def startDisplay(self): self.main_menu = MainMenu() self.main_menu.init() self.main_menu.secretsCallback = self.listSecrets self.main_menu.secretCallback = self.retrieveSecret self.main_menu.saltCallback = self.initEncryption self.main_menu.display()
class CreateGUI(tk.Tk): """The main class for the program Instance variables: edof: An noe x 7 array on the form array([[el_1, dof1, dof2...dof6], [el_noe, dof1, dof2...dof6]]) """ def __init__(self): tk.Tk.__init__(self) self.title("Frame 2000") self.state('zoomed') self.iconbitmap('icon_beam_2000.ico') self.resizable(False, False) # Create a list for storing instances of the element class self.element_list = [] # Create a dictionary to store the topology information self.edof = np.empty((0, 7), float) # Create instances of window content self.menubar = Menubar(self) self.canvas = Canvas(self) self.main_menu = MainMenu(self) # Place the instances in the window self.canvas.pack(side="left", fill="both", expand=1, pady=20, padx=20) self.main_menu.pack(side="right", fill=tk.Y, padx=10)
def test_add_task(self, mock_stdout): # Test adding task with a date provided main_menu = MainMenu() test_name = "John Doe" task_title = "Testing Task Title2" task_timespent = "30" task_notes = "coding!" datestr = "03/18/1981" prompts = [ test_name, datestr, task_title, task_timespent, task_notes, 'y', 'q' ] with mock.patch('builtins.input', side_effect=prompts): added_successfully = main_menu.add_task() self.assertTrue(added_successfully) # test adding task without date task_title = "Testing Task Title3" prompts = [ test_name, "", task_title, task_timespent, task_notes, 'y', 'q' ] with mock.patch('builtins.input', side_effect=prompts): added_successfully = main_menu.add_task() self.assertTrue(added_successfully)
def test_delete_task(self, mock_stdout): main_menu = MainMenu() test_name = "John Doe" task_title = "Testing Task To be deleted" task_timespent = "1" task_notes = "to be deleted" datestr = "07/04/1776" prompts = [ test_name, datestr, task_title, task_timespent, task_notes, 'y', 'q' ] with mock.patch('builtins.input', side_effect=prompts): main_menu.add_task() task_search = TaskSearch() prompts = ["07/04/1776", 'd', 'y', 'q', 'q'] with mock.patch('builtins.input', side_effect=prompts): task_search.search_by_taskdate() sdate = convertdate("07/04/1976") tasks = Task.select().where( Task.timestamp.year == sdate.year \ and Task.timestamp.month == sdate.month \ and Task.timestamp.day == sdate.day) self.assertEquals(len(tasks), 0)
class MyApp(ShowBase): def __init__(self): ShowBase.__init__(self) self.root_node = None self.clean_up() self.set_background_color(0, 0, 0) self.game = Game(self, self.main_menu) self.mm = MainMenu(self, self.start_game) self.main_menu() def clean_up(self): self.ignore_all() if self.root_node is not None: self.root_node.remove_node() for child in self.aspect2d.get_children(): child.remove_node() self.root_node = NodePath('root_node') self.root_node.reparent_to(self.render) self.accept("escape", sys.exit) # Escape quits def start_game(self): self.clean_up() self.game.run(self.root_node, self.start_game) def main_menu(self): self.clean_up() self.mm.show()
def start_screen(self): funcs = {'New Game': self.new, 'Load': self.load_game, 'Options': self.options, 'Quit': self.quit} mm = MainMenu(self.screen, funcs.keys(), funcs) mm.menu_run()
def __init__(self): ShowBase.__init__(self) self.root_node = None self.clean_up() self.set_background_color(0, 0, 0) self.game = Game(self, self.main_menu) self.mm = MainMenu(self, self.start_game) self.main_menu()
def test_add_task_employee_not_found(self, mock_stdout): main_menu = MainMenu() test_name = "Employee Notfound" task_title = "Testing Task Title" task_timespent = "30" task_notes = "Testing out code" prompts = [ test_name, " ", task_title, task_timespent, task_notes, 'y', 'q' ] with mock.patch('builtins.input', side_effect=prompts): added_successfully = main_menu.add_task() self.assertFalse(added_successfully)
def __init__(self): tk.Tk.__init__(self) self.title("Frame 2000") self.state('zoomed') self.iconbitmap('icon_beam_2000.ico') self.resizable(False, False) # Create instances of window content self.menubar = Menubar(self) self.canvas = Canvas(self) self.main_menu = MainMenu(self) # Place the instances in the window self.canvas.pack(side="left", fill="both", expand=1, pady=20, padx=20) self.main_menu.pack(side="right", fill=tk.Y, padx=10)
def __init__(self): pygame.init() # Initialize screen, and sets screen size self.surface = pygame.display.set_mode(size=(720, 640), flags=pygame.DOUBLEBUF) pygame.display.set_caption('Testing Game') self.game_state_manager = GameStateManager(self.surface, MainMenu(self.surface)) self.clock = pygame.time.Clock() # Creates instance of clock class
def __init__(self): themed_tk.ThemedTk.__init__(self) self.set_theme("arc") ttk.Style(self) self.horizontal_panel = ttk.PanedWindow(self, orient="horizontal") self.vertical_panel = ttk.PanedWindow(self, orient="vertical") self.side_view = Notebook(self, has_labels=True) self.node = NodeEditor(self) self.console = Interpreter(self) self.modules = ModuleTree(self) self.objects = ObjectTree(self) self.vertical_panel.add(self.node.frame) self.vertical_panel.add(self.console.frame) self.side_view.add("Modules", self.modules) self.side_view.add("Objects", self.objects) self.horizontal_panel.add(self.side_view.frame) self.horizontal_panel.add(self.vertical_panel) self.horizontal_panel.pack(side="left", fill="both", expand=True) self.animate = Animation(self) self.project = SaveData(self) self.menu = MainMenu(self) self.config(menu=self.menu) self.project.load(is_first_load=True)
def main(): pygame.init() pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) pygame.display.set_caption('pyAsteroids') screen = pygame.display.get_surface() MainMenu(screen)
def __init__(self): self.screenSize = (800, 600) self.backgroundColor = (230, 230, 230) self.screen = pygame.display.set_mode(self.screenSize) self.clock = pygame.time.Clock() self.sceneStack = Stack() self.sceneStack.push(MainMenu(self)) pygame.display.set_caption("Final Flautist")
def main(): while True: #Setup objects mainMenu = MainMenu(surface) game = Levels(surface) timeline = Timeline(surface, mainClock) #Load music and play it if sound is on pygame.mixer.music.load('data\\sound\\Godbless.mid') if sound: pygame.mixer.music.play(-1, 0.0) #Display main menu mainMenu.menu(mainClock) #Select level timeline.timeline() #Run level 1620 game.Y1620(mainClock)
class PasswordVault: storage_file = "/home/pi/password-vault-server/vault.json" if not debug.isDebug( ) else "vault.json" storage = None encryption = None main_menu = None def __init__(self): self.storage = Storage(self.storage_file) def startDisplay(self): self.main_menu = MainMenu() self.main_menu.init() self.main_menu.secretsCallback = self.listSecrets self.main_menu.secretCallback = self.retrieveSecret self.main_menu.saltCallback = self.initEncryption self.main_menu.display() def initEncryption(self, salt): self.encryption = Encryption(salt) # Validation secrets = self.storage.read() keys = list(secrets) if len(keys) > 0: return self.encryption.validate(secrets[keys[0]]) return False def addSecret(self, key, secret): encoded_secret = self.encryption.encode(secret) secrets = self.storage.read() secrets[key] = encoded_secret self.storage.save(secrets) def listSecrets(self): secrets = self.storage.read() return list(secrets.keys()) def retrieveSecret(self, key): secrets = self.storage.read() hashed_secret = secrets[key] decoded_secret = self.encryption.decode(hashed_secret) return decoded_secret
def __init__(self): tk.Tk.__init__(self) self.title("Frame 2000") self.state('zoomed') self.iconbitmap('icon_beam_2000.ico') self.resizable(False, False) # Create a list for storing instances of the element class self.element_list = [] # Create a dictionary to store the topology information self.edof = np.empty((0, 7), float) # Create instances of window content self.menubar = Menubar(self) self.canvas = Canvas(self) self.main_menu = MainMenu(self) # Place the instances in the window self.canvas.pack(side="left", fill="both", expand=1, pady=20, padx=20) self.main_menu.pack(side="right", fill=tk.Y, padx=10)
class Main(ShowBase): def __init__(self): ShowBase.__init__(self) self.login = Login(self) def startMainmenu(self): self.login.hide() self.mainmenu = MainMenu(self) self.pregame = Pregame(self) self.mainmenu.show() def startPregame(self): self.mainmenu.hide() self.pregame.reset() self.pregame.show() def returnToMenu(self): self.pregame.hide() self.mainmenu.show() def startRound(self): self.pregame.hide() self.round = Round(self) def endRound(self): self.round.destroy() del self.round self.pregame.show() def hostGame(self, params): pid = Popen(["python", "server.py", params]).pid print 'Server Process ID:', pid def quit(self): sys.exit()
def main(self): """ Lancement du jeu """ pygame.init() # Lance de Pygame screen = pygame.display.set_mode( (self.width, self.height)) # Crée la fenêtre pygame.display.set_caption( 'PyDragon v0.4') # Donne un nom à la fenêtre pygame.display.set_icon(pygame.image.load( self.favicon)) # Favicon du jeu self.son = pygame.mixer.Sound( "ressources/sounds/DBZFighter.wav") # Défini le son du jeu self.son.set_volume(0.3) # Permet de diminuer le son par défaut du jeu clock = pygame.time.Clock() # Calcule le temps de départ pour les FPS while Niveau.WHILE_GAME: # Boucle principale qui sert aux importations de maps if Niveau.LVL == 'while_main_menu': # Nom défini qui orchestre tous les imports liés main_menu = MainMenu( screen, clock, self.fps, self.son ) # Instancie la class qui affiche le menu de départ main_menu.while_menu() # Boucle sur le menu elif Niveau.LVL == 'while_map_kamehouse': map_kamehouse = Kamehouse(self.width, self.height, screen, clock, self.fps, self.avancer) map_kamehouse.while_kamehouse() # Boucle sur la map elif Niveau.LVL == 'while_map_kamehouse_in': map_kamehouse_in = KamehouseIn(self.width, self.height, screen, clock, self.fps, self.avancer) map_kamehouse_in.while_kamehouse_in() # Boucle sur la map elif Niveau.LVL == 'while_map_town': map_world = WorldTown(self.width, self.height, screen, clock, self.fps, self.avancer) map_world.while_town() # Boucle sur la map elif Niveau.LVL == 'while_map_town_in': map_world = WorldTownIn(self.width, self.height, screen, clock, self.fps, self.avancer) map_world.while_town_in() # Boucle sur la map pygame.quit() # Arrête le processus de PyGame
def build(self): sm = ScreenManager() menu = MainMenu(name='menu') sed = StartEndDate(name='sed') settingscreen = SettingsScreen(name="settingscreen") task = TaskScreen(name='task') task_results = TaskResultsScreen(name='task_results') sm.add_widget(menu) sm.add_widget(task) sm.add_widget(settingscreen) sm.add_widget(sed) sm.add_widget(task_results) return sm
def initPages(self): self.mode_stack = QtGui.QStackedWidget() main_menu = MainMenu(self) #0 self.stats = Statistics(self) #1 self.trainer = Trainer(self, self.stats) #2 self.generator = Generator(self) #3 self.mode_stack.addWidget(main_menu) self.mode_stack.addWidget(self.stats) self.mode_stack.addWidget(self.trainer) self.mode_stack.addWidget(self.generator) self.setCentralWidget(self.mode_stack)
def __init__(self): super().__init__() self.mainMenu = MainMenu() self.selectGame = SelectGame() self.settings = Settings() self.installGames = InstallGames() self.manageCharacters = ManageCharacters() self.viewCharacter = ViewCharacter() self.addWidget(self.mainMenu) self.addWidget(self.selectGame) self.addWidget(self.settings) self.addWidget(self.installGames) self.addWidget(self.manageCharacters) self.addWidget(self.viewCharacter) self.mainMenu.setCreateCharacterCallback(self.showSelectGame) self.mainMenu.setManageCharactersCallback(self.showManageCharacters) self.mainMenu.setSettingsCallback(self.showSettings) self.selectGame.setBackCallback(self.showMainMenu) self.selectGame.setInstallGamesCallback(self.showInstallGames) self.settings.setBackCallback(self.showMainMenu) self.installGames.setBackCallback(self.showSelectGame) self.manageCharacters.setBackCallback(self.showMainMenu) self.manageCharacters.setViewCallback(self.showViewCharacter) self.viewCharacter.setBackCallback(self.showManageCharacters)
def run_game(): '''Run Game of Life.''' pygame.init() game_settings = Settings() screen = pygame.display.set_mode((game_settings.screen_width, game_settings.screen_height)) pygame.display.set_caption("Game of Life") # There is only one cell. cell = Cell(screen, game_settings) # Set main menu. main = MainMenu() # Set available options. options = Options(screen, game_settings) # Set speed and speed bar. speed = Speed(screen, game_settings) to_drop = [speed.actual_drop] # Set pause menu. state = Status(screen) # Build the matrix for live cells coordinates. mat_rows = game_settings.screen_height // game_settings.cell_height + 2 mat_cols = game_settings.screen_width // game_settings.cell_width + 2 cells_matrix = np.zeros(shape = (mat_rows, mat_cols)).astype(bool) xmouse, ymouse = None, None # Set to False the single step option. move_to_next_step = [False] while 1: gf.check_events(state, speed, main, options, xmouse, ymouse, move_to_next_step) if main.menu: xmouse, ymouse = pygame.mouse.get_pos() gf.main_menu(xmouse, ymouse, game_settings, state, speed, main, options, cells_matrix) elif not state.pause or move_to_next_step[0]: gf.game(move_to_next_step, cells_matrix, game_settings, state, speed, to_drop) gf.update_screen(game_settings, screen, cells_matrix, state, speed, main, options, cell)
def main(): ### Initialize status variables done = False inMenu = True ### Initialize pygame pygame.init() screen = pygame.display.set_mode(WINDOW_SIZE) pygame.display.set_caption("Boston Cream") screen.fill(BLACK) ### Create game clock clock = pygame.time.Clock() ### Create menu and game objects print("Building menu") menu = MainMenu(screen) print("Building game") game = Game(screen) while not done: if inMenu: done, inMenu = menu.handle_events() menu.handle_logic() menu.handle_graphics() elif not inMenu: done, inMenu = game.handle_events() game.handle_logic() game.handle_graphics() else: print("Error: Neither in menu or in game...") clock.tick(FPS) pygame.quit()
from searchspreadsheet import SearchSpreadsheet from countcolumninstances import CountColumnInstances from createcertificates import CreateCertificates from mainmenu import MainMenu main_menu = MainMenu() if main_menu.choice == "1": SearchSpreadsheet() if main_menu.choice == "2": CountColumnInstances() if main_menu.choice == "3": CreateCertificates()
def NodeAdmin(): MainMenu()
def startMainmenu(self): self.login.hide() self.mainmenu = MainMenu(self) self.pregame = Pregame(self) self.mainmenu.show()
def postInit(self): # Some game related variables self.currentLevel = 1 self.youWon = False # Set esc to force exit $ remove self.accept('escape', self.exitApp) # Menu Events self.accept("menu_StartGame", self.startGame) self.accept("menu_Options", self.request, ["Options"]) self.accept("menu_QuitGame", self.exitApp) self.accept("menu_Back", self.request, ["Menu"]) self.accept("n", self.playNextTrack) ## Load Menu self.mainMenu = MainMenu() self.optionsMenu = OptionsMenu() ## Load music list self.musicList = [ [ "Housewell - Housewell - Sea Sun Fun", loader.loadMusic( "music/Housewell_-_Housewell_-_Sea__Sun__Fun.ogg") ], [ "KontrastE - LISTEN TO NIGHT", loader.loadMusic("music/KontrastE_-_LISTEN_TO_NIGHT.ogg") ], [ "LukHash - THE OTHER SIDE", loader.loadMusic("music/LukHash_-_THE_OTHER_SIDE.ogg") ], [ "Axl & Arth - Breathe", loader.loadMusic("music/Axl__amp__Arth_-_Breathe.ogg") ], [ "Lyonn - The Symphony", loader.loadMusic("music/Lyonn_-_The_Symphony.ogg") ], ] self.lblNowPlaying = DirectLabel(text="No track running!", text_align=TextNode.ARight, text_fg=(240 / 255.0, 255 / 255.0, 240 / 255.0, 0.75), pos=(base.a2dRight - 0.05, 0, base.a2dBottom + 0.1), scale=0.04, frameColor=(0, 0, 0, 0.5), sortOrder=10) self.lblNowPlaying.hide() # The games Intro def create16To9LogoCard(logoPath, tsName): cm = CardMaker("fade") scale = abs(base.a2dLeft) / 1.7776 cm.setFrame(-1, 1, -1 * scale, 1 * scale) logo = NodePath(cm.generate()) logo.setTransparency(TransparencyAttrib.MAlpha) logoTex = loader.loadTexture(logoPath) logoTs = TextureStage(tsName) logoTs.setMode(TextureStage.MReplace) logo.setTexture(logoTs, logoTex) logo.setBin("fixed", 5000) logo.reparentTo(render2d) logo.hide() return logo self.gfLogo = create16To9LogoCard("intro/GrimFangLogo.png", "gfLogoTS") self.pandaLogo = create16To9LogoCard("intro/Panda3DLogo.png", "pandaLogoTS") self.gameLogo = create16To9LogoCard("intro/GameLogo.png", "gameLogoTS") def createFadeIn(logo): return LerpColorScaleInterval(logo, 2, LVecBase4f(0.0, 0.0, 0.0, 1.0), LVecBase4f(0.0, 0.0, 0.0, 0.0)) def createFadeOut(logo): return LerpColorScaleInterval(logo, 2, LVecBase4f(0.0, 0.0, 0.0, 0.0), LVecBase4f(0.0, 0.0, 0.0, 1.0)) gfFadeInInterval = createFadeIn(self.gfLogo) gfFadeOutInterval = createFadeOut(self.gfLogo) p3dFadeInInterval = createFadeIn(self.pandaLogo) p3dFadeOutInterval = createFadeOut(self.pandaLogo) gameFadeInInterval = createFadeIn(self.gameLogo) gameFadeOutInterval = createFadeOut(self.gameLogo) self.introFadeInOutSequence = Sequence(Func(self.gfLogo.show), gfFadeInInterval, Wait(1.0), gfFadeOutInterval, Wait(0.5), Func(self.gfLogo.hide), Func(self.pandaLogo.show), p3dFadeInInterval, Wait(1.0), p3dFadeOutInterval, Wait(0.5), Func(self.pandaLogo.hide), Func(self.gameLogo.show), gameFadeInInterval, Wait(1.0), gameFadeOutInterval, Wait(0.5), Func(self.gameLogo.hide), Func(self.messenger.send, "intro_done"), Func(self.startMusic), name="fadeInOut") # game intro end # story intro self.storyImage1 = create16To9LogoCard("intro1.png", "storyIntro1TS") story1FadeInInterval = createFadeIn(self.storyImage1) story1FadeOutInterval = createFadeOut(self.storyImage1) self.storySequence = Sequence(Func(self.storyImage1.show), story1FadeInInterval, Wait(8.0), story1FadeOutInterval, Func(self.request, "Game"), name="story") # Outros self.outroImage1 = create16To9LogoCard("outro1.png", "storyOutro1TS") outro1FadeInInterval = createFadeIn(self.outroImage1) outro1FadeOutInterval = createFadeOut(self.outroImage1) self.outroWonSequence = Sequence(Func(self.outroImage1.show), outro1FadeInInterval, Wait(8.0), outro1FadeOutInterval, Func(self.request, "Game"), name="OutroWon") self.outroImage2 = create16To9LogoCard("outro2.png", "storyOutro2TS") outro2FadeInInterval = createFadeIn(self.outroImage2) outro2FadeOutInterval = createFadeOut(self.outroImage2) self.outroLostSequence = Sequence(Func(self.outroImage2.show), outro2FadeInInterval, Wait(8.0), outro2FadeOutInterval, Func(self.request, "Menu"), name="OutroLost") self.outroImage3 = create16To9LogoCard("outro3.png", "storyOutro3TS") outro3FadeInInterval = createFadeIn(self.outroImage3) outro3FadeOutInterval = createFadeOut(self.outroImage3) self.outroWonGameSequence = Sequence(Func(self.outroImage3.show), outro3FadeInInterval, Wait(8.0), outro3FadeOutInterval, Func(self.request, "Menu"), name="OutroWonGame") # # Start with the menu after the intro has been played # self.introFadeInOutSequence.start() self.accept("intro_done", self.request, ["Menu"])
for event in pg.event.get(): if event.type == pg.QUIT: self.done = True self.state.get_event(event) def main_game_loop(self): while not self.done: delta_time = self.clock.tick(60) / 1000 self.event_loop() self.update(delta_time) pg.display.update() #Settings from above dictionary get passed into Control class #Control creates app object. #Then, each state (Menu & Game) object get assigned to a dicitonary. #This allows control to be able to switch to and from any state as needed. app = Control() #State Dictionary. Include all state classes here. state_dict = {'mainmenu': MainMenu(), 'game': Game(), 'gameover': GameOver()} #Setup State is called and sets the initial state of the program app.setup_states(state_dict, 'mainmenu') #Call main game loop that runs whole program app.main_game_loop() pg.quit() sys.exit()
def build(self): return MainMenu()
class Main(ShowBase): def __init__(self): self.created_client = False ShowBase.__init__(self) self.login = Login(self) self.client = Client(LOGIN_IP, LOGIN_PORT, compress=True) if not self.client.getConnected(): self.login.updateStatus("Could not connect to the Login server") self.client = False def attempt_login(self, username, password): # check if processing a request already so if multiple presses of button it wont break this lol... # set a variable in login_packetReader() and check here # attempt to connect again if it failed on startup if not self.client: self.client = Client(LOGIN_IP, LOGIN_PORT, compress=True) if self.client.getConnected(): self.username = username # Setup the un/up sendpacket, this will be changed. later :P data = {} data[0] = 'login_request' data[1] = {} data[1][0] = username data[1][1] = password self.client.sendData(data) # Add the handler for the login stage. taskMgr.doMethodLater(0.2, self.login_packetReader, 'Update Login') return True else: # client not connected to login/auth server so display message self.login.updateStatus("Could not connect to the Login server") self.client = False def create_account(self, username, password): # should be similar to attempt_login() but sends 'create_request' rather than 'login_request' # similarly need a create_packetReader() task to check for account_created success packet # then automatically call attempt_login with the username and password pass def login_packetReader(self, task): # setup some sort of timeout checker which will unset the checker variable in attempt_login function so it can go again # i think also for the 'db_reply' instead use the hex codes like you were thinking, and have each seperate code like 'already logged' 'wrong password/username' 'whatever else' # so on a return of a failure aswell, it will need to stop this task (return task.done) temp = self.client.getData() if temp != []: for i in range(len(temp)): valid_packet = False package = temp[i] if len(package) == 2: print "Received: " + str(package) print "Connected to login server" # updates warlocks in game """if package[0]=='error': print package print "User already logged" self.login.updateStatus(package[1]) valid_packet=True break""" if package[0] == 'db_reply': print "DB: " + str(package[1]) self.login.updateStatus(package[1]) valid_packet = True elif package[0] == 'login_valid': print "Login valid: " + str(package[1]) self.login.updateStatus(package[1][0]) print "success: " + str(package[1][1]) valid_packet = True print "I should move to main menu now..." taskMgr.doMethodLater(0.3, self.start_mainmenu, 'Start Main Menu') return task.done """if not valid_packet: data = {} data[0] = "error" data[1] = "Fail Server" self.client.sendData(data) print "Bad packet from server""" else: print "Packet wrong size" return task.again def start_mainmenu(self, task): self.login.destroy() self.mainmenu = MainMenu(self) return task.done def join_server(self, address): # Store connection to lobby and chat i guess eventually self.lobby_con = self.client # attempt to connect to the game server self.client = Client(address, 9099, compress=True) if self.client.getConnected(): print "Connected to server" data = {} data[0] = "username" data[ 1] = self.username # This will end up being the selected server? self.client.sendData(data) taskMgr.doMethodLater( 0.03, self.start_pregame, 'Start Pregame') # I guess this should change to Pregame. return True else: return False def start_pregame(self, task): self.mainmenu.hide() self.pregame = Pregame(self) return task.done def begin_preround(self): print "Game Starting" taskMgr.doMethodLater(0.01, self.start_preround, 'Start Preround') def start_preround(self, task): self.pregame.hide() self.preround = Preround(self) return task.done def begin_round(self): print "Round Starting" taskMgr.doMethodLater(0.01, self.start_round, 'Start Round') def start_round(self, task): self.preround.hide() self.round = Round(self) return task.done def quit(self): sys.exit()
class Main(ShowBase): def __init__(self): self.created_client=False ShowBase.__init__(self) self.prelobby=PreLobby(self) def login(self,username,password): self.username=username self.status=OnscreenText(text = "Attempting to login...", pos = Vec3(0, -0.4, 0), scale = 0.05, fg = (1, 0, 0, 1), align=TextNode.ACenter) # simulate authentication by delaying before continuing # if authentication fails, create prelobby again with status text "LOGIN FAILED!" #self.prelobby=PreLobby(self,"LOGIN FAILED!") # else proceed to lobby state taskMgr.doMethodLater(0.01, self.start_mainmenu, 'Start MainMenu') def start_mainmenu(self,task): self.prelobby.destroy() self.status.destroy() self.mainmenu=MainMenu(self) return task.done def join_server(self,address): # Connect to our server self.client = Client(address, 9099, compress=True) if self.client.getConnected(): self.created_client=True data = {} data[0]="username" data[1]=self.username self.client.sendData(data) taskMgr.doMethodLater(0.01, self.start_lobby, 'Start Lobby') return True else: return False def start_lobby(self,task): self.mainmenu.hide() self.status.destroy() self.lobby=Lobby(self) return task.done def join_game(self): print "Game Starting" taskMgr.doMethodLater(0.01, self.start_game, 'Start Game') def start_game(self,task): self.lobby.hide() self.status.destroy() self.pregame=Pregame(self) return task.done def begin_round(self): print "Game Starting" taskMgr.doMethodLater(0.01, self.start_round, 'Start Round') def start_round(self,task): #self.pregame.hide() #self.status.destroy() self.playstate=Playstate(self) return task.done def quit(self): sys.exit()
pygame.display.set_caption('Glarf') #pygame.mouse.set_visible(0) #Create The Backgound bgMangr = SeamedBackgroundManager(screen) #Display The Background screen.blit(bgMangr.GetBackground(), (0, 0)) pygame.display.flip() #Prepare Game Objects clock = pygame.time.Clock() musicMangr = MusicManager() displayer = MainMenu(bgMangr, musicMangr) #Main Loop oldfps = 0 while 1: timeChange = clock.tick(40) newfps = int(clock.get_fps()) #if newfps != oldfps: #print "fps: ", newfps #oldfps = newfps #Handle Input Events remainingEvents = pygame.event.get() for event in remainingEvents: upKeys = filter(allKUPs, remainingEvents) if event.type == QUIT:
class Main(ShowBase, FSM): def __init__(self): ShowBase.__init__(self) FSM.__init__(self, "mainStateMachine") # some basic enhancements # window background color self.setBackgroundColor(0, 0, 0) # set antialias for the complete sceen to automatic self.render.setAntialias(AntialiasAttrib.MAuto) # shader generator render.setShaderAuto() # Enhance font readability DGG.getDefaultFont().setPixelsPerUnit(100) # hide the mouse cursor hide_cursor() # # CONFIGURATION LOADING # # load given variables or set defaults # check if audio should be muted mute = ConfigVariableBool("audio-mute", False).getValue() if mute: self.disableAllAudio() else: self.enableAllAudio() base.sfxManagerList[0].setVolume( ConfigVariableDouble("audio-volume-sfx", 1.0).getValue()) base.difficulty = ConfigVariableInt("difficulty", 0).getValue() def setFullscreen(): """Helper function to set the window fullscreen with width and height set to the screens size""" # get the displays width and height w = self.pipe.getDisplayWidth() h = self.pipe.getDisplayHeight() # set window properties # clear all properties not previously set base.win.clearRejectedProperties() # setup new window properties props = WindowProperties() # Fullscreen props.setFullscreen(True) # set the window size to the screen resolution props.setSize(w, h) # request the new properties base.win.requestProperties(props) # check if the config file hasn't been created if not os.path.exists(prcFile): setFullscreen() elif base.appRunner: # When the application is started as appRunner instance, it # doesn't respect our loadPrcFiles configurations specific # to the window as the window is already created, hence we # need to manually set them here. for dec in range(mainConfig.getNumDeclarations()): # check if we have the fullscreen variable if mainConfig.getVariableName(dec) == "fullscreen": setFullscreen() # automatically safe configuration at application exit base.exitFunc = self.__writeConfig # due to the delayed window resizing and switch to fullscreen # we wait some time until everything is set so we can savely # proceed with other setups like the menus if base.appRunner: # this behaviour only happens if run from p3d files and # hence the appRunner is enabled taskMgr.doMethodLater(0.5, self.postInit, "post initialization", extraArgs=[]) else: self.postInit() def postInit(self): # Some game related variables self.currentLevel = 1 self.youWon = False # Set esc to force exit $ remove self.accept('escape', self.exitApp) # Menu Events self.accept("menu_StartGame", self.startGame) self.accept("menu_Options", self.request, ["Options"]) self.accept("menu_QuitGame", self.exitApp) self.accept("menu_Back", self.request, ["Menu"]) self.accept("n", self.playNextTrack) ## Load Menu self.mainMenu = MainMenu() self.optionsMenu = OptionsMenu() ## Load music list self.musicList = [ [ "Housewell - Housewell - Sea Sun Fun", loader.loadMusic( "music/Housewell_-_Housewell_-_Sea__Sun__Fun.ogg") ], [ "KontrastE - LISTEN TO NIGHT", loader.loadMusic("music/KontrastE_-_LISTEN_TO_NIGHT.ogg") ], [ "LukHash - THE OTHER SIDE", loader.loadMusic("music/LukHash_-_THE_OTHER_SIDE.ogg") ], [ "Axl & Arth - Breathe", loader.loadMusic("music/Axl__amp__Arth_-_Breathe.ogg") ], [ "Lyonn - The Symphony", loader.loadMusic("music/Lyonn_-_The_Symphony.ogg") ], ] self.lblNowPlaying = DirectLabel(text="No track running!", text_align=TextNode.ARight, text_fg=(240 / 255.0, 255 / 255.0, 240 / 255.0, 0.75), pos=(base.a2dRight - 0.05, 0, base.a2dBottom + 0.1), scale=0.04, frameColor=(0, 0, 0, 0.5), sortOrder=10) self.lblNowPlaying.hide() # The games Intro def create16To9LogoCard(logoPath, tsName): cm = CardMaker("fade") scale = abs(base.a2dLeft) / 1.7776 cm.setFrame(-1, 1, -1 * scale, 1 * scale) logo = NodePath(cm.generate()) logo.setTransparency(TransparencyAttrib.MAlpha) logoTex = loader.loadTexture(logoPath) logoTs = TextureStage(tsName) logoTs.setMode(TextureStage.MReplace) logo.setTexture(logoTs, logoTex) logo.setBin("fixed", 5000) logo.reparentTo(render2d) logo.hide() return logo self.gfLogo = create16To9LogoCard("intro/GrimFangLogo.png", "gfLogoTS") self.pandaLogo = create16To9LogoCard("intro/Panda3DLogo.png", "pandaLogoTS") self.gameLogo = create16To9LogoCard("intro/GameLogo.png", "gameLogoTS") def createFadeIn(logo): return LerpColorScaleInterval(logo, 2, LVecBase4f(0.0, 0.0, 0.0, 1.0), LVecBase4f(0.0, 0.0, 0.0, 0.0)) def createFadeOut(logo): return LerpColorScaleInterval(logo, 2, LVecBase4f(0.0, 0.0, 0.0, 0.0), LVecBase4f(0.0, 0.0, 0.0, 1.0)) gfFadeInInterval = createFadeIn(self.gfLogo) gfFadeOutInterval = createFadeOut(self.gfLogo) p3dFadeInInterval = createFadeIn(self.pandaLogo) p3dFadeOutInterval = createFadeOut(self.pandaLogo) gameFadeInInterval = createFadeIn(self.gameLogo) gameFadeOutInterval = createFadeOut(self.gameLogo) self.introFadeInOutSequence = Sequence(Func(self.gfLogo.show), gfFadeInInterval, Wait(1.0), gfFadeOutInterval, Wait(0.5), Func(self.gfLogo.hide), Func(self.pandaLogo.show), p3dFadeInInterval, Wait(1.0), p3dFadeOutInterval, Wait(0.5), Func(self.pandaLogo.hide), Func(self.gameLogo.show), gameFadeInInterval, Wait(1.0), gameFadeOutInterval, Wait(0.5), Func(self.gameLogo.hide), Func(self.messenger.send, "intro_done"), Func(self.startMusic), name="fadeInOut") # game intro end # story intro self.storyImage1 = create16To9LogoCard("intro1.png", "storyIntro1TS") story1FadeInInterval = createFadeIn(self.storyImage1) story1FadeOutInterval = createFadeOut(self.storyImage1) self.storySequence = Sequence(Func(self.storyImage1.show), story1FadeInInterval, Wait(8.0), story1FadeOutInterval, Func(self.request, "Game"), name="story") # Outros self.outroImage1 = create16To9LogoCard("outro1.png", "storyOutro1TS") outro1FadeInInterval = createFadeIn(self.outroImage1) outro1FadeOutInterval = createFadeOut(self.outroImage1) self.outroWonSequence = Sequence(Func(self.outroImage1.show), outro1FadeInInterval, Wait(8.0), outro1FadeOutInterval, Func(self.request, "Game"), name="OutroWon") self.outroImage2 = create16To9LogoCard("outro2.png", "storyOutro2TS") outro2FadeInInterval = createFadeIn(self.outroImage2) outro2FadeOutInterval = createFadeOut(self.outroImage2) self.outroLostSequence = Sequence(Func(self.outroImage2.show), outro2FadeInInterval, Wait(8.0), outro2FadeOutInterval, Func(self.request, "Menu"), name="OutroLost") self.outroImage3 = create16To9LogoCard("outro3.png", "storyOutro3TS") outro3FadeInInterval = createFadeIn(self.outroImage3) outro3FadeOutInterval = createFadeOut(self.outroImage3) self.outroWonGameSequence = Sequence(Func(self.outroImage3.show), outro3FadeInInterval, Wait(8.0), outro3FadeOutInterval, Func(self.request, "Menu"), name="OutroWonGame") # # Start with the menu after the intro has been played # self.introFadeInOutSequence.start() self.accept("intro_done", self.request, ["Menu"]) def exitApp(self): if self.state == "Off": self.introFadeInOutSequence.finish() elif self.state == "Menu": self.userExit() elif self.state == "Intro": self.storySequence.finish() elif self.state == "Outro": if self.youWon: if self.currentLevel == 2: self.outroWonSequence.finish() else: self.outroWonGameSequence.finish() else: self.outroLostSequence.finish() else: self.request("Menu") def startMusic(self): self.lblNowPlaying.show() self.lastPlayed = None self.currentTrack = [None] self.playNextTrack() base.taskMgr.add(self.musicTask, "music playlist") def playNextTrack(self): if self.currentTrack[0] is not None: self.currentTrack[1].stop() while self.lastPlayed == self.currentTrack[0]: self.currentTrack = random.choice(self.musicList) self.lastPlayed = self.currentTrack[0] self.lblNowPlaying[ "text"] = "Press 'N' for Next ~\nNOW PLAYING: {}".format( self.currentTrack[0]) self.lblNowPlaying.resetFrameSize() self.currentTrack[1].play() def musicTask(self, task): if not base.AppHasAudioFocus: return task.cont track = self.currentTrack[1] if track.status() != track.PLAYING: self.playNextTrack() return task.cont def startGame(self): self.acceptWinLoose() self.currentLevel = 1 self.request("Intro") def enterMenu(self): show_cursor() self.mainMenu.show() def exitMenu(self): self.mainMenu.hide() def enterOptions(self): self.optionsMenu.show() def exitOptions(self): self.optionsMenu.hide() def enterIntro(self): self.storySequence.start() def enterGame(self): self.youWon = False hide_cursor() ## Load/Start GameBase self.gamebase = GameBase() ## Load/Start Game self.game = Game() self.gamebase.start() self.game.setPhysicsWorld(self.gamebase.physics_world) if base.difficulty == 0: self.game.start(self.currentLevel, 25) elif base.difficulty == 1: self.game.start(self.currentLevel, 50) else: self.game.start(self.currentLevel, 100) self.acceptWinLoose() # Debug # #self.gamebase.enablePhysicsDebug() #print (render.ls()) def exitGame(self): self.ignoreWinLoose() self.game.stop() self.gamebase.stop() del self.game del self.gamebase self.game = None self.gamebase = None def enterOutro(self): if self.youWon: if self.currentLevel == 1: self.outroWonSequence.start() else: self.outroWonGameSequence.start() else: self.outroLostSequence.start() def wonGame(self): self.ignoreWinLoose() self.youWon = True self.request("Outro") self.currentLevel += 1 def lostGame(self): self.ignoreWinLoose() self.youWon = False self.request("Outro") def acceptWinLoose(self): self.accept("wonGame", self.wonGame) self.accept("lostGame", self.lostGame) def ignoreWinLoose(self): self.ignore("wonGame") self.ignore("lostGame") def __writeConfig(self): """Save current config in the prc file or if no prc file exists create one. The prc file is set in the prcFile variable""" page = None volume = str(round(base.musicManager.getVolume(), 2)) volumeSfx = str(round(base.sfxManagerList[0].getVolume(), 2)) mute = "#f" if base.AppHasAudioFocus else "#t" difficuty = str(base.difficulty) customConfigVariables = [ "", "audio-mute", "audio-volume", "audio-volume-sfx", "difficulty" ] if os.path.exists(prcFile): # open the config file and change values according to current # application settings page = loadPrcFile(prcFile) removeDecls = [] for dec in range(page.getNumDeclarations()): # Check if our variables are given. # NOTE: This check has to be done to not loose our base or other # manual config changes by the user if page.getVariableName(dec) in customConfigVariables: decl = page.modifyDeclaration(dec) removeDecls.append(decl) for dec in removeDecls: page.deleteDeclaration(dec) # NOTE: audio-mute are custom variables and # have to be loaded by hand at startup # audio page.makeDeclaration("audio-volume", volume) page.makeDeclaration("audio-volume-sfx", volumeSfx) page.makeDeclaration("audio-mute", mute) page.makeDeclaration("difficulty", difficuty) else: # Create a config file and set default values cpMgr = ConfigPageManager.getGlobalPtr() page = cpMgr.makeExplicitPage("App Pandaconfig") # set OpenGL to be the default page.makeDeclaration("load-display", "pandagl") # get the displays width and height w = self.pipe.getDisplayWidth() h = self.pipe.getDisplayHeight() # set the window size in the config file page.makeDeclaration("win-size", "%d %d" % (w, h)) # set the default to fullscreen in the config file page.makeDeclaration("fullscreen", "1") # audio page.makeDeclaration("audio-volume", volume) page.makeDeclaration("audio-volume-sfx", volumeSfx) page.makeDeclaration("audio-mute", "#f") page.makeDeclaration("sync-video", "1") page.makeDeclaration("textures-auto-power-2", "1") page.makeDeclaration("framebuffer-multisample", "1") page.makeDeclaration("multisamples", "2") page.makeDeclaration("texture-anisotropic-degree", "0") page.makeDeclaration("difficulty", 0) # create a stream to the specified config file configfile = OFileStream(prcFile) # and now write it out page.write(configfile) # close the stream configfile.close()
def start_mainmenu(self,task): self.login.destroy() self.mainmenu=MainMenu(self) return task.done
class Main(ShowBase): def __init__(self): self.created_client=False ShowBase.__init__(self) self.login=Login(self) self.client = Client(LOGIN_IP, LOGIN_PORT, compress=True) if not self.client.getConnected(): self.login.updateStatus("Could not connect to the Login server") self.client=False def attempt_login(self, username, password): # check if processing a request already so if multiple presses of button it wont break this lol... # set a variable in login_packetReader() and check here # attempt to connect again if it failed on startup if not self.client: self.client = Client(LOGIN_IP, LOGIN_PORT, compress=True) if self.client.getConnected(): self.username=username # Setup the un/up sendpacket, this will be changed. later :P data = {} data[0] = 'login_request' data[1] = {} data[1][0] = username data[1][1] = password self.client.sendData(data) # Add the handler for the login stage. taskMgr.doMethodLater(0.2, self.login_packetReader, 'Update Login') return True else: # client not connected to login/auth server so display message self.login.updateStatus("Could not connect to the Login server") self.client=False def create_account(self, username, password): # should be similar to attempt_login() but sends 'create_request' rather than 'login_request' # similarly need a create_packetReader() task to check for account_created success packet # then automatically call attempt_login with the username and password pass def login_packetReader(self, task): # setup some sort of timeout checker which will unset the checker variable in attempt_login function so it can go again # i think also for the 'db_reply' instead use the hex codes like you were thinking, and have each seperate code like 'already logged' 'wrong password/username' 'whatever else' # so on a return of a failure aswell, it will need to stop this task (return task.done) temp=self.client.getData() if temp!=[]: for i in range(len(temp)): valid_packet=False package=temp[i] if len(package)==2: print "Received: " + str(package) print "Connected to login server" # updates warlocks in game """if package[0]=='error': print package print "User already logged" self.login.updateStatus(package[1]) valid_packet=True break""" if package[0]=='db_reply': print "DB: "+str(package[1]) self.login.updateStatus(package[1]) valid_packet=True elif package[0]=='login_valid': print "Login valid: "+str(package[1]) self.login.updateStatus(package[1][0]) print "success: "+str(package[1][1]) valid_packet=True print "I should move to main menu now..." taskMgr.doMethodLater(0.3, self.start_mainmenu, 'Start Main Menu') return task.done """if not valid_packet: data = {} data[0] = "error" data[1] = "Fail Server" self.client.sendData(data) print "Bad packet from server""" else: print "Packet wrong size" return task.again def start_mainmenu(self,task): self.login.destroy() self.mainmenu=MainMenu(self) return task.done def join_server(self,address): # Store connection to lobby and chat i guess eventually self.lobby_con=self.client # attempt to connect to the game server self.client = Client(address, 9099, compress=True) if self.client.getConnected(): print "Connected to server" data = {} data[0]="username" data[1]=self.username # This will end up being the selected server? self.client.sendData(data) taskMgr.doMethodLater(0.03, self.start_pregame, 'Start Pregame') # I guess this should change to Pregame. return True else: return False def start_pregame(self,task): self.mainmenu.hide() self.pregame=Pregame(self) return task.done def begin_preround(self): print "Game Starting" taskMgr.doMethodLater(0.01, self.start_preround, 'Start Preround') def start_preround(self,task): self.pregame.hide() self.preround=Preround(self) return task.done def begin_round(self): print "Round Starting" taskMgr.doMethodLater(0.01, self.start_round, 'Start Round') def start_round(self,task): self.preround.hide() self.round=Round(self) return task.done def quit(self): sys.exit()
def test_menu_loop(self, mock_stdout): main_menu = MainMenu() with mock.patch('builtins.input', side_effect=['s', 'q', 'q']): return_value = main_menu.menu_loop() self.assertTrue(return_value)
def start_mainmenu(self,task): self.prelobby.destroy() self.status.destroy() self.mainmenu=MainMenu(self) return task.done