def main_loop(self):
while 1:
#set fps
self.clock.tick(60)
#if the desired mode is changed, then change the program to that mode.
if self.selected_mode != str(self.current_mode):
if self.selected_mode == 'Start' or self.selected_mode == 'Continue':
if self.save == None:
self.save = Game(self.screen)
self.current_mode = self.save
elif self.selected_mode == 'Menu':
if self.save == None:
self.current_mode = Menu(['Start','Quit'],self.screen)
else:
self.current_mode = Menu(['Continue','Quit'],self.screen)
elif self.selected_mode == 'Shop':
temp = Shop(self.screen,self.save.player)
self.current_mode = temp
self.save.player = temp.player
elif self.selected_mode == 'Quit':
raise SystemExit
#if the current_mode exist, run its loop
if self.current_mode != None:
#the loop usually returns a str(self), so when it is not the case, the mode changes
self.selected_mode = self.current_mode.loop(pygame.event.get(),self.screen)
pygame.display.flip()
def add_likelihood(self):
pdf = self.choose_pdf()
if pdf is not None:
if len(self.history['likelihoods']) > 0:
lk_history = sorted(self.history['likelihoods'],
key=lambda x: x[1], reverse=True)
sort_indices = sorted(range(len(self.history['likelihoods'])),
key=lambda i: \
self.history['likelihoods'][i][1],
reverse=True)
options = [lk[0] for lk in lk_history]
details = ['Likelihoods:\n' + '\n'.join(
[' ' + s + ': ' + str(lk[2][s]) \
for s in sorted(lk[2].keys())]) \
for lk in lk_history]
m = Menu(options=options, more=details,
exit_str='New likelihood',
header='Choose a likelihood function:\n' + \
'(add ? to the number to get ' + \
'more info on a likelihood)')
m.get_choice()
if m.choice == m.exit:
new_lk = self.define_new_likelihood(pdf)
pdf.add_likelihood(new_lk[0], **new_lk[2])
else:
self.history['likelihoods'][sort_indices[m.i_choice]][1] \
+= 1
lk = self.history['likelihoods'][sort_indices[m.i_choice]]
pdf.add_likelihood(lk[0], **lk[2])
else:
new_lk = self.define_new_likelihood(pdf)
pdf.add_likelihood(new_lk[0], **new_lk[2])
def change_plot(self):
# options that apply to all subplots
options = [('Change axis limits', self.plot.change_limits),
('Change axis labels', self.plot.label_axes),
('Add legend', self.plot.add_legend)]
# change appearance of a PDF
if self.pdf_exists():
options.extend([('Change constraint color',
self.change_pdf_color)])
# options specific to 1D or 2D plots
subplot_1d_exists = False
subplot_2d_exists = False
subplot_2d_has_multiple_contours = False
for ax_row in self.plot.axes:
for ax in ax_row:
if hasattr(ax, 'parameters'):
if len(ax.parameters) == 1:
subplot_1d_exists = True
elif len(ax.parameters) == 2:
subplot_2d_exists = True
if len(ax.pdfs) > 1:
subplot_2d_has_multiple_contours = True
if subplot_2d_has_multiple_contours:
options.extend([('Change order of contour layers',
self.plot.change_layer_order)])
options = OrderedDict(options)
m = Menu(options=options.keys(), exit_str='Cancel')
m.get_choice()
if m.choice != m.exit:
options[m.choice]()
#self.plot.plot_grid.tight_layout(self.plot.figure)
self.plot.figure.set_tight_layout(True)
plt.draw()
def delete_history(self):
m = Menu(options=['Likelihoods', 'Chains', 'All'], exit_str='Cancel')
m.get_choice()
if m.choice == 'Likelihoods' or m.choice == 'All':
self.history['likelihoods'] = []
if m.choice == 'Chains' or m.choice == 'All':
self.history['chains'] = []
def add_chain(self):
pdf = self.choose_pdf(require_no_chain=True)
# select from list of currently defined chains (from all pdfs),
# previously used chains (read from file),
# or get files and name for new chain (if new, save to file)
if pdf is not None:
if len(self.history['chains']) > 0:
chain_history = sorted(self.history['chains'],
key=lambda x: x[0], reverse=True)
sort_indices = sorted(range(len(self.history['chains'])),
key=lambda i: \
self.history['chains'][i][0],
reverse=True)
options = [ch[1] for ch in chain_history]
details = ['Chains:\n' + '\n'.join(
[textwrap.fill(s, initial_indent=' ',
subsequent_indent=' ') \
for s in sorted(ch[2])]) \
for ch in chain_history]
m = Menu(options=options, more=details,
exit_str='New chain',
header='Choose a chain:\n' + \
'(add ? to the number to get ' + \
'more info on a chain)')
m.get_choice()
if m.choice == m.exit:
pdf.add_chain(*self.define_new_chain())
else:
self.history['chains'][sort_indices[m.i_choice]][0] += 1
pdf.add_chain(*self.history['chains'] \
[sort_indices[m.i_choice]][1:])
else:
pdf.add_chain(*self.define_new_chain())
def show_menu(self, command, options): """Shows the tab-completion menu""" menu = Menu(self.win, options ) option = menu.run() menu.hide() if option is not None: self.set_buffer(command + ' ' + option)
def test_single_options_single_digits(self):
m = Menu(test_contacts)
assert len(m.get_options('2')) == 1
assert m.get_options('2')[0]['number'] == '1'
assert len(m.get_options('3')) == 1
assert m.get_options('3')[0]['number'] == '2'
def get_modification(self):#integrate options, perhaps send to 'get' functions and change those to file mods
choice = None
resume = False
while choice != 'q':
if self.mod_key == "Resume":
# if self.mod_value != None:
# print("\n\t\tHere is the current resume.")
# resume = self.controller.get_resume(self)
# self.open_resume(resume)
# choice = input("Please enter the new resumes file path\nand file name with a .pdf ending: ")
# resume = self.save_resume(choice)
# new_value = choice
print("\n\t\tResume saving inside database is currently malfunctioning, pick another option please.")
time.sleep(4)
break
else:
print("\n\t\tYou have chosen to modify '{}'.\n".format(self.mod_key))
print("\nOpening contents in text editor. Please modify and save the file.")
self.open_data()
new_value = None
choice = input("\n\t\tPress enter to continue when ready...")
if not new_value:
new_value = self.save_data()
Menu.clear_screen()
print("\nThe information you have entered is:\n{}".format(new_value))
verify = input("Is this correct? 'y' to confirm: ").lower()
if Menu.verify_yes_no(verify):
print("\nEntry complete and saving now.")
if resume:
self.info[self.mod_key] = resume.encode('utf8')
else:
self.info[self.mod_key] = new_value
choice = 'q'
time.sleep(2)
return resume
def main():
#Initialize
pygame.init()
screen = pygame.display.set_mode((width, height))
pygame.display.set_caption(WINDOW_TITLE)
screen.fill(bg_color)
clock = pygame.time.Clock()
font = pygame.font.Font(font_path, fonth)
img_reglas = load_image(reglas_path)
img_creditos = load_image(creditos_path)
pygame.mixer.music.load(menu_music)
pygame.mixer.music.play()
while True:
menu = Menu(screen, font, ['Jugar', 'Reglas', 'Creditos', 'Salir'])
op = menu.main_loop()
if op == 0:
game = SC(screen, clock)
game.main_loop()
elif op == 1:
SimpleScreen(screen, img_reglas).main_loop()
elif op == 2:
SimpleScreen(screen, img_creditos).main_loop()
elif op == 3:
sys.exit(0)
def mode__episodes(self):
id = self.args['id'][0]
menu = Menu(self.base_url, self.addon_handle)
for item in a3media.get_episodes(id):
video = {"Plot": item['plot']}
menu.add(MenuItem(item['title'], 'play', args={'id': id}, iconImage=item['img'], video=video))
menu.show()
def mode__section(self):
id = self.args['id'][0]
menu = Menu(self.base_url, self.addon_handle)
for item in a3media.get_section(id):
video = {"Plot": item['plot']}
menu.add(MenuItem(item['title'], 'subcategories', args={'id': id, 'subid': item['id']}, iconImage=item['img'], video=video))
menu.show()
def test_select_parents(self):
"""
Ensure the MENU_SELECT_PARENTS setting works
"""
settings.MENU_SELECT_PARENTS = False
request = self.factory.get('/parent2/kids2-1')
items = Menu.process(request, 'test')
self.assertEqual(items[0].selected, True)
self.assertEqual(items[0].children[1].selected, True)
self.assertEqual(items[1].selected, False)
request = self.factory.get('/kids2-2')
items = Menu.process(request, 'test')
self.assertEqual(items[0].selected, False)
self.assertEqual(items[0].children[0].selected, True)
self.assertEqual(items[1].selected, False)
settings.MENU_SELECT_PARENTS = True
request = self.factory.get('/kids2-2')
items = Menu.process(request, 'test')
self.assertEqual(items[0].selected, True)
self.assertEqual(items[0].children[0].selected, True)
self.assertEqual(items[1].selected, False)
request = self.factory.get('/parent3/kids3-1/kid1')
items = Menu.process(request, 'test')
self.assertEqual(items[0].selected, False)
self.assertEqual(items[0].children[1].selected, False)
self.assertEqual(items[1].selected, True)
self.assertEqual(items[1].children[0].selected, True)
self.assertEqual(items[1].children[0].children[0].selected, True)
self.assertEqual(items[1].children[1].selected, False)
self.assertEqual(items[2].selected, False)
def build_shows_menu(self, shows):
menu = Menu(self.base_url, self.addon_handle)
for show in shows:
iconImage = show.img if len(show.img) > 0 else 'DefaultVideo.png'
li = MenuItem(show.title, 'episodes', args={'code': show.code}, iconImage=iconImage)
menu.add(li)
menu.show()
def test_display_select_setting_name_modify_attributes_should_update_attribute_for_level(self):
sudoku_menu = Menu()
sudoku_setting = Settings()
old_value = sudoku_setting.get_attribute_value_for_setting("Level", "Easy","max")
sudoku_menu.display_select_setting_name_to_modify_attributes("Level")
new_value = sudoku_setting.get_attribute_value_for_setting("Level", "Easy","max")
self.assertEqual(old_value, new_value)
def change_layer_order(self, ax=None):
if ax is None:
ax = self.select_subplot()
set_pdfs = self.settings['{0:d}.{1:d}'.format(ax.row, ax.col)]['pdfs']
# find current order
pdfs = []
layers = []
for pdf in set_pdfs:
if 'layer' in set_pdfs[pdf]:
layers.append(set_pdfs[pdf]['layer'])
pdfs.append(pdf)
old_layers = list(zip(*sorted(zip(pdfs, layers),
key=lambda x: x[1],
reverse=True))[0])
# get new order (e.g. 1 0 2)
m = Menu(options=old_layers, exit_str=None,
header='Enter a new order for the constraints.\n' + \
'The current order (top to bottom) is:')
new_layer_order = m.get_order()
new_layer_order.reverse()
# should clear subplot before plotting contours again,
# but don't want to change other plot elements
# re-plot pdfs in new order
for i in new_layer_order:
self.plot_2d_pdf(ax, ax.pdfs[old_layers[i]], layer=-1)
def main():
"""Snake main entry point."""
pygame.init()
game_display = display.Display('Snake')
# Create menu buttons
menu_buttons = [Button("(1) Classic game",
(display.WINDOW_WIDTH * 1/3,
display.WINDOW_HEIGHT * 3/8),
pygl.K_1),
Button("(2) Exit",
(display.WINDOW_WIDTH * 1/3,
display.WINDOW_HEIGHT * 4/8),
pygl.K_2)]
# Create the menu
game_menu = Menu(game_display, menu_buttons, 'snake/images/menu/snake.png')
game_menu.draw()
while True:
for event in pygame.event.get():
if (event.type == pygl.QUIT) or \
(event.type == pygl.KEYDOWN and event.key == pygl.K_ESCAPE):
sys.exit(pygame.quit)
for button in menu_buttons:
if (event.type == pygl.KEYDOWN and
button.key_pressed(event.key)):
run_game(game_display)
pygame.display.update()
game_display.update_clock()
def connectHandlers(self): # Inherited connections. Menu.connectHandlers(self) # Specific connections. self.btnBack.subscribeEvent(PyCEGUI.PushButton.EventClicked, self, "onBackButtonClicked")
def quit_game():
quit_items=Menu([
MenuItem(1, "Save and Quit", save_and_quit),
MenuItem(2, "Quit without save", quit_without_save),
MenuItem(3, "Resume", resume)])
quit_items.print_menu_items()
quit_item=quit_items.select_menu_item()
def potion_submenu():
potion_submenu_items=Menu([
MenuItem(1, "Reselect the Potion", select_potion),
MenuItem(2, "Continue", print_character),
MenuItem(3, "Quit", quit_game)])
potion_submenu_items.print_menu_items()
potion_submenu_item=potion_submenu_items.select_menu_item()
def ready(self):
# Add two items to our main menu
Menu.add_item("main", MenuItem("Informacje o koncie",reverse("am_userInfo"),weight=10,icon="tools"))
Menu.add_item("main", MenuItem("zmień dane",reverse("am_changeUserdata"),weight=20,icon="report"))
Menu.add_item("main", MenuItem("zmień hasło",reverse("am_changeUserpassword"),weight=30,icon="report"))
Menu.add_item("main", MenuItem("twoje ankiety",reverse("am_userSurveys"),weight=40,icon="report"))
Menu.add_item("main", MenuItem("statystyki i aktywność użytkownika",reverse("am_userActivity"),weight=50,icon="report"))
def __init__(self,screen):
# Load images
global images
images = loadImages()
#Load sounds Effects
global sounds
sounds = loadSounds()
# Ojbects
self.player = Player((93,324),images,sounds)
self.playerSprite = pygame.sprite.Group()
self.playerSprite.add(self.player)
# -------------------
self.levelList = []
self.levelList.append(niveles.Level_One(images,sounds,self.player))
self.levelList.append(niveles.Level_Two(images,sounds,self.player))
self.currentLevel = 0
self.level = self.levelList[self.currentLevel]
self.level.load_music()
self.player.level = self.level
#--------------------------------------------------------------
self.text_font = pygame.font.Font("fuentes/FreeSansBold.ttf",38)
#Create menu object:
self.menu = Menu(screen,("INICIO","OPCIONES","AYUDA","SALIR"),ttf_font="fuentes/dejavu.ttf",
font_color=(0,0,0),bg_image=images["intro"],font_size=34)
self.menuPausa = Menu(screen,("Continuar Juego","Menu prinsipal"),ttf_font="fuentes/dejavu.ttf",
font_color=(0,0,0),bg_image=images["background"],font_size=34)
self.screen = screen
def play():
from menu import Menu
menu = Menu(screen)
#show menu before starting game.
menu.showMenu()
from player import Player
from bullet import Bullet
from enemies import Enemies
player = Player()
player.set_screen(screen)
to_update = player.create()
#draw player to screen immediately
pygame.display.update(to_update)
bullet = Bullet()
bullet.set_screen(screen)
enemies = Enemies()
enemies.set_screen(screen)
while player.is_alive():
to_update = []
pygame.event.pump()
key = pygame.key.get_pressed()
#key events that only need to be pressed once
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_RETURN:
menu.showMenu()
if event.key == pygame.K_SPACE:
player.fire(bullet, True)
if key[pygame.K_ESCAPE]:
sys.exit()
if key[pygame.K_RIGHT]:
to_update += player.move_right()
if key[pygame.K_LEFT]:
to_update += player.move_left()
if key[pygame.K_SPACE]:
player.fire(bullet, False)
frametime.start()
to_update += bullet.move(enemies, player)
to_update += enemies.move(bullet)
pygame.display.update(to_update)
#find how long it took to render this frame so we can adjust speeds
frametime.end()
#player died
player.game_over()
enemies.game_over()
bullet.game_over()
pygame.display.flip()
def main():
menu = Menu()
f = None
experiments = import_module("experiments").__all__
for exp_name in experiments:
if exp_name.startswith("*"):
f = exp_name
break
if not f:
f = menu.experiments_prompt()
curr_exp = Current_experiment(import_module("experiments." + f))
arduino = arduino_serial.Arduino(serial_name = curr_exp.serial_name)
arduino.start()
scheduler = Scheduler(curr_exp)
controller = Controller(curr_exp, scheduler.schedule_a, scheduler.schedule_b, scheduler.schedule_mat)
controller.send_scheduled_commands()
tagger = Data_handler(curr_exp, scheduler.schedule_a, scheduler.schedule_b)
previous_time = datetime.now()
running = True
while running:
try:
if (datetime.now() - previous_time).total_seconds() > 5:
controller.send_scheduled_commands()
previous_time = datetime.now()
tagger.ard_grab_and_tag_data(arduino)
except KeyboardInterrupt:
running = False
def test_select_shouldShowLoadingWhileGettingItemsAsynchronously():
asyncFolder = mocks.NeverLoadingFolder("Dynamic", [])
dynamicMainFolder = mocks.Folder("Main", [asyncFolder])
menu = Menu(dynamicMainFolder)
menu.select()
assert asyncFolder.loadItemsCnt == 0
assert menu.item() is menu._loadingItem
def test_select_shouldLoadAsyncFolders():
asyncFolder = mocks.SynchronAsyncFolder("Dynamic", [])
dynamicMainFolder = mocks.Folder("Main", [asyncFolder])
menu = Menu(dynamicMainFolder)
menu.select()
assert asyncFolder.loadItemsCnt == 1
assert menu._currentItems == asyncFolder._itemsToLoad
def albums_action(menuitem, gui, artist_id = None):
"""
Load the list of artists from the XBMC and display the menu.
"""
if artist_id:
result = xbmc.call.AudioLibrary.GetAlbums(artistid = artist_id)
else:
result = xbmc.call.AudioLibrary.GetAlbums()
def convert(album):
text = album["label"]
if album.has_key('thumbnail'):
pass
#image = self.cache.open_http(
# album["thumbnail"], self.config["default album"],
# image_convert)
else:
image = self.cache.open(self.config["default album"])
def action(menuitem2, gui2):
tracks_action(menuitem2, gui2, album["albumid"])
return MenuItem(image, text, action)
self.albums_menu.fill(*map(convert, result["albums"]))
Menu.action_helper(self.albums_menu)(menuitem, gui)
def __init__(self, app):
Menu.__init__(self, app)
self.header = ["Ebenezer personal accounting ver 0.1",\
"-----------[ Main menu ]------------"]
num_acc = len(data.accounts)
if self.app.active_account is None:
active_account_name = "No account found!"
else:
active_account_name = self.app.active_account.name
self.contents = ["Found " + str(num_acc) + " data.accounts",\
"Current active account : " + active_account_name,\
"[A]ccounts",\
"[T]ransactions",\
"[D]ebts",\
"[Q]uit"]
self.prompt = "What do you want to do ?"
self.answers = {"a":[self.change_menu, "accountlist"],\
"t":[self.change_menu, "accounttrans"],\
"d":[self.change_menu, "debts"],\
"q":[self.quit, None]}
def show_menu(self):
from menu import Menu
import Tkinter as tk
root = tk.Tk()
self.add_human = 0
self.goOn = 0
def set_AI_vs_human():
self.add_human = 1
root.destroy()
self.goOn = 1
def set_AI_vs_AI():
root.destroy()
self.goOn = 1
def quit():
root.destroy()
items = [("AI vs Human", set_AI_vs_human), ("AI vs AI", set_AI_vs_AI), ("Quit", quit)]
menu = Menu(root, items)
menu.pack()
root.mainloop()
if not self.goOn:
self.quit()
else:
del self.goOn
def strike_menu():
roll_cube(player)
roll_cube(opponent)
if player.roll > opponent.roll:
print(player)
print(opponent)
print('You hits monster')
opponent.hp -= 2
print(player)
print(opponent)
else:
print(player)
print(opponent)
print('Monster hits you')
player.hp -= 2
print(player)
print(opponent)
name_items = Menu([
MenuItem(1, 'Try your luck', try_your_luck_menu),
MenuItem(2, 'Retreat', strike_menu),
MenuItem(3, 'Quit', quit),
])
name_items.print_menu()
name_items.choose()
def start(self):
pygame.display.flip()
menu = Menu(self.fenetre)
askToExit = False
while not askToExit:
for event in pygame.event.get():
if event.type == QUIT:
askToExit = True
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
askToExit = True
choix = menu.loop()
if choix <=0:
askToExit = True
if choix == 4:
regle = Regle(self.fenetre)
regle = regle.loop()
if regle <=0:
askToExit = True
if choix == 1:
niveau = Niveau(1)
joueurs = [Joueur(1),Joueur(1)]
partie = Partie(self.fenetre,niveau,joueurs)
askToExit = partie.start()
Joueur.i = 1
from req import Request
from menu import Menu
requisicao = Request()
menu = Menu()
INTERVALO_NAO_ZERO_OU_NEGATIVO = 0
VOLTAR = 9
class Moedas:
def escolha_menu(self, option: int):
self.option = option
escolha_dic = {
0: lambda temp: self.escolhas_moeda(self.tmp_moeda),
1: lambda temp: self.escolhas_moeda_intervalo(self.tmp_moeda),
}
if self.option not in escolha_dic.keys():
raise KeyError
else:
print(menu.mostra_moedas_menu())
self.tmp_moeda = int(input('Escolha:'))
if self.tmp_moeda == VOLTAR:
return ''
else:
return escolha_dic[self.option](self.tmp_moeda)
def escolhas_moeda(self, entrada_tipo_moeda: int):
self.moeda = entrada_tipo_moeda
self.tmp_moeda = ''
self.moeda_dic = {
# -*- coding: utf-8 -*-
from menu import Menu
if __name__ == "__main__":
lista_personas = []
menu = Menu(lista_personas)
menu.iniciar()
from menu import Menu from boardFunctions import BoardFunctions myGame = Menu() myGame.game_menu() myBoard = BoardFunctions() size = myGame.board_size mines = myGame.mines_num myBoard.mines_num = mines grid = myBoard.make_grid(size) myBoard.generate_mines(size, grid) myBoard.just_print(size, grid) myBoard.print_board(size, grid) # myGame.play_game()
class Game():
def __init__(self, screen, clk):
self.heart_image = pygame.image.load('source\\heart.png')
self.heart_empty_image = pygame.image.load('source\\heart_empty.png')
self.hero_image = pygame.image.load('source\\TEMP_medic.png')
self.black_image = pygame.image.load('source\\blackground.jpg')
self.red_image = pygame.image.load('source\\redground.png')
self.background_image = pygame.image.load(
'source\\menu_background.jpg').convert()
self.mouse_image = pygame.image.load('source\\broadsword.png')
self.divide_image = pygame.image.load('source\\border_vertical.png')
self.ring_image = pygame.image.load('source\\ring.png')
self.welBk_image = pygame.image.load('source\\welcome_bk.png')
self.skeleton_static = pygame.image.load('source\\skeleton_static.png')
self.slime_green_static = pygame.image.load(
'source\\slime_green_static.png')
self.slime_blue_static = pygame.image.load(
'source\\slime_blue_static.png')
self.spider_static = pygame.image.load('source\\spider_static.png')
self.gameover = pygame.image.load('source\\game_over.png')
self.mouse_cursor = pygame.transform.scale(self.mouse_image, (30, 30))
self.font1 = pygame.font.Font('source\\Font Error.ttf', 18)
self.font2 = pygame.font.Font('source\\Song.ttf', 35)
self.font3 = pygame.font.Font('source\\Font Error.ttf', 35)
self.menu = Menu(('START', 'HELP', 'EXIT'))
self.font_text1 = self.font1.render('Won\'t move', True, WHITE)
self.font_text2 = self.font1.render('Move up & down', True, WHITE)
self.font_text3 = self.font1.render('Square movement', True, WHITE)
self.font_text4 = self.font1.render('Sloping movement, ', True, WHITE)
self.useless = []
self.state = 6 #welcome
self.screen = screen
self.menu = Menu(('START', 'HELP', 'EXIT'))
self.map = Map(self.screen)
self.move = False
self.pos_x, self.pos_y = 4, 4
self.groups = sprite.Groups(screen, self.map)
self.clk = clk
self.attacked = True
self.last_time = 0
self.beats_time_mod = []
self.modified_beats = []
self.lives = 3
self.lv = 1
self.swipe = sprite.Animation(self.screen, 'source\\swipe_dagger.png',
3)
self.swipe_group = pygame.sprite.Group()
self.swipe_group.add(self.swipe)
def game_quit(self):
pygame.quit()
exit()
def selection(self):
print(self.menu.state)
def update_frame(self):
common_function.check_return()
'''Creat Background'''
self.screen.blit(self.background_image, (0, 0))
'''Creat Mouse Cursor '''
x, y = pygame.mouse.get_pos()
x -= self.mouse_cursor.get_width() / 2
y -= self.mouse_cursor.get_height() / 2
self.screen.blit(self.mouse_cursor, (x, y))
def update_menu_frame(self):
common_function.check_return()
'''Creat Background'''
self.screen.blit(self.background_image, (0, 0))
'''Creat Menu'''
self.menu.update()
self.menu.display_frame(self.screen)
'''Creat Mouse Cursor '''
x, y = pygame.mouse.get_pos()
x -= self.mouse_cursor.get_width() / 2
y -= self.mouse_cursor.get_height() / 2
self.screen.blit(self.mouse_cursor, (x, y))
def update_game_frame(self):
common_function.check_return()
'''Display Background'''
self.screen.blit(self.black_image, (0, 0))
'''Draw Hero's POS'''
rectx, recty = OFFSET_X + self.pos_x * BLOCK, OFFSET_Y + self.pos_y * BLOCK + BLOCK / 2
sqr = pygame.draw.rect(self.screen, YELLOW, (rectx, recty, 60, 60))
'''Draw the map'''
self.map.display_map()
'''Creat Mouse Cursor '''
x, y = pygame.mouse.get_pos()
x -= self.mouse_cursor.get_width() / 2
y -= self.mouse_cursor.get_height() / 2
self.screen.blit(self.mouse_cursor, (x, y))
'''Display Divide'''
self.screen.blit(self.divide_image, (580, 0))
'''Display Lv inf'''
self.display_Lv()
'''Display Lives'''
if self.lives == 3:
for i in range(3):
self.screen.blit(self.heart_image, (LIVES_LEGEND + i * 50, 15))
elif self.lives == 2:
self.screen.blit(self.heart_image, (LIVES_LEGEND + 0 * 50, 15))
self.screen.blit(self.heart_image, (LIVES_LEGEND + 1 * 50, 15))
self.screen.blit(self.heart_empty_image,
(LIVES_LEGEND + 2 * 50, 15))
elif self.lives == 1:
self.screen.blit(self.heart_image, (LIVES_LEGEND + 0 * 50, 15))
self.screen.blit(self.heart_empty_image,
(LIVES_LEGEND + 1 * 50, 15))
self.screen.blit(self.heart_empty_image,
(LIVES_LEGEND + 2 * 50, 15))
else:
for i in range(3):
self.screen.blit(self.heart_empty_image,
(LIVES_LEGEND + i * 50, 15))
'''Display monster images'''
self.screen.blit(self.slime_green_static, (MONSTER_LEGEND, 220))
self.screen.blit(self.slime_blue_static, (MONSTER_LEGEND, 320))
self.screen.blit(self.spider_static, (MONSTER_LEGEND, 420))
self.screen.blit(self.skeleton_static, (MONSTER_LEGEND, 520))
'''Display monster information'''
self.screen.blit(self.font_text1, (TEXT_LEGEND, 240))
self.screen.blit(self.font_text2, (TEXT_LEGEND, 340))
self.screen.blit(self.font_text3, (TEXT_LEGEND, 440))
self.screen.blit(self.font_text4, (TEXT_LEGEND, 540))
'''check beat'''
clk = pygame.mixer.music.get_pos()
if int(clk / 10) in self.beats_time_mod or int(
clk / 10) + 1 in self.beats_time_mod or int(
clk / 10) - 1 in self.beats_time_mod:
if int(clk / 10) in self.beats_time_mod:
self.beats_time_mod.remove(int(clk / 10))
elif int(clk / 10) + 1 in self.beats_time_mod:
self.beats_time_mod.remove(int(clk / 10) + 1)
else:
self.beats_time_mod.remove(int(clk / 10) - 1)
#print(int(clk/10))
self.move = True
'''Display Monsters'''
ticks = pygame.time.get_ticks() # Give gif clk
self.groups.monster_group.update(ticks, 0, 0, self.move)
self.move = False
self.groups.monster_group.draw(self.screen)
'''Check and display attacked'''
self.check_attacked()
if self.attacked:
self.screen.blit(self.red_image, (0, 0))
if pygame.time.get_ticks() > self.last_time + 500:
self.attacked = False
'''Display Hero'''
self.screen.blit(self.ring_image, (rectx, recty + 10))
self.groups.hero_group.update(ticks, self.pos_x, self.pos_y)
self.groups.hero_group.draw(self.screen)
if self.swipe.visable:
self.swipe_group.update(ticks)
self.swipe_group.draw(self.screen)
def display_Lv(self):
lv = 'LEVEL ' + str(self.lv)
label = self.font3.render(lv, True, YELLOW)
width = label.get_width()
height = label.get_height()
pos_x = 800 - 20 - width
pos_y = 80
self.screen.blit(label, (pos_x, pos_y))
'''
STATE:
1 MENU
2 START
3 HELP
4 EXIT
5 GAME OVER
6 WELCOME
0 GAME RUNNING
'''
def state_logic(self):
if self.state == 0:
self.show_game_process()
return False
elif self.state == 1:
self.show_menu()
return False
elif self.state == 2:
self.show_game()
return False
elif self.state == 3:
self.show_help()
return False
elif self.state == 4:
return True
elif self.state == 5:
self.display_gameover()
elif self.state == 6:
self.welcome()
def welcome(self):
text = self.font2.render("(按任意键以继续)", True, WHITE, BLACK)
ztx, zty, ztw, zth = text.get_rect()
jx = pygame.Rect(800, 200, ztw, zth)
clock = pygame.time.Clock()
txt1 = self.font2.render("一名探险家偶然踏入一座地牢，神奇的是: ", True, WHITE, BLACK)
txt2 = self.font2.render("这座地牢的里的怪物们会根据音乐节奏移动。", True, WHITE, BLACK)
txt3 = self.font2.render("小心移动并击杀怪物，逃出地牢···", True, WHITE, BLACK)
self.screen.fill((0, 0, 0))
self.screen.blit(self.welBk_image, (100, 300))
self.screen.blit(txt1, (50, 50))
self.screen.blit(txt2, (50, 150))
self.screen.blit(txt3, (50, 250))
pygame.display.update()
time.sleep(3)
while True:
self.screen.fill((0, 0, 0))
self.screen.blit(self.welBk_image, (100, 300))
clock.tick(30)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit(0)
if event.type == pygame.KEYDOWN:
self.state = 1
return
elif event.type == pygame.MOUSEBUTTONDOWN:
self.state = 1
return
jx.x -= 5
if jx.x < 0 - ztw:
jx.x = 510
self.screen.blit(text, [jx.x, jx.y])
pygame.display.update()
def show_menu(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.game_quit()
if event.type == pygame.KEYDOWN:
if event.type == K_ESCAPE:
self.game_quit()
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
if self.menu.rect_list[0].collidepoint(mouse_x, mouse_y):
self.state = 2
elif self.menu.rect_list[1].collidepoint(mouse_x, mouse_y):
self.state = 3
elif self.menu.rect_list[2].collidepoint(mouse_x, mouse_y):
pygame.quit()
exit()
else:
self.state = 1
self.update_menu_frame()
pygame.display.flip()
def display_message(self, message):
label = self.font2.render(message, True, WHITE)
width = label.get_width()
height = label.get_height()
pos_x = (SCREEN_WIDTH // 2) - (width // 2)
pos_y = (SCREEN_HEIGHT // 2) - (height // 2)
self.screen.blit(label, (pos_x, pos_y))
def show_help(self):
for event in pygame.event.get():
if event.type == QUIT:
self.game_quit()
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
print("Exit from help")
self.state = 1
return
self.update_frame()
label1 = self.font2.render(" 使用←↑→↓移动 ", True, WHITE)
label2 = self.font2.render("开始前选择地牢节奏", True, WHITE)
label3 = self.font2.render("怪物将根据节奏移动", True, WHITE)
label4 = self.font2.render("(按ESC回到主菜单)", True, WHITE)
pos_x = 150
pos_y = 200
self.screen.blit(label1, (pos_x, pos_y))
self.screen.blit(label2, (pos_x, pos_y + 50))
self.screen.blit(label3, (pos_x, pos_y + 100))
self.screen.blit(label4, (pos_x + 100, pos_y + 300))
pygame.display.flip()
def select_music(self):
root = tkinter.Tk()
root.withdraw()
music_name = tkinter.filedialog.askopenfilenames()
if len(music_name) != 0:
music_name_str = ''
for i in range(0, len(music_name)):
music_name_str += str(music_name[i])
print(music_name_str)
return music_name_str
else:
self.update_frame()
self.display_message("Please select your music !")
pygame.display.flip()
self.select_music()
def show_game(self):
common_function.check_return()
filename = self.select_music()
pygame.display.flip()
pygame.mixer.music.load(filename)
pygame.mixer.music.set_endevent(pygame.USEREVENT + 1)
'''Beat Track'''
y, sr = librosa.load(filename)
duration = librosa.get_duration(y)
#print(duration)
tempo, beats = librosa.beat.beat_track(y)
amt = beats.size
beats_time = librosa.frames_to_time(beats)
# print(beats_time)
self.beats_time_mod = []
for b in beats_time:
self.beats_time_mod.append(int(b * 100))
self.state = 0
pygame.mixer.music.play(1, 0)
self.show_game_process()
def display(self):
if self.state == 0:
self.update_game_frame()
else:
self.update_frame()
self.clk.tick(FRAME_RATE)
def display_gameover(self):
for event in pygame.event.get():
if event.type == QUIT:
self.game_quit()
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
#print("Exit from gameover")
self.state = 1
return
#print('gameover')
self.screen.blit(self.gameover, (0, 0))
label4 = self.font2.render("(按ESC回到主菜单)", True, WHITE)
self.screen.blit(label4, (250, 500))
pygame.display.flip()
def resetPos(self):
for monster in self.groups.monster_group:
#print(monster.pos_x, monster.pos_y)
self.map.array[monster.pos_x][monster.pos_x] = 1
def readPos(self):
self.map = Map(self.screen)
for monster in self.groups.monster_group:
#print(monster.pos_x, monster.pos_y)
self.map.array[monster.pos_x][monster.pos_y] = 2
def removeMonster(self, pos_x, pos_y):
for monster in self.groups.monster_group:
if monster.pos_x == pos_x and monster.pos_y == pos_y:
#print(pos_x, pos_y)
self.map.array[pos_x][pos_y] = 1
self.groups.monster_group.remove(monster)
def move_or_kill(self, factor_x, factor_y):
if common_function.check_movable(self.pos_x + factor_x,
self.pos_y + factor_y, self.map):
'''Kill'''
if self.map.array[self.pos_x + factor_x][self.pos_y +
factor_y] == 2:
self.swipe.set_pos(self.pos_x + factor_x,
self.pos_y + factor_y)
self.swipe.visable = True
self.removeMonster(self.pos_x + factor_x,
self.pos_y + factor_y)
else:
'''Move'''
self.pos_x += factor_x
self.pos_y += factor_y
#self.move = True
def check_attacked(self):
self.readPos()
#common_function.printMap(self.map)
if self.map.array[self.pos_x][self.pos_y] == 2:
'''Was attacked'''
self.lives -= 1
if self.lives == 0:
pygame.mixer.music.stop()
self.__init__(self.screen, self.clk)
self.state = 5
self.display_gameover()
self.attacked = True
self.last_time = pygame.time.get_ticks()
flag = False
while not flag:
temp_x = common_function.get_randint(1, 8)
temp_y = common_function.get_randint(1, 8)
if self.map.array[temp_x][temp_y] == 1:
self.pos_x = temp_x
self.pos_y = temp_y
flag = True
def get_proper_pos(self):
while True:
temp_x = common_function.get_randint(1, 8)
temp_y = common_function.get_randint(1, 8)
if self.map.array[temp_x][temp_y] == 1:
return temp_x, temp_y
def add_characters_1(self):
pos_x, pos_y = self.get_proper_pos()
self.map.array[pos_x][pos_y] = 2
green_slime = character.Slime_Green(self.screen, pos_x, pos_y,
self.map)
self.groups.monster_group.add(green_slime)
def add_characters_2(self):
pos_x, pos_y = self.get_proper_pos()
self.map.array[pos_x][pos_y] = 2
blue_slime = character.Slime_Blue(self.screen, pos_x, pos_y, self.map)
self.groups.monster_group.add(blue_slime)
def add_characters_3(self):
pos_x, pos_y = self.get_proper_pos()
self.map.array[pos_x][pos_y] = 2
spider = character.Spider(self.screen, pos_x, pos_y, self.map)
self.groups.monster_group.add(spider)
def add_characters_4(self):
pos_x, pos_y = self.get_proper_pos()
self.map.array[pos_x][pos_y] = 2
skeleon = character.Skeleon(self.screen, pos_x, pos_y, self.map)
self.groups.monster_group.add(skeleon)
def auto_add_monster(self):
if self.lv == 2:
self.add_characters_2()
elif self.lv == 3:
self.add_characters_3()
elif self.lv == 4:
self.add_characters_4()
else:
for i in range(self.lv - 4):
raint = common_function.get_randint(1, 4)
if raint == 1:
self.add_characters_1()
elif raint == 2:
self.add_characters_2()
elif raint == 3:
self.add_characters_3()
else:
self.add_characters_4()
def level_up(self):
print("Level up")
self.lv += 1
self.auto_add_monster()
def show_game_process(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
pygame.mixer.music.stop()
self.__init__(self.screen, self.clk)
self.state = 1
return
else:
self.readPos()
#common_function.printMap(self.map)
if event.key == K_LEFT or event.key == K_a:
self.move_or_kill(-1, 0)
elif event.key == K_RIGHT or event.key == K_d:
# 右方向键则加一
self.move_or_kill(+1, 0)
elif event.key == K_UP or event.key == K_w:
# 类似
self.move_or_kill(0, -1)
elif event.key == K_DOWN or event.key == K_s:
self.move_or_kill(0, +1)
if not len(self.groups.monster_group):
self.level_up()
if event.type == pygame.USEREVENT + 1:
print("Game Finished")
self.state = 1
return
pygame.display.flip()
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
dockWidget = QDockWidget("Explorer", self)
self.editor = QPlainTextEdit()
self.editor.document().setDefaultFont(QFont("monospace"))
self.editor.zoomIn(2)
self.explorer = QTreeView()
self.model = QFileSystemModel(self.explorer)
self.root = self.model.setRootPath("../..")
self.explorer.setModel(self.model)
self.explorer.setRootIndex(self.root)
self.file_path = None
# Instances of menus and message
self.custom_menu = Custom_menu(self, self.explorer, self.model,
self.editor, app)
self.menu = Menu(self, self.explorer, self.editor, self.model)
self.message = Message(self)
# Menu bar
self.file_menu = self.menuBar().addMenu("&File")
self.help_menu = self.menuBar().addMenu("&Help")
self.menu.menu_actions()
# Other custom tweaks
self.explorer.setSortingEnabled(True)
self.explorer.setMinimumWidth(400)
self.explorer.setContextMenuPolicy(Qt.CustomContextMenu)
self.resize(1500, 900)
# Enabling renaming on context menu
self.model.setReadOnly(False)
self.explorer.setEditTriggers(self.explorer.NoEditTriggers)
# Change default explorers column width
self.header = self.explorer.header()
self.header.setSectionResizeMode(0, QHeaderView.Interactive)
self.header.setDefaultSectionSize(200)
self.header.setSectionResizeMode(1, QHeaderView.ResizeToContents)
self.header.setSectionResizeMode(2, QHeaderView.ResizeToContents)
# Setting editor as central widget
self.setCentralWidget(self.editor)
self.addDockWidget(Qt.LeftDockWidgetArea, dockWidget)
# Setting view as widget of dock widget
dockWidget.setWidget(self.explorer)
dockWidget.setFloating(False)
### Double & right click
self.explorer.doubleClicked.connect(self.custom_menu.on_double_click)
self.explorer.customContextMenuRequested.connect(
self.custom_menu.context_menu)
def closeEvent(self, e):
"""This function prevents from closing without saving,
it works with the "Close" event"""
if not self.editor.document().isModified():
return
answer = self.message.ask_for_confirmation()
if answer == QMessageBox.Save:
if not self.menu.save():
e.ignore()
elif answer == QMessageBox.Cancel:
e.ignore()
class Game:
#Background Color
BLACK = (0, 0, 0)
BLUE = (0, 126, 231) # 007EE7 hex number
def __init__(self):
self.ai = AI()
pygame.init() # initialize pygame
self.red_selector = pygame.image.load("button-red.png")
self.screen = pygame.display.set_mode((696, 700)) # screen size
self.game_board = Board(
self.screen) # initialize Game board with screen size
self.settings = Settings()
self.menu = Menu(self.screen)
#self.turn = "red"
self.player = 1
def play(self):
self.game_board.reset_game()
gameover = False # play until game is done
while not gameover:
if self.settings.gameActive is "pvp":
for event in pygame.event.get(): # Events from player
if event.type == pygame.QUIT: # Player chose to quit
pygame.quit()
quit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_w:
#print("player decided to place here")
if self.game_board.check_valid_move():
self.game_board.move()
pygame.display.update()
if self.game_board.check_win():
pygame.display.update()
pygame.event.pump()
time.sleep(2)
self.settings.toggle_game_active()
pygame.mouse.set_visible(True)
#blit win thing too?
if self.game_board.move_count is 42:
pygame.event.pump() #blit tie game
time.sleep(2)
self.settings.toggle_game_active()
pygame.mouse.set_visible(True)
self.game_board.change_turn()
elif event.key == pygame.K_a:
# print("Player moved left!")
self.game_board.move_select_button("left")
pygame.display.update()
elif event.key == pygame.K_s:
print("Player knowns nothing")
elif event.key == pygame.K_d:
# print("Player moved right!")
self.game_board.move_select_button("right")
pygame.display.update()
elif event.key == pygame.K_q:
pygame.quit()
quit()
elif self.settings.gameActive is "pvai":
if self.player:
for event in pygame.event.get(): # Events from player
if event.type == pygame.QUIT: # Player chose to quit
pygame.quit()
quit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_w:
#print("player decided to place here")
if self.game_board.check_valid_move():
self.game_board.move()
pygame.display.update()
pygame.event.pump()
if self.game_board.check_win():
pygame.display.update()
pygame.event.pump()
time.sleep(2)
self.settings.toggle_game_active()
pygame.mouse.set_visible(True)
#blit win thing too?
if self.game_board.move_count is 42:
pygame.event.pump() #blit tie game
time.sleep(2)
self.settings.toggle_game_active()
pygame.mouse.set_visible(True)
self.game_board.change_turn()
self.player = 0
elif event.key == pygame.K_a:
# print("Player moved left!")
self.game_board.move_select_button("left")
pygame.display.update()
elif event.key == pygame.K_s:
print("Player knowns nothing")
elif event.key == pygame.K_d:
# print("Player moved right!")
self.game_board.move_select_button("right")
pygame.display.update()
elif event.key == pygame.K_q:
pygame.quit()
quit()
else:
print("ai")
#ai
moved = False
score = 0
while not moved:
move, score = self.ai.minimax(self.game_board, 1,
-1000, 1000, True)
print("Column Move: " + str(move))
# print("Minmax Number:" + str(move))
self.game_board.button_position = move
while self.game_board.check_valid_move() is False:
move += 1
self.game_board.button_position = move
self.game_board.move()
pygame.event.pump()
pygame.display.update()
moved = True
if self.game_board.check_win():
pygame.display.update()
pygame.event.pump()
time.sleep(2)
self.settings.toggle_game_active()
pygame.mouse.set_visible(True)
# blit win thing too?
if self.game_board.move_count is 42:
pygame.event.pump() #blit tie game
time.sleep(2)
self.settings.toggle_game_active()
pygame.mouse.set_visible(True)
pygame.event.pump()
self.game_board.reset_select_button()
pygame.display.update()
#x = 10000000
#while(x):
#x = x-1
print("Score: " + str(score))
self.game_board.change_turn()
self.player = 1
else:
self.menu.draw_menu()
pygame.display.update()
for event in pygame.event.get(): # Events from player
if event.type == pygame.QUIT: # Player chose to quit
pygame.quit()
quit()
gameover = True
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
self.menu.checkForPlayButtonClick(
mouse_x, mouse_y, self.settings)
if self.settings.gameActive:
self.update_screen() # initialize window
self.game_board.reset_game()
self.game_board.load_board()
# can be made in board
def update_screen(self):
self.screen.fill(game.BLUE)
#self.game_board.blit() # call gameboard
self.game_board.load_board()
pygame.display.update() # update the entire screen = flip
from database import Database
from menu import Menu
from models.food import Food
from models.types_of_food import Types_Of_Food
Database.initialize()
#t1 = Types_Of_Food.find_one_type(ttype="type5")
#t2 = Types_Of_Food.find_one_type(ttype="type8")
#print(t1)
#print(t2)
menu = Menu()
menu.run_menu()
"""
food = Food(_id="4",
name="name4",
preparation="prep4",
type_id="4")
food.save_food()
food2 = Food.find_one_food_by_name("name2")
print(food2)
"""
# Added menu to select which gui to run
# GUIs: madlib and restaurant
# Restaurant currently does not calculate toal correctly
from tkinter import *
from menu import Menu
if __name__ == '__main__':
window = Tk()
window.title("Simple GUIs")
app = Menu(window)
window.mainloop()
import os
from menu import Menu
from coffee_maker import CoffeeMaker
from money_machine import MoneyMachine
menu_object = Menu()
coffee_maker_object = CoffeeMaker()
money_machine_object = MoneyMachine()
os.system("clear")
not_turn_off = True
while not_turn_off:
# TODO: 1. Ask user
option = input(f"What would you like? {menu_object.get_items()}: ")
if option == "off":
not_turn_off = False
elif option == "report":
coffee_maker_object.report()
money_machine_object.report()
else:
drink = menu_object.find_drink(option)
if coffee_maker_object.is_resource_sufficient(drink):
if money_machine_object.make_payment(drink.cost):
coffee_maker_object.make_coffee(drink)
# Space between runs
print("\n")
def select_student(students):
selected_module = Menu.show_object(students, ['Select Student'])
return selected_module
def select_module(modules):
selected_module = Menu.show_object(modules, ['Select Module'])
return selected_module
def main():
pg.init()
pg.display.set_caption("Tetris")
screen = pg.display.set_mode(solo_max_screen_coord)
pg.key.set_repeat(delay, interval)
normal_blocks_path = os.path.join('sprites', 'blocks.png')
assist_blocks_path = os.path.join('sprites', 'assist_blocks.png')
glow_blocks_path = os.path.join('sprites', 'glow_blocks.png')
game_background_path = os.path.join('sprites', 'background.png')
menu_background_path = os.path.join('sprites', 'background.png')
grid_background_path = os.path.join('sprites', 'grid_background.png')
# load backgrounds
background_original = pg.image.load(game_background_path).convert()
grid_background = pg.image.load(grid_background_path).convert()
# load font
font = pg.font.Font(os.path.join('fonts', font_file), 38)
# load and scale all blocks (each tetromino has its own block color)
def load_blocks(path, size, blocks_number):
blocks_list = []
blocks = pg.image.load(path).convert_alpha()
blocks = pg.transform.scale(blocks, (size * blocks_number, size))
for i in range(blocks_number):
block_surface = blocks.subsurface(i * size, 0, size, size)
blocks_list.append(block_surface)
return blocks_list
normal_blocks = load_blocks(normal_blocks_path, block_size, 8)
assist_blocks = load_blocks(assist_blocks_path, block_size, 7)
glow_blocks = load_blocks(glow_blocks_path, block_size + glow_size, 7)
# (Left, Right, Rotate Clockwise, Rotate Counterclockwise, Drop, Speed Up)
arrow_keys = (pg.K_LEFT, pg.K_RIGHT, pg.K_UP, pg.K_DOWN, pg.K_SPACE,
pg.K_RSHIFT)
letter_keys = (pg.K_a, pg.K_d, pg.K_w, pg.K_s, pg.K_LSHIFT, pg.K_z)
# create menu
menu_items = ['SINGLE PLAYER', 'MULTIPLAYER', 'CO-OP', 'QUIT']
main_menu = Menu('TETRIS', menu_background_path, screen_res, font_file,
menu_coord)
for item in menu_items:
main_menu.add_item(item)
# when game_over is True return to main menu
while True:
display_menu = True
multiplayer = False
coop = False
while display_menu:
screen = pg.display.set_mode(solo_max_screen_coord)
background = pg.transform.scale(background_original,
screen.get_size())
main_menu.show(screen)
pg.display.flip()
# wait for keyboard input
event = pg.event.wait()
user_input = main_menu.check_input(event)
if user_input == menu_items[0]: # single player
display_menu = False
elif user_input == menu_items[1]: # multiplayer
screen = pg.display.set_mode(multiplayer_max_screen_coord)
background = pg.transform.scale(background_original,
screen.get_size())
multiplayer = True
display_menu = False
elif user_input == menu_items[2]: # coop
screen = pg.display.set_mode(coop_max_screen_coord)
background = pg.transform.scale(background_original,
screen.get_size())
display_menu = False
coop = True
elif user_input == menu_items[3] or event.type == pg.QUIT: # quit
exit()
player_list = []
if not coop:
left_player = DefaultPlayer(grid_background, block_size, (0, 0),
solo_max_screen_coord)
player_list.append(left_player)
else:
path = os.path.join('sprites', 'coop_grid_background.png')
temp = pg.image.load(path).convert()
grid = Grid(20, 20, block_size, coop_max_screen_coord, temp)
left_player = CoopPlayer(grid, block_size, (0, 0), 0)
right_player = CoopPlayer(grid, block_size, (0, 0), 1)
player_list.append(left_player)
player_list.append(right_player)
if multiplayer:
right_player = DefaultPlayer(
grid_background, block_size,
(multiplayer_max_screen_coord[0] // 2, 0),
multiplayer_max_screen_coord)
player_list.append(right_player)
game_over = game_paused = False
clock = pg.time.Clock()
total_time = 0.0
dt = 1.0 / FPS
accumulator = 0.0
while not game_over:
# keyboard input
for event in pg.event.get():
if multiplayer or coop:
left_player.check_input(event, letter_keys)
right_player.check_input(event, arrow_keys)
else:
left_player.check_input(event, arrow_keys)
if event.type == pg.QUIT:
exit()
elif event.type == pg.KEYDOWN and event.key == pg.K_ESCAPE:
game_over = True
elif event.type == pg.KEYDOWN and event.key == pg.K_m: # mute
sounds.mute = not sounds.mute
if sounds.mute:
pg.mixer.music.pause()
else:
pg.mixer.music.unpause()
elif event.type == pg.KEYDOWN and event.key == pg.K_p: # Pause the game
pause = True
sounds.pause_sound.play()
pg.mixer.music.pause()
for player in player_list:
player.display_message(screen, 'PAUSE')
pg.display.flip()
while pause:
event = pg.event.wait()
if event.type == pg.KEYDOWN and event.key == pg.K_p:
pause = False
elif event.type == pg.QUIT:
exit()
game_paused = True
pg.mixer.music.unpause()
sounds.pause_sound.play()
if game_paused:
frame_time = dt
game_paused = False
clock.tick(FPS)
else:
frame_time = clock.tick(FPS) / 1000.0 # convert to seconds
# main game loop
accumulator += frame_time
while accumulator >= dt and not game_over:
if multiplayer:
left_player.insert_lines(right_player.get_lines_cleared())
right_player.insert_lines(left_player.get_lines_cleared())
elif coop:
# all players must have the same difficulty level
max_level = 0
for player in player_list:
if player.get_difficulty_level() > max_level:
max_level = player.get_difficulty_level()
for player in player_list:
if player.get_difficulty_level() != max_level:
player.increase_difficulty_level()
for player in player_list:
player.main_loop(dt)
game_over = game_over or player.is_game_over()
accumulator -= dt
# create strings
if display_time:
total_time += frame_time
time_string = "TIME " + '{0:02d}'.format(int(total_time // 60))\
+ ":" + '{0:02d}'.format(int(total_time % 60))
time_surface = write(font, time_string, text_color)
if display_fps:
fps_string = "FPS: " + str(int(clock.get_fps()))
fps_surface = write(font, fps_string, text_color)
# Draw
screen.blit(background, min_screen_coord)
if display_time:
screen.blit(time_surface, time_coord)
if display_fps:
screen.blit(fps_surface, fps_coord)
if coop:
player_list[0].show_grid(screen, normal_blocks)
for player in player_list:
player.show(screen, normal_blocks, assist_blocks, glow_blocks)
pg.display.flip()
# end of game messages
victory_color = (0, 255, 0)
defeat_color = (255, 0, 0)
tie_color = (255, 255, 0)
tie = True
# game over is True for all the players (tie)
# game over is False for all the players (used escape to return to main menu)
for player in player_list:
tie = tie and player.is_game_over()
game_over = game_over and not player.is_game_over()
for player in player_list:
if not multiplayer or (game_over and multiplayer):
player.display_message(screen, 'GAME OVER', text_color)
elif tie:
player.display_message(screen, 'TIE', tie_color)
elif player.is_game_over():
player.display_message(screen, 'DEFEAT', defeat_color)
else:
player.display_message(screen, 'VICTORY', victory_color)
pg.display.flip()
pg.mixer.music.stop()
clock.tick(0.7)
class MainWindow(Gtk.Window):
"""
This class contains methods related the MainWindow class.
"""
# ----------------------------------------------------------------------
def __init__(self):
"""
This method is constructor.
"""
System()
Gtk.Window.__init__(self, title="Mosaicode")
self.resize(System.get_preferences().width,
System.get_preferences().height)
self.main_control = MainControl(self)
# GUI components
self.menu = Menu(self)
self.toolbar = Toolbar(self)
self.search = SearchBar(self)
self.block_notebook = BlockNotebook(self)
self.property_box = PropertyBox(self)
self.work_area = WorkArea(self)
self.status = Status(self)
self.diagram_menu = DiagramMenu()
self.menu.add_help()
System.set_log(self.status)
# vbox main
# -----------------------------------------------------
# | Menu
# -----------------------------------------------------
# | Toolbar
# -----------------------------------------------------
# | V Paned bottom
# -----------------------------------------------------
# First Vertical Box
vbox_main = Gtk.VBox()
self.add(vbox_main)
vbox_main.pack_start(self.menu, False, True, 0)
vbox_main.pack_start(self.toolbar, False, False, 0)
self.vpaned_bottom = Gtk.Paned.new(Gtk.Orientation.VERTICAL)
vbox_main.add(self.vpaned_bottom)
# vpaned_bottom
# -----------------------------------------------------
# | hpaned_work_area
# =====================================================
# | status
# -----------------------------------------------------
self.hpaned_work_area = Gtk.HPaned()
self.hpaned_work_area.connect("accept-position", self.__resize)
self.hpaned_work_area.set_position(
System.get_preferences().hpaned_work_area)
self.vpaned_bottom.add1(self.hpaned_work_area)
self.vpaned_bottom.add2(self.__create_frame(self.status))
self.vpaned_bottom.set_position(System.get_preferences().vpaned_bottom)
self.vpaned_bottom.set_size_request(50, 50)
# hpaned_work_area
# -----------------------------------------------------
# | vbox_left || work_area
# -----------------------------------------------------
vbox_left = Gtk.VBox(False, 0)
self.hpaned_work_area.add1(vbox_left)
self.hpaned_work_area.add2(self.work_area)
# vbox_left
# -----------------------------------------------------
# |search
# -----------------------------------------------------
# |vpaned_left
# -----------------------------------------------------
vbox_left.pack_start(self.search, False, False, 0)
self.vpaned_left = Gtk.VPaned()
vbox_left.pack_start(self.vpaned_left, True, True, 0)
# vpaned_left
# -----------------------------------------------------
# |blocks_tree_view
# =====================================================
# |property_box
# -----------------------------------------------------
self.vpaned_left.add1(self.__create_frame(self.block_notebook))
self.vpaned_left.add2(self.__create_frame(self.property_box))
self.vpaned_left.set_position(System.get_preferences().vpaned_left)
self.connect("key-press-event", self.__on_key_press)
self.connect("check-resize", self.__resize)
self.main_control.init()
# ----------------------------------------------------------------------
def __on_key_press(self, widget, event=None):
if event.state == \
Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.MOD2_MASK:
if event.keyval == Gdk.KEY_a:
self.main_control.select_all()
return True
return False
# ----------------------------------------------------------------------
def __create_frame(self, widget):
frame = Gtk.Frame()
frame.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
frame.add(widget)
frame.set_property("border-width", 4)
return frame
# ----------------------------------------------------------------------
def __resize(self, data):
width, height = self.get_size()
System.get_preferences().width = width
System.get_preferences().height = height
System.get_preferences(
).hpaned_work_area = self.hpaned_work_area.get_position()
System.get_preferences(
).vpaned_bottom = self.vpaned_bottom.get_position()
System.get_preferences().vpaned_left = self.vpaned_left.get_position()
self.work_area.resize(data)
# ----------------------------------------------------------------------
def update(self):
self.main_control.update_all()
# ----------------------------------------------------------------------
def set_title(self, title):
"""
This method set title.
Parameters:
* **title** (:class:`str<str>`)
"""
Gtk.Window.set_title(self, "Mosaicode (" + title + ")")
import pygame
if __name__ == "__main__":
from menu import Menu
pygame.init()
screen_w, screen_h = 1280, 960
screen = pygame.display.set_mode((screen_w, screen_h))
pygame.display.set_caption('Pong')
game = Menu(screen)
game.draw()
def __init__(self):
"""
This method is constructor.
"""
System()
Gtk.Window.__init__(self, title="Mosaicode")
self.resize(System.get_preferences().width,
System.get_preferences().height)
self.main_control = MainControl(self)
# GUI components
self.menu = Menu(self)
self.toolbar = Toolbar(self)
self.search = SearchBar(self)
self.block_notebook = BlockNotebook(self)
self.property_box = PropertyBox(self)
self.work_area = WorkArea(self)
self.status = Status(self)
self.diagram_menu = DiagramMenu()
self.menu.add_help()
System.set_log(self.status)
# vbox main
# -----------------------------------------------------
# | Menu
# -----------------------------------------------------
# | Toolbar
# -----------------------------------------------------
# | V Paned bottom
# -----------------------------------------------------
# First Vertical Box
vbox_main = Gtk.VBox()
self.add(vbox_main)
vbox_main.pack_start(self.menu, False, True, 0)
vbox_main.pack_start(self.toolbar, False, False, 0)
self.vpaned_bottom = Gtk.Paned.new(Gtk.Orientation.VERTICAL)
vbox_main.add(self.vpaned_bottom)
# vpaned_bottom
# -----------------------------------------------------
# | hpaned_work_area
# =====================================================
# | status
# -----------------------------------------------------
self.hpaned_work_area = Gtk.HPaned()
self.hpaned_work_area.connect("accept-position", self.__resize)
self.hpaned_work_area.set_position(
System.get_preferences().hpaned_work_area)
self.vpaned_bottom.add1(self.hpaned_work_area)
self.vpaned_bottom.add2(self.__create_frame(self.status))
self.vpaned_bottom.set_position(System.get_preferences().vpaned_bottom)
self.vpaned_bottom.set_size_request(50, 50)
# hpaned_work_area
# -----------------------------------------------------
# | vbox_left || work_area
# -----------------------------------------------------
vbox_left = Gtk.VBox(False, 0)
self.hpaned_work_area.add1(vbox_left)
self.hpaned_work_area.add2(self.work_area)
# vbox_left
# -----------------------------------------------------
# |search
# -----------------------------------------------------
# |vpaned_left
# -----------------------------------------------------
vbox_left.pack_start(self.search, False, False, 0)
self.vpaned_left = Gtk.VPaned()
vbox_left.pack_start(self.vpaned_left, True, True, 0)
# vpaned_left
# -----------------------------------------------------
# |blocks_tree_view
# =====================================================
# |property_box
# -----------------------------------------------------
self.vpaned_left.add1(self.__create_frame(self.block_notebook))
self.vpaned_left.add2(self.__create_frame(self.property_box))
self.vpaned_left.set_position(System.get_preferences().vpaned_left)
self.connect("key-press-event", self.__on_key_press)
self.connect("check-resize", self.__resize)
self.main_control.init()
def create_menu():
menu = Menu()
menu.add_option('1', 'Add Book', add_book)
menu.add_option('2', 'Search For Book', search_book)
menu.add_option('3', 'Show Unread Books', show_unread_books)
menu.add_option('4', 'Show Read Books', show_read_books)
menu.add_option('5', 'Show All Books', show_all_books)
menu.add_option('6', 'Change Book Read Status', change_read)
menu.add_option('7', 'Delete Book', delete_book)
menu.add_option('Q', 'Quit', quit_program)
return menu
from highscore import Pontuacao
from dificuldades import Dificuldade
janela = Window(globais.WIDTH,globais.HEIGHT)
tela = Tela(janela)
tela.setFundo()
teclado = Keyboard()
dificuldade = Dificuldade()
dificuldade.setDificuldade()
humano = Humano(janela)
menu = Menu(janela)
posicoes = Posicoes(janela)
pontuacao = Pontuacao(janela)
while True:
tela.setTela()
if(teclado.key_pressed("RIGHT")):
globais.STATUS_PERSONAGEM = 2
posicoes.setUpdate()
while(globais.STATUS_PERSONAGEM == 2):
if globais.GAME_STATE == 1:
tela.getFundo()
posicoes.getUpdate()
board = Board()
pins = [board.getPin(18)]
def just_print(x):
print("Just print")
print(x)
q.put(game)
def game():
t = 0
while t < 2000:
time.sleep(0.01)
t += 1
print("Game over")
def re_assign(pins):
print("Reassign")
for pin in pins:
pin.registerHandler(just_print)
menu = Menu(ledArray, pins, [MenuItem("Test", lambda x: re_assign(pins))])
menu.show(0)
while True:
game = q.get()
game()
time.sleep(0.01)
## @file main.py # Main file for project # # Project: Minesweeper # Author: All # Created: 09/06/18 from menu import Menu playing = Menu() playing.game_rules() playing.game_menu()
class Magic: #Cast not a method so it's compatible with Menu - it needed to be of the form func(string), so string.method()
def __init__(self,
name,
manacost,
damage=None
): #was proving difficult to make work with the menu class
self.name = name
self.manacost = manacost
spells.append(self)
self.damage = damage
if damage == None:
string = "Costs " + str(manacost) + " mana."
else:
string = "Costs " + str(manacost) + " mana to do " + str(
damage) + " damage."
self.desc = string
a = Magic("Sparks", 0, 4)
a = Magic("Confringo", 1, 8)
magicMenu = Menu(
) #addMenuOption(displayname,commandname,outputfunc,helpdescription,expectedinput,abbreviation=None)
magicMenu.addMenuOption("cast", "cast", cast,
"casts a spell -- see spell list for options", "spell",
"c")
magicMenu.addMenuOption("spell list", "spell", spelllist,
"lists currently known spells", None, "sl")
magicMenu.addMenuOption("run", "run", run, "escapes into an adjacent room",
None, "r")
def __init__(self, items):
self.__name = "WebSelect"
self.__second_menu = Menu(items)
from menu import Menu
from .sites import site
for item in site.get_menu():
Menu.add_item('cbvadmin', item)
import sys
from PyQt5 import QtWidgets
from menu import Menu
if __name__ == '__main__':
app = QtWidgets.QApplication(sys.argv)
screen = app.primaryScreen()
rect = screen.availableGeometry()
menu = Menu(rect.width(), rect.height())
sys.exit(app.exec_())
def main():
# wydarzenia przechowuj w liście
calendar = []
# zakładamy, że wydarzenie to słownik z kluczami title, date, time
# jeśli chcesz przechowywać wydarzenie w innej strukturze danych
# to pamiętaj o zmianie jej obsługi w funkcji list_calendar
event = {
'title': 'Programowanie obiektowe w jezyku PYTHON - Cwiczenia',
'date': '28.03.2020',
'time': '12:45',
}
calendar.append(event)
menu = Menu()
# tutaj możesz dodać kolejne polecenia do menu
# menu.add_command(MenuCommand(menu)
menu.add_command(StartCommand(menu))
menu.add_command(OptionCommand(menu))
menu.add_command(AddCommand(menu))
menu.add_command(ExitCommand(menu))
menu.run()
from menu import Menu, MenuItem
from coffee_maker import CoffeeMaker
from money_machine import MoneyMachine
My_Menu = Menu()
MakeCoffee = CoffeeMaker()
Money = MoneyMachine()
Machine_working = True
while Machine_working:
choice = input("What do you want? espresso, latte, cappuccino: ").lower()
if choice == 'off':
Machine_working = False
elif choice == 'report':
MakeCoffee.report()
Money.report()
else:
drink = My_Menu.find_drink(choice)
if MakeCoffee.is_resource_sufficient(drink) and Money.make_payment(
drink.cost):
MakeCoffee.make_coffee(drink)
file_root = None
python_root = None
data_dir = None
actions_dir = None
store_file = None
user_db = None
status_log_file = None
access_log_file = None
pidfile = None
host = None
port = None
debug = False
no_daemon = False
server_dir = '/'
main_menu = Menu()
def read():
"""Read configuration"""
directory = os.path.dirname(os.path.realpath(__file__))
parser = SafeConfigParser(defaults={
'root': directory,
})
parser.read(os.path.join(directory, 'plinth.config'))
config_items = {('Name', 'product_name'), ('Name', 'box_name'),
('Path', 'root'), ('Path', 'file_root'),
('Path', 'python_root'), ('Path', 'data_dir'),
('Path', 'store_file'), ('Path', 'user_db'),
('Path', 'actions_dir'), ('Path', 'status_log_file'),
from menu import Menu, MenuItem
from coffee_maker import CoffeeMaker
from money_machine import MoneyMachine
# Create objects
machine_menu = Menu()
resources_management = CoffeeMaker()
cash_machine = MoneyMachine()
while True:
menu_choice = input(
f" What would you like? ({machine_menu.get_items()}): ")
if menu_choice == "off":
break
elif menu_choice == "report":
resources_management.report()
cash_machine.report()
else:
drink_chosen = machine_menu.find_drink(menu_choice)
if not drink_chosen:
continue
enough_resources = resources_management.is_resource_sufficient(
drink_chosen)
if not enough_resources:
continue
main_menu.display()
def open_feed():
webbrowser.open(feed_address)
# Main menu
main_menu_run = Button("Run", parse_feeds, 1)
main_menu_edit = Button("Edit Filters", filters_to_textfile, 2)
main_menu_all = Button("List All Filters And Conditions", list_all, 3)
main_menu_downloaded = Button("List All Downloaded Entries", list_downloaded,
4)
main_menu_feed = Button("Open Feed", open_feed, 5)
main_menu_exit = Button("Exit", sys.exit, 0)
main_menu_buttons = [
main_menu_run, main_menu_edit, main_menu_all, main_menu_downloaded,
main_menu_feed, main_menu_exit
]
main_menu = Menu("Main Menu", main_menu_buttons)
try:
if sys.argv[1] == "-run":
parse_feeds()
except IndexError:
pass
main_menu.display()
from menu import Menu
from coffee_maker import CoffeeMaker
from money_machine import MoneyMachine
money_machine = MoneyMachine()
coffee_maker = CoffeeMaker()
menu = Menu()
is_on = True
while is_on:
options = menu.get_items()
choice = input(f"what would you like? {options}:\t")
if choice == "off":
is_on = False
elif choice == "report":
coffee_maker.report()
money_machine.report()
else:
drink = menu.find_drink(choice)
if coffee_maker.is_resource_sufficient(
drink) and money_machine.make_payment(drink.cost):
coffee_maker.make_coffee(drink)
def buildMenu(self, drink_list, drink_options):
# create a new main menu
m = Menu("Main Menu")
# add drink options
drink_opts = []
for d in drink_list:
drink_opts.append(
MenuItem('drink', d["name"],
{"ingredients": d["ingredients"]}))
configuration_menu = Menu("Configure")
# add pump configuration options
pump_opts = []
for p in sorted(self.pump_configuration.keys()):
config = Menu(self.pump_configuration[p]["name"])
# add fluid options for each pump
for opt in drink_options:
# star the selected option
selected = "*" if opt["value"] == self.pump_configuration[p][
"value"] else ""
config.addOption(
MenuItem('pump_selection', opt["name"], {
"key": p,
"value": opt["value"],
"name": opt["name"]
}))
# add a back button so the user can return without modifying
config.addOption(Back("Back"))
config.setParent(configuration_menu)
pump_opts.append(config)
# add pump menus to the configuration menu
configuration_menu.addOptions(pump_opts)
# add a back button to the configuration menu
configuration_menu.addOption(Back("Back"))
# adds an option that cleans all pumps to the configuration menu
configuration_menu.addOption(MenuItem('clean', 'Clean'))
configuration_menu.setParent(m)
m.addOptions(drink_opts)
m.addOption(configuration_menu)
# create a menu context
self.menuContext = MenuContext(m, self)
