def __init__(self):
gui.gui_state.__init__(self)
self.btn_width = 180
self.btn_height = 35
self.btn_offset = 15
self.title = gui.label()
self.btn_new_game = gui.button(self.btn_width, self.btn_height)
self.btn_deck_view = gui.button(self.btn_width, self.btn_height)
self.btn_quit = gui.button(self.btn_width, self.btn_height)
def __init__(self):
gui.gui_state.__init__(self)
self.btn_width = 180
self.btn_height = 35
self.btn_offset = 15
self.title = gui.label()
self.btn_new_game = gui.button(self.btn_width, self.btn_height)
self.btn_deck_view = gui.button(self.btn_width, self.btn_height)
self.btn_quit = gui.button(self.btn_width, self.btn_height)
def __init__(self, cards, choice, width=0, height=0):
gui.widget.__init__(self, "card_selector", width, height)
self.font = gui.get_big_font()
card_result = ""
if choice.destination == player_choice.DiscardCard:
card_result = "discard"
elif choice.destination == player_choice.DestroyCard:
card_result = "destroy"
elif choice.destination == player_choice.PlayerDeckBottom:
card_result = "deck bottom"
elif choice.destination == player_choice.PlayerDeckTop:
card_result = "deck top"
if not choice.count == -1:
self.title = "Choose %d card(s) to %s" % (choice.count, card_result)
else:
self.title = "Choose cards to %s" % card_result
self.cards = cards
self.possible_choice = self.cards
self.choice = choice
self.selected_cards = []
self.cards_image = {}
self.card_width = 310
self.card_height = 440
self.card_y_offset = 10
self.card_x_offset = 100
self.load_images()
self.card_position = 0
self.closing = None
self.btn_accept = gui.button(100, 30)
self.btn_accept.caption = "Accept"
self.btn_accept.add_receivers(self.accept)
self.btn_reset = gui.button(100, 30)
self.btn_reset.caption = "Reset"
self.btn_reset.add_receivers(self.reset)
self.choice_done = None
def display(self):
assets = self.assets
sw,sh = self.sw,self.sh
settings_menu.firstpane = "display"
self.base()
res_box = gui.scrollpane([10,20])
res_box.width = 200
res_box.height = 120
self.res_box = res_box
self.children.append(res_box)
res_box.add_child(gui.button(self,"Change resolution (%sx%s)"%(assets.swidth,assets.sheight)))
res = res_box.pane.children[-1]
res.checked = True
res.click_down_over = self.popup_resolution
res_box.add_child(gui.checkbox("smoothscale"))
self.smoothscale = res_box.pane.children[-1]
res_box.add_child(gui.checkbox("fullscreen"))
self.fs = res_box.pane.children[-1]
res_box.add_child(gui.checkbox("dualscreen"))
ds = self.ds = res_box.pane.children[-1]
res_box.add_child(gui.checkbox("virtual dualscreen"))
self.vds = res_box.pane.children[-1]
self.vds.visible = 0
res_box.add_child(gui.checkbox("show fps"))
self.show_fps = res_box.pane.children[-1]
s_c = self.show_fps.set_checked
def set_checked(val):
s_c(val)
assets.show_fps = val
wini(assets)
self.show_fps.set_checked = set_checked
#self.reses = gui.radiobutton.groups["resopt"]
if assets.fullscreen:
self.fs.checked = True
if assets.num_screens==2:
self.ds.checked = True
if not assets.screen_compress:
self.vds.checked = True
if assets.show_fps:
self.show_fps.checked = True
if assets.smoothscale:
self.smoothscale.checked = True
self.children.append(gui.button(self,"apply",[10,140]))
def players_categorie_selection(
self, player_nb, adj_num
): # rendre fonctionnel l'écran des sélections de caractères
text(f"Le {adj_num} joueur peut choisir son type de personnage.",
self.medium_font_2,
self.surface, (self.surface_size[0] // 2, 80),
shadow=True,
shadow_offset=2)
buttons_size = (220, 70)
button_y_pos = reset_button_y_pos = 200 # où sera le premier bouton (en y)
button_x_pos = self.surface_size[0] // 2 - buttons_size[0] // 2 - 25
for button_number in range(len(self.characters_categorie)):
if button_number == (len(self.characters_categorie) + 1) // 2:
button_y_pos = reset_button_y_pos
button_x_pos = self.surface_size[0] // 2 + buttons_size[
0] // 2 + 25
button_out = button(self.characters_categorie[button_number],
self.big_font,
self.surface,
pos=(button_x_pos, button_y_pos),
size=buttons_size,
user_click=self.user_click)
# vérifier si l'utilisateur appuie sur le bouton
if button_out[0] is not False:
self.players_categorie[player_nb] = button_out[1]
self.characters_categorie.remove(button_out[1])
break
# changer la position y
button_y_pos += buttons_size[1] + 50
def __init__(self, library=None):
gui.gui_state.__init__(self)
if library is None:
library = cards.library("../dc-deck/pack1")
self.library = library
self.handle_quit = False
self.pic_cards = []
self.current_index = 0
self.key_downs = []
self.deck_start_x = 0
self.card_offset = 15
self.lbl_current_card = gui.label()
self.lbl_cards_count = gui.label()
self.lbl_deck_name = gui.label()
self.deck_combo = gui.combobox(120, 20)
self.deck_combo.items.append("Pack1")
self.deck_combo.items.append("Pack2")
self.deck_combo.items.append("Pack3")
self.deck_combo.items.append("Pack4")
self.btn_back = gui.button()
self.btn_back.width = 120
self.btn_back.height = 35
self.btn_back.caption = "Back"
self.btn_back.add_receivers(self.back)
self.tick_id = 0
def update(self, *args):
assets = self.assets
self.rpos = [0, 0]
self.pos = self.rpos
self.children[:] = [
x for x in self.children if not getattr(x, "kill", 0)
]
for x in self.children:
x.update()
if getattr(self, "giffile", ""):
sys.path.append("tools")
import gif2strip
try:
path = gif2strip.go(self.giffile)
m = msg("Converted " + path.rsplit("/", 1)[1] + ".png",
self.assets)
self.children.append(m)
graphic = pygame.transform.rotozoom(
pygame.image.load(path + ".png"), 0, 0.25)
m.children.append(gui.button(None, "x"))
m.children[-1].graphic = graphic
setattr(m.children[-1], "x", m.click_down_over)
except Exception:
import traceback
traceback.print_exc()
self.children.append(
msg("File could not be converted.", self.assets))
self.giffile = ""
return True
def __init__(self, library=None):
gui.gui_state.__init__(self)
if library is None:
library = cards.library("../dc-deck/pack1")
self.library = library
self.handle_quit = False
self.pic_cards = []
self.current_index = 0
self.key_downs = []
self.deck_start_x = 0
self.card_offset = 15
self.lbl_current_card = gui.label()
self.lbl_cards_count = gui.label()
self.lbl_deck_name = gui.label()
self.deck_combo = gui.combobox(120, 20)
self.deck_combo.items.append("Pack1")
self.deck_combo.items.append("Pack2")
self.deck_combo.items.append("Pack3")
self.deck_combo.items.append("Pack4")
self.btn_back = gui.button()
self.btn_back.width = 120
self.btn_back.height = 35
self.btn_back.caption = "Back"
self.btn_back.add_receivers(self.back)
self.tick_id = 0
def drawPlanet(screen, inGame, planetsData, itemsData, inventoryManager):
#title
font = pygame.font.Font('freesansbold.ttf', 25)
text = font.render("IMT - Interplanetary Market Terminal", True, (255,255,255))
textRect = text.get_rect()
textRect.topleft = (20, 20)
screen.blit(text, textRect)
planetData = planetsData[inGame.planetName]
#slot 1
drawItemCard(screen, planetData[0], (100, 200), itemsData, inventoryManager)
#slot 2
drawItemCard(screen, planetData[1], (280, 200), itemsData, inventoryManager)
#slot 3
drawItemCard(screen, planetData[2], (460, 200), itemsData, inventoryManager)
#balance
gui.button(screen, "$"+str(inventoryManager.bankBalance), (640 - 80, 30))
def __init__(self, modeNameList):
self.buttonList = []
self.modeList = modeNameList
for i in range(0, len(modeNameList)):
butt = gui.button(modeNameList[i], 0, 30*i, doNothing)
butt.setAction(butt.getName)
self.buttonList.append(butt)
self.selectedToolText = gui.justText("This is a piece of text", 0, 30*(i+1))
def make_button(self,text,pos):
b = gui.button(self,text,pos)
if settings_menu.firstpane == text:
b.bgcolor = [50,50,50]
b.highlightcolor = [50,50,50]
b.textcolor = [255,255,255]
print "changed settings for",text
self.children.append(b)
return b
def drawPlanets(screen, inGame, invMan):
#title
font = pygame.font.Font('freesansbold.ttf', 25)
text = font.render("IMT - Interplanetary Market Terminal", True, (255,255,255))
textRect = text.get_rect()
textRect.topleft = (20, 20)
screen.blit(text, textRect)
#slot 1
drawPlanetCardWithImage(screen, "Earth", earthImage, (100, 200), inGame)
#slot 2
drawPlanetCardWithImage(screen, "Mars", marsImage, (280, 200), inGame)
#slot 3
drawPlanetCardWithImage(screen, "Venus", venusImage, (460, 200), inGame)
#balance
gui.button(screen, "$"+str(invMan.bankBalance), (640 - 80, 30))
#space station
if(gui.button(screen, "Space Station", (120, 440))):
inGame.setInSpaceStation(True)
def drawTitleScreen(self, screen, font, inGame):
if self.textAnimationPosition != 50:
self.textAnimationPosition = self.textAnimationPosition + 2
text = font.render('Commercium', True, (255, 255, 255))
textRect = text.get_rect()
textRect.center = (640 / 2, (480 / 2) - self.textAnimationPosition)
screen.blit(text, textRect)
if (gui.button(screen, "Start", (640 / 2, (480 / 2) + 50))):
inGame.setInGame(True)
def make_button(self, text, pos):
b = gui.button(self, text, pos)
if settings_menu.firstpane == text:
b.bgcolor = [50, 50, 50]
b.highlightcolor = [50, 50, 50]
b.textcolor = [255, 255, 255]
print "changed settings for", text
self.children.append(b)
return b
def drawSpaceStation(screen, inGame, inventoryManager):
itemsData = {
"Market Speed+": 1000.0,
"Market Speed-": 1000.0,
"I AM RICH": 100000.0
}
#title
font = pygame.font.Font('freesansbold.ttf', 25)
text = font.render("Space Station Kiosk", True, (255,255,255))
textRect = text.get_rect()
textRect.topleft = (20, 20)
screen.blit(text, textRect)
#slot 1
drawItemCardCustom(screen, "Market Speed+", (100, 200), itemsData, inventoryManager, inGame)
#slot 2
drawItemCardCustom(screen, "Market Speed-", (280, 200), itemsData, inventoryManager, inGame)
#slot 3
drawItemCard(screen, "I AM RICH", (460, 200), itemsData, inventoryManager)
#balance
gui.button(screen, "$"+str(inventoryManager.bankBalance), (640 - 80, 30))
def project_data(self):
t = gui.toplevel(self, _('project_data'))
f_data = gui.lf_param(t, 1, 1, '')
gui.e_general(self, f_data, 1, 1, None, _('project_name'), 'project', 'None')
gui.e_general(self, f_data, 2, 1, None, _('further_info'), 'info', 'None')
gui.e_general(self, f_data, 3, 1, 56, _('engineer'), 'engineer', project_data['engineer'])
gui.e_general(self, f_data, 3, 2, 7, _('signature'), 'signature', 'mr')
def ok():
project_data['project'] = self.var_project.get()
project_data['info'] = self.var_info.get()
project_data['engineer'] = self.var_engineer.get()
project_data['signature'] = self.var_signature.get()
t.destroy()
def cancel():
t.destroy()
f2 = gui.frame(t, 2, 1, E)
gui.button(f2, 'Cancel', cancel)
gui.button(f2, 'OK', ok)
def draw_words(self): # dessiner tous les mots triés par catégorie
buttons_size = (262, 32)
space = 10 # espace entre les boutons
button_x_pos = buttons_size[0] // 2 + space
button_y_pos = reset_button_y_pos = 350 # où sera le premier bouton (en y)
to_return = None, None
for words_group in ("Sujet", "Verbe", "Complément", "Liaison"):
text(words_group,
self.medium_font_2,
self.surface, (button_x_pos, button_y_pos - 40),
color=(164, 61, 227),
shadow=True,
shadow_offset=2) # dessiner le nom de la catégorie
for word in self.sentences["all"][words_group]:
if len(word) > 24:
split_number = 2
else:
split_number = 1
button_out = button(word,
self.small_font,
self.surface,
pos=(button_x_pos, button_y_pos),
size=buttons_size,
user_click=self.user_click,
split=split_number)
if button_out[
0] is not False: # lorsque l'utilisateur clique sur un bouton
to_return = (
words_group, button_out[1]
) # renverra le groupe de mots et le texte du bouton
button_y_pos += buttons_size[1] + space
button_x_pos += buttons_size[0] + space
button_y_pos = reset_button_y_pos
return to_return
def apply(self):
assets = self.assets
sw, sh = self.sw, self.sh
for r in self.screens:
if r.checked:
assets.screen_mode = r.text
for r in self.reses:
if r.checked:
self.oldwidth, self.oldheight = assets.swidth, assets.sheight
self.timer = 5.0
self.really_applyb = gui.pane()
self.really_applyb.is_applyb = True
self.really_applyb.width = 1000
self.really_applyb.height = 1000
self.really_applyb.pri = -1002
self.really_applyb.z = 11002
#self.really_applyb.align = False
e = gui.editbox(None, "")
e.draw_back = False
self.really_applyb.children.append(e)
self.really_applyb.timer = e
b = gui.button(self, "save_resolution", [0, 0])
self.really_applyb.children.append(b)
assets.cur_script.obs.append(self.really_applyb)
assets.swidth, assets.sheight = [
int(x) for x in (r.text[r.text.find("(") +
1:r.text.find(")")]).split("x")
]
self.old_fullscreen = assets.fullscreen
assets.fullscreen = 0
if self.fs.checked:
assets.fullscreen = 1
self.old_num_screens = assets.num_screens
assets.smoothscale = 0
if self.smoothscale.checked:
assets.smoothscale = 1
assets.make_screen()
self.display()
wini(assets)
def apply(self):
assets = self.assets
sw,sh = self.sw,self.sh
for r in self.reses:
if r.checked:
self.oldwidth,self.oldheight = assets.swidth,assets.sheight
self.timer = 5.0
self.really_applyb = gui.pane()
self.really_applyb.is_applyb = True
self.really_applyb.width = 1000
self.really_applyb.height = 1000
self.really_applyb.pri = -1002
self.really_applyb.z = 11002
#self.really_applyb.align = False
e = gui.editbox(None,"")
e.draw_back = False
self.really_applyb.children.append(e)
self.really_applyb.timer = e
b = gui.button(self,"save_resolution",[0,0])
self.really_applyb.children.append(b)
assets.cur_script.obs.append(self.really_applyb)
assets.swidth,assets.sheight = [int(x) for x in (r.text[r.text.find("(")+1:r.text.find(")")]).split("x")]
self.old_fullscreen = assets.fullscreen
assets.fullscreen = 0
if self.fs.checked:
assets.fullscreen = 1
self.old_num_screens = assets.num_screens
assets.num_screens = 1
if self.ds.checked:
assets.num_screens = 2
assets.screen_compress = 1
if self.vds.checked:
assets.screen_compress = 0
assets.smoothscale = 0
if self.smoothscale.checked:
assets.smoothscale = 1
assets.make_screen()
self.display()
wini(assets)
def update(self,*args):
assets = self.assets
self.rpos = [0,0]
self.pos = self.rpos
self.children[:] = [x for x in self.children if not getattr(x,"kill",0)]
for x in self.children:
x.update()
if getattr(self,"giffile",""):
sys.path.append("tools")
import gif2strip
try:
path = gif2strip.go(self.giffile)
m = msg("Converted "+path.rsplit("/",1)[1]+".png",self.assets)
self.children.append(m)
graphic = pygame.transform.rotozoom(pygame.image.load(path+".png"),0,0.25)
m.children.append(gui.button(None,"x"))
m.children[-1].graphic = graphic
setattr(m.children[-1],"x",m.click_down_over)
except Exception:
import traceback
traceback.print_exc()
self.children.append(msg("File could not be converted.",self.assets))
self.giffile = ""
return True
def do(self): # rendre le jeu fonctionnel
self.surface.blit(self.background, (0, 0))
self.click()
if self.state == "characters_selection":
if self.players_categorie[1] is None:
self.players_categorie_selection(1, "premier")
elif self.players_categorie[2] is None:
self.players_categorie_selection(2, "second")
else:
self.sentences_selection()
self.state = "game"
elif self.state == "game":
# self.user_click = True
self.draw_image()
self.draw_players_current_sentences()
words_group, button_out_text = self.draw_words()
if words_group is not None:
self.check_correct_word(words_group, button_out_text)
self.make_wrong_guess()
elif self.state == "score":
self.draw_image()
self.draw_players_current_sentences()
self.draw_scores()
if button("Continuer",
self.big_font,
self.surface,
pos=(self.surface_size[0] // 2,
self.surface_size[1] - 120),
size=(240, 60),
user_click=self.user_click)[0]:
self.reset()
def main():
window_width = 800
window_height = 600
print "Loading locale ...",
gettext.install('default', 'locale')
po = { "position" : _("Position"), "height" : _("Height"), "big" : _("Big"), "small" : _("Small"),
"sides" : _("Sides"), "grid" : _("Grid"), "exit" : _("Exit"),
"del" : _("Delete"), "clear" : _("Clear"), "options" : _("Options"),
"up" : _("Up"), "down" : _("Down"), "left" : _("Left"), "right" : _("Right"), "forward" : _("Forward"), "back" : _("Back"),
"motion_blur" : _("Motion Blur"), "light" : _("Light"),
"few" : _("Too few sides given to describe a rectangular shape"),
"not_even" : _("Odd number of sides can't border a rectangular shape"),
"both" : _("Neither even nor odd indexed sides are closed"),
"even" : _("Even indexed sides are not closed"),
"odd" : _("Odd indexed sides are not closed")
}
for k in po:
po[k] = unicode(po[k],'utf8')
print "Done"
print "Loading pygame ..." ,
pygame.display.init()
pygame.font.init()
print "Done"
print "Loading screen ...",
pygame.display.set_mode ( (window_width,window_height), pygame.OPENGL|pygame.DOUBLEBUF|pygame.RESIZABLE, 24 )
print "Done"
print "Loading opengl ...",
lego.gl_init( window_width, window_height )
print "Done"
# draw dialog screen
print "Loading layers ...",
button_color = (0.8, 0.8, 0.0)
button_focus_color = (0.3, 0.8, 0.5)
button_error_color = (0.8, 0.4, 0.4)
title = pygame.font.SysFont("courier", 24, True, True)
error = pygame.font.SysFont("courier", 18, True, True)
small = pygame.font.SysFont("courier", 14, False, True)
bold_small = pygame.font.SysFont("courier", 14, True, True)
title_scale = 15
sub_scale = -5
text_color = ( 192, 64, 128 )
text_error_color = (204, 204, 0)
piecesize = reference()
grid = opposite(True)
mblur = opposite(False)
menu = reference()
static = dict()
static["options"] = gui.toggle( 10,10, 145, 37, button_color, button_focus_color, button_error_color, 2, menu )
static["edit"] = gui.toggle( 165,10, 145, 37, button_color, button_focus_color, button_error_color, 1, menu )
static_layers = gui.layer_manager()
static_layers.add( small.render(po["options"], True,text_color), 25, 17, (0,3) )
static_layers.add( small.render("Edit", True,text_color), 180, 17, (0,3) )
static_layers.load()
edit = dict()
edit["x"] = gui.textbox( 11,107, 42, 32, button_color, button_focus_color, button_error_color, bold_small, text_color, text_error_color, (0,4) )
edit["y"] = gui.textbox( 113,105, 42, 32, button_color, button_focus_color, button_error_color, bold_small, text_color, text_error_color, (0,4) )
edit["z"] = gui.textbox( 62,107, 42, 32, button_color, button_focus_color, button_error_color, bold_small, text_color, text_error_color, (0,4) )
edit["big"] = gui.toggle ( 33,207, 32, 32, button_color, button_focus_color, button_error_color, lego.LEGO_BIG, piecesize )
edit["small"] = gui.toggle ( 101,207, 32, 32, button_color, button_focus_color, button_error_color, lego.LEGO_SMALL, piecesize )
edit["sides"] = gui.textbox( 11,277, 145,100, button_color, button_focus_color, button_error_color, bold_small, text_color, text_error_color )
edit["grid"] = gui.toggle ( 123,391, 32, 32, button_color, button_focus_color, button_error_color, True, grid )
edit["raise_grid"] = gui.arrow ( 17,437, 32, 32, button_color, button_focus_color, button_error_color )
edit["lower_grid"] = gui.arrow ( 117,437, 32, 32, button_color, button_focus_color, button_error_color, False )
edit["send"] = gui.button ( 11,487, 145, 37, button_color, button_focus_color, button_error_color )
edit["del"] = gui.button ( 11,536, 70, 37, button_color, button_focus_color, button_error_color )
edit["clear"] = gui.button ( 86,536, 70, 37, button_color, button_focus_color, button_error_color )
edit_layers = gui.layer_manager()
edit_layers.add( pygame.image.load(os.path.join('data','ui.png')), 0, 57, (0,0) )
edit_layers.add( title.render(po["position"],True,text_color), 20, 67, (0,title_scale) )
edit_layers.add( title.render(po["height"], True,text_color), 20, 139, (0,title_scale) )
edit_layers.add( title.render(po["big"], True,text_color), 20, 179, (0,sub_scale) )
edit_layers.add( title.render(po["small"], True,text_color), 85, 179, (0,sub_scale) )
edit_layers.add( title.render(po["sides"], True,text_color), 20, 239, (0,title_scale) )
edit_layers.add( title.render(po["grid"], True,text_color), 20, 387, (0,title_scale) )
edit_layers.add( title.render("OK", True,text_color), 67, 494, (0,sub_scale) )
edit_layers.add( small.render(po["del"], True,text_color), 20, 545, (0,3) )
edit_layers.add( small.render(po["clear"], True,text_color), 95, 545, (0,3) )
edit_layers.load()
options = dict()
options["mblur"] = gui.toggle( 67,355, 32, 32, button_color, button_focus_color, button_error_color, True, mblur )
options["raise_mblur"] = gui.arrow ( 17,388, 32, 32, button_color, button_focus_color, button_error_color )
options["lower_mblur"] = gui.arrow ( 117,388, 32, 32, button_color, button_focus_color, button_error_color, False )
options["raise_light"] = gui.arrow ( 17,487, 32, 32, button_color, button_focus_color, button_error_color )
options["lower_light"] = gui.arrow ( 117,487, 32, 32, button_color, button_focus_color, button_error_color, False )
options_layers = gui.layer_manager()
options_layers.add( edit_layers.layer_list[0][0], 0, 57, (0,0) )
options_layers.add( title.render(po["motion_blur"],True,text_color), 8,301, (0,title_scale) )
options_layers.add( title.render(po["light"], True,text_color), 8,434, (0,title_scale) )
options_layers.add( small.render(' '.join(( po["forward"], ":" )), True,text_color), 10, 65, (0,3) )
options_layers.add( small.render(' '.join(( po["back"], ":" )), True,text_color), 10, 98, (0,3) )
options_layers.add( small.render(' '.join(( po["left"], ":" )), True,text_color), 10,131, (0,3) )
options_layers.add( small.render(' '.join(( po["right"], ":" )), True,text_color), 10,164, (0,3) )
options_layers.add( small.render(' '.join(( po["up"], ":" )), True,text_color), 10,197, (0,3) )
options_layers.add( small.render(' '.join(( po["down"], ":" )), True,text_color), 10,230, (0,3) )
options_layers.add( small.render(' '.join(( po["exit"], ":" )), True,text_color), 10,263, (0,3) )
options_layers.add( small.render('W', True,text_color), 100, 65, (0,3) )
options_layers.add( small.render('S', True,text_color), 100, 98, (0,3) )
options_layers.add( small.render('A', True,text_color), 100,131, (0,3) )
options_layers.add( small.render('D', True,text_color), 100,164, (0,3) )
options_layers.add( small.render('Space',True,text_color), 100,197, (0,3) )
options_layers.add( small.render('Ctrl', True,text_color), 100,230, (0,3) )
options_layers.add( small.render('Esc', True,text_color), 100,263, (0,3) )
options_layers.load()
controls = static.copy()
menus = { 1 : edit, 2: options }
print "Done"
print "\nEntering drawing loop\n"
pieces = list()
pieces.append(lego.piece( (4,2,-2,2,-1,1,-2,-1,-1,-2,2,-2), lego.LEGO_BIG, (1.0, 0.1, 0.2), (-6, 0, -6) ))
pieces.append(lego.piece( (1,-1,1,1,1,-1,1,4,-3,-1,-1,-2), lego.LEGO_SMALL, (0.2, 0.8, 0.3), (-8, 2.0/3, 2) ))
pieces.append(lego.piece( (2,2,1,1,-1,2,-2,-5), lego.LEGO_SMALL, (0.2, 0.3, 0.8), ( 5, 1.0/3, 1) ))
pieces.append(lego.piece( (5,6,-5,-1,-1,-4,1,-1), lego.LEGO_BIG, (0.8, 0.3, 0.8), ( 1, 0 ,-2) ))
pieces.append(lego.piece( (2,7,-2,-5,-2,-1,2,-1), lego.LEGO_SMALL, (0.9, 0.9, 0.3), ( 0, 1, 0) ))
lightp = np.array((2.0, 4.0, -4.0, 1.0))
light_int = 0.5
light_amb = 1.0 - (1.0 - light_int) ** 2
GL.glLightfv( GL.GL_LIGHT0, GL.GL_AMBIENT, (light_amb * 0.1, light_amb * 0.1, light_amb * 0.1, 1.0) ) # Setup The Ambient Light
GL.glLightfv( GL.GL_LIGHT0, GL.GL_DIFFUSE, (light_amb, light_amb, light_amb, 1.0) ) # Setup The Diffuse Light
GL.glEnable(GL.GL_LIGHT0) # Enable Light One
eps = sys.float_info.epsilon
ticker = pygame.time.Clock()
running = True
fps = 30
accumulate = False
mblur_rate = 0.5
rotating = False
rotrot = 0.0
rot_speed = 1.5
rotx = 0
roty = -40.0
mouse_sens = -120
position = np.array(( 2.0, -15, 15, 0.0))
move = np.array(( 0.0, 0.0, 0.0, 0.0))
move_speed = 0.5
slow = False
focused = None
mouse_down = None
drag_from = None
key_hit = None
errors = set()
chosen_index = None
grid_level = 0
edit_dyn_layers = gui.dynamic_layer_manager()
edit_dyn_layers.add( "grid-level", title.render(str(grid_level),True,text_color), 75, 437, (0,title_scale) )
options_dyn_layers = gui.dynamic_layer_manager()
options_dyn_layers.add( "mblur-level", title.render(str(mblur_rate),True,text_color), 61, 388, (0,title_scale) )
options_dyn_layers.add( "light-level", title.render(str(light_int) ,True,text_color), 61, 487, (0,title_scale) )
while running:
cx = np.cos( rotx / 180.0 * np.pi )
sx = np.sin( rotx / 180.0 * np.pi)
cy = np.cos( roty / 180.0 * np.pi)
sy = np.sin( roty / 180.0 * np.pi)
xrot = np.array(( (cx, 0.0, -sx, 0.0),
(0.0, 1.0, 0.0, 0.0),
(sx, 0.0, cx, 0.0),
(0.0, 0.0, 0.0, 1.0) ))
yrot = np.array(( (1.0, 0.0, 0.0, 0.0),
(0.0, cy, sy, 0.0),
(0.0, -sy, cy, 0.0),
(0.0, 0.0, 0.0, 1.0) ))
rot = np.dot( xrot, yrot )
# handle events
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.VIDEORESIZE:
window_width, window_height = event.size
pygame.display.set_mode ( (window_width,window_height), pygame.OPENGL|pygame.DOUBLEBUF|pygame.RESIZABLE, 24 )
lego.setviewport(event.w, event.h)
clear_color = GL.glGetFloatv(GL.GL_COLOR_CLEAR_VALUE)
GL.glClearColor( 0.0, 0.0, 0.0, 0.0 )
GL.glClear( GL.GL_COLOR_BUFFER_BIT )
GL.glClearColor( *clear_color )
ticker.tick(fps/6)
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
running=False
if not slow and event.key == 304:
mouse_sens = -60
slow = True
move_speed = 0.1
# FIXME: after moving down (ctrl) and another direction same time it stucks moving
if event.mod % 256 == 64 or event.key == 306:
move[1] = 1.0
elif event.key == 32:
move[1] = -1.0
elif event.key == pygame.K_a or event.key == pygame.K_LEFT:
move[0] = 1.0
elif event.key == pygame.K_d or event.key == pygame.K_RIGHT:
move[0] = -1.0
elif event.key == pygame.K_s or event.key == pygame.K_DOWN:
move[2] = 1.0
elif event.key == pygame.K_w or event.key == pygame.K_UP:
move[2] = -1.0
else:
key_hit = event
elif event.type == pygame.KEYUP:
if event.mod % 256 == 64 or event.key == 306 or event.key == 32:
move[1] = 0.0
elif ( event.key == pygame.K_a or event.key == pygame.K_LEFT or
event.key == pygame.K_d or event.key == pygame.K_RIGHT ):
move[0] = 0.0
elif ( event.key == pygame.K_s or event.key == pygame.K_DOWN or
event.key == pygame.K_w or event.key == pygame.K_UP ):
move[2] = 0.0
if slow and event.key == 304:
slow = False
mouse_sens = -120
move_speed = 0.5
elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
mouse_down = event.pos
GL.glSelectBuffer( 64 )
GL.glRenderMode( GL.GL_SELECT )
lego.draw_mode_3d(event.pos)
GL.glInitNames()
GL.glMultMatrixf( rot )
GL.glMultMatrixf( np.eye(4) + np.vstack(( np.zeros((3,4)), position )) )
for i,p in enumerate( pieces ):
GL.glPushName( i )
p.draw()
GL.glPopName()
hits = GL.glRenderMode( GL.GL_RENDER )
distance = None
if hits:
for j in hits:
if distance > j[1] or distance is None:
distance = j[1]
chosen_index = j[2][0]
start_position = pieces[chosen_index].position
if menu.get() == 1:
edit["x"].value = format( pieces[chosen_index].position[0], 'g' )
edit["y"].value = format( pieces[chosen_index].position[1], 'g')
edit["z"].value = format( pieces[chosen_index].position[2], 'g')
piecesize.set( pieces[chosen_index].size )
edit["sides"].value = ''
edit["sides"].value = ','.join(str(i) for i in pieces[chosen_index].sides)
GL.glRenderMode( GL.GL_SELECT )
lego.draw_mode_2d(event.pos)
GL.glInitNames()
for i in range( 0, len(controls) ):
GL.glPushName( i )
controls.values()[i].draw()
GL.glPopName()
hits = GL.glRenderMode( GL.GL_RENDER )
focused = controls.values()[ hits.pop()[2][0] ] if hits else None
elif mouse_down and event.type == pygame.MOUSEMOTION:
if chosen_index is None or drag_from is None:
rotx += float(event.rel[0]) / window_width * mouse_sens
roty += float(event.rel[1]) / window_height * mouse_sens
else:
x,y = event.pos
y = window_height - y
lego.draw_mode_3d()
GL.glMultMatrixf( rot )
GL.glMultMatrixf( np.eye(4) + np.vstack(( np.zeros((3,4)), position )) )
far = np.array(GLU.gluUnProject( x, y, 1, GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX), GL.glGetDoublev(GL.GL_PROJECTION_MATRIX), GL.glGetIntegerv(GL.GL_VIEWPORT) ))
near = np.array(GLU.gluUnProject( x, y, 0, GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX), GL.glGetDoublev(GL.GL_PROJECTION_MATRIX), GL.glGetIntegerv(GL.GL_VIEWPORT) ))
drag = (drag_from - ( (drag_from[1]-near[1]) / (far[1]-near[1]) ) * (far-near) - near) / -lego.LEGO_GRID
prev_position = pieces[chosen_index].position
pieces[chosen_index].position = start_position + drag.round()
for i,p in enumerate(pieces):
collision = collide( p, pieces[chosen_index] )
if collision:
break
if collision:
pieces[chosen_index].position = prev_position
elif event.type == pygame.MOUSEBUTTONUP and event.button == 1:
mouse_down = None
drag_from = None
if menu.get() != 1:
chosen_index = None
if not np.array_equal( move, np.zeros(4) ):
move = move_speed * move / np.linalg.norm(move)
position += np.dot( rot, move )
# draw 3D stuff
lego.draw_mode_3d()
GL.glMultMatrixf( rot )
GL.glMultMatrixf( np.eye(4) + np.vstack(( np.zeros((3,4)), position )) )
if mblur.value:
if not accumulate:
GL.glClear( GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT )
else:
GL.glAccum( GL.GL_ACCUM, 1.0 - mblur_rate )
GL.glAccum( GL.GL_RETURN, 1.0 )
GL.glAccum( GL.GL_MULT, mblur_rate )
accumulate = not accumulate
ticker.tick( 2*fps )
if rotating:
rotrot = (rotrot + rot_speed/2) % 360
GL.glRotatef( rotrot, 0.0, 1.0, 0.0 )
else:
GL.glClear( GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT )
ticker.tick( fps )
if rotating:
rotrot = (rotrot + rot_speed) % 360
GL.glRotatef( rotrot, 0.0, 1.0, 0.0 )
GL.glLightfv( GL.GL_LIGHT0, GL.GL_POSITION, lightp )
if edit["grid"].value:
lego.draw_grid(grid_level)
ps = GL.glGetInteger( GL.GL_POINT_SIZE )
GL.glPointSize( 10 )
GL.glColor3f( 1.0, 1.0, 0.5 )
GL.glBindTexture(GL.GL_TEXTURE_2D, 0)
GL.glNormal3fv(lightp[:3])
GL.glBegin( GL.GL_POINTS )
GL.glVertex3fv( lightp[:3] - np.array((0.1, 0.1, 0.1)) )
GL.glEnd()
GL.glPointSize( ps )
for piece in pieces:
piece.draw()
if mouse_down and chosen_index is not None and drag_from is None:
x,y = mouse_down
y = window_height - y
z = GL.glReadPixels(x,y,1,1,GL.GL_DEPTH_COMPONENT,GL.GL_FLOAT)
drag_from = np.array(GLU.gluUnProject( x, y, z, GL.glGetDoublev(GL.GL_MODELVIEW_MATRIX), GL.glGetDoublev(GL.GL_PROJECTION_MATRIX), GL.glGetIntegerv(GL.GL_VIEWPORT) ))
# draw 2D stuff
lego.draw_mode_2d()
if menu.get() == 1:
edit_layers.draw( 1 )
elif menu.get() == 2:
options_layers.draw( 1 )
for b in controls.values():
decide = b is focused
b.draw( decide, b in errors )
if decide:
if b is static["options"] or b is static["edit"]:
if b.value is None:
controls = dict_union(controls, menus[b.ref])
b.value = b.ref
elif b.value == b.ref:
b.value = None
controls = dict_substract(controls, menus[b.ref])
else:
controls = dict_substract(controls, menus[b.value])
b.value = b.ref
controls = dict_union(controls, menus[b.ref])
elif isinstance(b, gui.toggle):
b.value = b.ref
elif key_hit is not None and isinstance(b, gui.textbox):
b.append(key_hit)
if b is edit["raise_grid"]:
grid_level += 1
edit_dyn_layers.add( "grid-level", title.render(str(grid_level),True,text_color), edit_dyn_layers.layer_list["grid-level"][1], edit_dyn_layers.layer_list["grid-level"][2], (0,title_scale) )
elif b is edit["lower_grid"]:
grid_level -= 1
edit_dyn_layers.add( "grid-level", title.render(str(grid_level),True,text_color), edit_dyn_layers.layer_list["grid-level"][1], edit_dyn_layers.layer_list["grid-level"][2], (0,title_scale) )
elif b is edit["send"]:
errors = set()
try:
try:
edit_dyn_layers.remove("error")
except KeyError:
pass
sides = tuple( int(i) for i in edit["sides"].value.split(',') )
lego.piece.is_closed(sides)
except lego.LoopError as e:
if e.errno == 1001:
edit_dyn_layers.add( "error", error.render(po["few"],True,text_color), 180, 5, )
elif e.errno == 1002:
edit_dyn_layers.add( "error", error.render(po["not_even"],True,text_color), 180, 5 )
elif e.errno == 1020:
edit_dyn_layers.add( "error", error.render(po["both"],True,text_color), 180, 5 )
elif e.errno == 1000:
edit_dyn_layers.add( "error", error.render(po["even"],True,text_color), 180, 5 )
elif e.errno == 1010:
edit_dyn_layers.add( "error", error.render(po["odd"],True,text_color), 180, 5 )
errors.add(edit["sides"])
except ValueError:
errors.add(edit["sides"])
try:
x = float( edit["x"].value )
except ValueError:
errors.add(edit["x"])
try:
y = round( float( edit["y"].value )*3 ) / 3.0
except ValueError:
errors.add(edit["y"])
try:
z = float( edit["y"].value )
except ValueError:
errors.add(edit["z"])
if piecesize.get() is None:
errors.add(edit["big"])
errors.add(edit["small"])
if not errors:
pieces.append( lego.piece(sides, piecesize.value, (0.2, 0.1, 0.8), (x,y,z)) )
edit["sides"].value = ''
edit["x"].value = ''
edit["y"].value = ''
edit["z"].value = ''
piecesize.value = None
elif b is edit["clear"] or menu.get() != 1:
edit["sides"].value = ''
edit["x"].value = ''
edit["y"].value = ''
edit["z"].value = ''
piecesize.value = None
chosen_index = None
elif b is edit["del"] and chosen_index is not None:
pieces.pop( chosen_index )
edit["sides"].value = ''
edit["x"].value = ''
edit["y"].value = ''
edit["z"].value = ''
piecesize.value = None
chosen_index = None
if b is options["raise_mblur"] and mblur_rate < 0.9 - eps:
mblur_rate += 0.1
options_dyn_layers.add( "mblur-level", title.render(str(mblur_rate),True,text_color), options_dyn_layers.layer_list["mblur-level"][1], options_dyn_layers.layer_list["mblur-level"][2], (0,title_scale) )
elif b is options["lower_mblur"] and mblur_rate > 0.1 + eps:
mblur_rate -= 0.1
options_dyn_layers.add( "mblur-level", title.render(str(mblur_rate),True,text_color), options_dyn_layers.layer_list["mblur-level"][1], options_dyn_layers.layer_list["mblur-level"][2], (0,title_scale) )
elif b is options["lower_light"] and light_int > 0.0:
light_int -= 0.1
if light_int < eps:
light_int = 0.0
light_amb = 1.0 - (1.0 - light_int) ** 2
GL.glLightfv( GL.GL_LIGHT0, GL.GL_AMBIENT, (light_amb * 0.2, light_amb * 0.2, light_amb * 0.2, 1.0) ) # Setup The Ambient Light
GL.glLightfv( GL.GL_LIGHT0, GL.GL_DIFFUSE, (light_amb, light_amb, light_amb, 1.0) )
options_dyn_layers.add( "light-level", title.render(str(light_int) ,True,text_color), options_dyn_layers.layer_list["light-level"][1], options_dyn_layers.layer_list["light-level"][2], (0,title_scale) )
elif b is options["raise_light"] and light_int < 1.0 - eps:
light_int += 0.1
light_amb = 1.0 - (1.0 - light_int) ** 2
GL.glLightfv( GL.GL_LIGHT0, GL.GL_AMBIENT, (light_amb * 0.2, light_amb * 0.2, light_amb * 0.2, 0.2) ) # Setup The Ambient Light
GL.glLightfv( GL.GL_LIGHT0, GL.GL_DIFFUSE, (light_amb, light_amb, light_amb, 1.0) )
options_dyn_layers.add( "light-level", title.render(str(light_int) ,True,text_color), options_dyn_layers.layer_list["light-level"][1], options_dyn_layers.layer_list["light-level"][2], (0,title_scale) )
if decide and not b.keepfocus:
focused = None
key_hit = None
static_layers.draw()
if menu.get() == 1:
edit_layers.draw()
edit_dyn_layers.draw()
elif menu.get() == 2:
options_layers.draw()
options_dyn_layers.draw()
pygame.display.flip()
lego.finish()
pygame.quit()
print "Bye!"
def __init__(self):
gui.gui_state.__init__(self)
#loading superheroes
self.library = cards.library("../dc-deck/pack1")
self.lbl_title = gui.label()
self.lbl_title.font = gui.get_big_font()
self.lbl_title.text = "Game Setup"
self.lbl_players_name = gui.label()
self.lbl_players_name.text = "Players name"
self.lbl_players_num = gui.label()
self.lbl_players_num.text = "Number of players : "
self.lbl_players_num.render()
self.cb_players_num = gui.combobox(50, 22)
self.cb_players_num.items.append("2")
self.cb_players_num.items.append("3")
self.cb_players_num.items.append("4")
self.cb_players_num.items.append("5")
self.cb_players_num.add_receiver(self.player_num_changed)
self.lbl_cb_superhero_pick = gui.label()
self.lbl_cb_superhero_pick.text = "Random superhero : "
self.cb_superhero_pick = gui.checkbox()
self.cb_superhero_pick.checked = True
self.cb_superhero_pick.state_changed = self.pick_random_changed
self.add(self.lbl_title)
self.add(self.lbl_players_name)
self.add(self.lbl_players_num)
self.add(self.cb_players_num)
self.add(self.lbl_cb_superhero_pick)
self.add(self.cb_superhero_pick)
self.tb_players = []
self.lbl_players = []
self.slider_player_superhero = []
nb_players = int(self.cb_players_num.get_item())
for i in range(5):
tb = gui.textbox(180, 22)
self.tb_players.append(tb)
self.add(tb)
lbl = gui.label(25, 22)
lbl.text = str(i + 1) + " : "
self.lbl_players.append(lbl)
self.add(lbl)
if i < nb_players:
tb.visible = True
lbl.visible = True
else:
tb.visible = False
lbl.visible = False
slider = gui.slider(100, 22)
slider.visible = False
for s in self.library.superheroes:
slider.items.append(s.name)
self.slider_player_superhero.append(slider)
self.add(slider)
self.btn_start = gui.button(180, 40)
self.btn_start.caption = "Start !"
self.btn_start.add_receivers(self.start_game)
self.btn_back = gui.button(180, 40)
self.btn_back.caption = "Back"
self.btn_back.add_receivers(self.back)
self.add(self.btn_start)
self.add(self.btn_back)
def page(arg):
## Name of this Page
# print(arg.curpage)
## SAVE PROPERTIES
arg.hprops = sn(**{})
arg.hobjs = sn(**{})
arg.hvars = sn(**{})
arg.hprops.__dict__[arg.curpage] = sn(**{})
arg.hobjs.__dict__[arg.curpage] = sn(**{})
arg.hvars.__dict__[arg.curpage] = sn(**{})
####################### GUI ELEMENTS #########################
h = sn(**{})
## Optional Variables for Guided Positioning
margin = 30
spacing = 10
small = 150
medium = 225
large = 300
height = 40
h.bg = sn(
**{ ## gui.image(arg,"imagename", "image.jpg", (w,h)))
"obj":
gui.image(arg, "pg_1-bg", "bg.jpg", (g.frameWidth, g.frameHeight)),
"pos":
sn(**{
"x": 0,
"y": 0,
"w": g.frameWidth,
"h": g.frameHeight,
})
})
### LABEL
h.label1 = sn(
**{ ## gui.label(arg,"style","align","text")
"obj": gui.label(arg, "labelSmall", "center", "Hello There!"),
"pos": sn(**{
"x": margin,
"y": 300,
"w": medium,
"h": height,
})
})
### ENTRY
h.myEntry = sn(
**
{ ## gui.entry(arg,"style","align","text", name="entryName" ,password=True, keyboard=True, type=number),
"obj":
gui.entry(arg,
"entryMedium",
"center",
"Edit me!",
name="myEntry",
password=True,
keyboard=True),
"pos":
sn(**{
"x": 10,
"y": 10,
"w": 150,
"h": 30,
})
})
h.btnTest1 = sn(
**{ ## gui.button(arg,"style","unused","text",lambda: fcn(arg)),
## Function Wont Work on Quick View
"obj":
gui.button(arg, "btnBig", "center", "Push Me!",
lambda: arg.fcn_main.testFcn(arg)),
"pos":
sn(**{
"x": margin,
"y": 200,
"w": medium,
"h": height,
})
})
h.btnTest2 = sn(
**{ ## gui.button(arg,"style","unused","text",lambda: fcn(arg)),
"obj":
gui.button(arg, "btnBig", "center", "NEXT PAGE",
lambda: gui.showPage(arg, "pg_testing")),
"pos":
sn(
**{
"x": margin,
"y": h.btnTest1.pos.y + h.btnTest1.pos.h + spacing,
"w": medium,
"h": height,
})
})
#
data = ["Entry1", "fsfs"] ## ["Entry 1" , "Entry 2"]
h.listbox1 = sn(
**{
"obj":
gui.listbox(arg, data, "listbox1"),
"pos":
sn(
**{
"x": margin + medium + spacing,
"y": margin,
"w": large,
"h": 300,
})
})
data = ["Entry 1", "Entry 2"]
h.dropdown1 = sn(
**{
"obj": gui.dropdown(arg, "ddstyle", "center", data, "dropdown1"),
"pos": sn(**{
"x": 600,
"y": 20,
"w": 180,
"h": 35,
})
})
rsp = db(arg, "getPathologist")
data = []
for dt in rsp:
data.append([dt["name"], dt["status"]])
h.table1 = sn(
**{
"obj":
gui.ttk.Treeview(arg.master),
"pos":
sn(**{
"x": 70,
"y": 180,
"w": 650,
"h": 200,
}),
"table":
sn(
**{
"columns": [
sn(**{
"title": "Name",
"width": 500
}),
sn(**{
"title": "Status",
"width": 150
}),
# sn(**{"title" : "Brand", "width" : 150}),
# sn(**{"title" : "Equipment", "width" : 200}),
# sn(**{"title" : "Tag", "width" : 100}),
],
"data": [[]],
}),
})
# For Scrollbar
h.table1Scroll = sn(
**{
"obj":
gui.ttk.Scrollbar(
arg.master, orient="vertical", command=h.table1.obj.yview),
"pos":
sn(**{
"x": 725,
"y": 180,
"w": 25,
"h": 200,
})
})
h.table1.obj.configure(yscrollcommand=h.table1Scroll.obj.set)
# self.canvas.bind('<Button-1>', self.clicked)
# self.canvas.bind('<Double-1>', self.double_click)
# self.canvas.bind('<ButtonRelease-1>', self.button_released)
# self.canvas.bind('<B1-Motion>', self.moved)
# Bind double click even on table1 data/row.
h.table1.obj.bind(
'<Double-1>',
lambda event, t=h.table1.obj: arg.fcn_gui3.table1Double_ClickEven(arg))
# "data" : [
# ["Felipe Templo Jr, MD","ON-DUTY"],
# ["Jeffrey S. So, MD, DPSP","OFF-DUTY"],
# ["Francis G. Moria, MD, MSc FPSP","OFF-DUTY"],
# ["Jose Maria C. Avila, MD","ON-DUTY"],
# ["Michelle Anne M. Latoy, MD","ON-DUTY"],
# ["Aida Isabel Mendoza, MD","OFF-DUTY"],
# ["Charles Harris, MD","OFF-DUTY"],
# ["Felipe Templo Jr, MD","ON-DUTY"],
# ["Jeffrey S. So, MD, DPSP","OFF-DUTY"],
# ["Francis G. Moria, MD, MSc FPSP","OFF-DUTY"],
# ["Jose Maria C. Avila, MD","ON-DUTY"],
# ["Michelle Anne M. Latoy, MD","ON-DUTY"],
# ["Aida Isabel Mendoza, MD","OFF-DUTY"],
# ["Charles Harris, MD","OFF-DUTY"],
# ],
# h.scrollAlone = sn(**{
# "obj": gui.scroll(arg,"scrollstyle","center"),
# "pos": sn(**{
# "x": h.listbox1.pos.x + h.listbox1.pos.w + spacing,
# "y": margin,
# "w": 50,
# "h": 300,
# })
# })
# data = ["Entry1 - ON-DUTY","fsfs - OFF-DUTY"] ## ["Entry 1" , "Entry 2"]
# h.listbox1 = sn(**{
# "obj" : gui.listbox(arg,data,"listbox1"),
# "pos": sn(**{
# "x": 70,
# "y": 180,
# "w": 645,
# "h": 200,
# })
# })
# For Scrollbar
# h.listScroll = sn(**{
# "obj" : ttk.Scrollbar(master, orient="vertical",
# # command=handle["listbox1"]["element"].yview),
# command=h.listbox1.obj.yview),
# "pos" : sn(**{
# "x": 200,
# "y": 50,
# "w": 40,
# "h": 720,
# })
# })
# ##### SUB PROPERTIES OF THE ABOVE HANDLES
# h.listbox1.obj.configure(yscrollcommand=h.listScroll.obj.set);
h.checkbox = sn(
**{ ## gui.checkbox(arg,"yourText", lambda: test(arg)),
"obj": gui.checkbox(arg, "yourText", lambda: test(arg)),
"pos": sn(**{
"x": 10,
"y": 10,
"w": 150,
"h": 30,
})
})
# array 0 is the default value.
optionList1 = ('a', 'a', 'b', 'c')
h.combobox = sn(
**
{ ## ttk.OptionMenu(arg.master,v1,*optionList1, command=lambda selected:test123123(selected))
"obj":
gui.combobox(arg, optionList1,
lambda selected_val: test(selected_val)),
"pos":
sn(**{
"x": 50,
"y": 10,
"w": 150,
"h": 30,
})
})
h.progressbar = sn(
**
{ ## tttk.Progressbar(arg.master, orient = orient, length = length, mode = mode)
"obj": gui.progressbar(arg),
"pos": sn(**{
"x": 100,
"y": 10,
"w": 150,
"h": 30,
})
})
gui.hpropsobjs(arg, h)
return h
def saves(self):
assets = self.assets
sw, sh = self.sw, self.sh
settings_menu.firstpane = "saves"
self.base()
line = gui.pane([0, 30], [sw, 20])
line.align = "horiz"
self.children.append(line)
line.children.append(gui.label("Autosave?"))
class myb(gui.checkbox):
def click_down_over(self, *args):
super(myb, self).click_down_over(*args)
if self.checked:
assets.autosave = 1
else:
assets.autosave = 0
wini(assets)
line.children.append(myb("autosave"))
cb = line.children[-1]
if assets.autosave: cb.checked = True
line = gui.pane([0, 50], [sw, 20])
line.align = "horiz"
self.children.append(line)
line.children.append(gui.label("Minutes between autosave"))
class mymin(gui.editbox):
def insert(self, val):
if val not in u"0123456789":
return
super(mymin, self).insert(val)
def set(self, val):
super(mymin, self).set(val)
if not val:
val = 0
assets.autosave_interval = int(val)
wini(assets)
self.autosave_interval = str(assets.autosave_interval)
line.children.append(mymin(self, "autosave_interval"))
line = gui.pane([0, 70], [sw, 20])
line.align = "horiz"
self.children.append(line)
line.children.append(gui.label("Autosave backups"))
class mye(gui.editbox):
def insert(self, val):
if val not in u"0123456789":
return
super(mye, self).insert(val)
def set(self, val):
super(mye, self).set(val)
if not val:
val = 0
assets.autosave_keep = int(val)
wini(assets)
self.autosave_keep = str(assets.autosave_keep)
line.children.append(mye(self, "autosave_keep"))
line = gui.pane([0, 90], [sw, 20])
line.align = "horiz"
self.children.append(line)
if not assets.variables.get("_allow_saveload", "true"):
line.children.append(
gui.label("Save/Load currently disabled by game"))
else:
line.children.append(gui.label("Save/Load"))
line.children.append(gui.button(self, "save_game"))
line.children.append(gui.button(self, "load_game"))
def sound(self):
assets = self.assets
sw, sh = self.sw, self.sh
settings_menu.firstpane = "sound"
self.base()
ermsg = gui.label("")
ermsg.rpos = [0, 140]
ermsg.textcol = [255, 0, 0]
line = gui.pane([0, 130], [sw, 20])
line.align = "horiz"
self.children.append(line)
class myb(gui.checkbox):
def click_down_over(self, *args):
super(myb, self).click_down_over(*args)
if self.checked:
assets.set_mute_sound(True)
else:
assets.set_mute_sound(False)
line.children.append(myb("mute sound"))
if assets.mute_sound:
line.children[-1].checked = True
if android:
return
line = gui.pane([0, 30], [sw, 20])
line.align = "horiz"
self.children.append(line)
class newr(gui.radiobutton):
def click_down_over(s, *args):
ermsg.text = ""
gui.radiobutton.click_down_over(s, *args)
assets.sound_format = int(s.text)
if not assets.init_sound(True):
ermsg.text = "Sound not initialized"
else:
assets.play_sound("phoenix/objection.ogg")
wini(assets)
line.children.append(gui.label("Format:"))
line.children.append(newr("11025", "formchoice"))
line.children.append(newr("22050", "formchoice"))
line.children.append(newr("44100", "formchoice"))
for t in line.children:
if t.text == str(assets.sound_format):
t.checked = True
line = gui.pane([0, 50], [sw, 20])
line.align = "horiz"
self.children.append(line)
class newr(gui.radiobutton):
def click_down_over(s, *args):
ermsg.text = ""
gui.radiobutton.click_down_over(s, *args)
assets.sound_bits = int(s.text)
if not assets.init_sound(True):
ermsg.text = "Sound not initialized"
else:
assets.play_sound("phoenix/objection.ogg")
wini(assets)
line.children.append(gui.label("Bits:"))
line.children.append(newr("8", "bitschoice"))
line.children.append(newr("16", "bitschoice"))
for t in line.children:
if t.text == str(assets.sound_bits):
t.checked = True
line = gui.pane([0, 70], [sw, 20])
line.align = "horiz"
self.children.append(line)
class newr(gui.radiobutton):
def click_down_over(s, *args):
ermsg.text = ""
gui.radiobutton.click_down_over(s, *args)
assets.sound_buffer = int(s.text)
if not assets.init_sound(True):
ermsg.text = "Sound not initialized"
else:
assets.play_sound("phoenix/objection.ogg")
wini(assets)
line.children.append(gui.label("Buffer:"))
line.children.append(newr("512", "bufchoice"))
line.children.append(newr("1024", "bufchoice"))
line.children.append(newr("2048", "bufchoice"))
line.children.append(newr("4096", "bufchoice"))
for t in line.children:
if t.text == str(assets.sound_buffer):
t.checked = True
line = gui.pane([0, 90], [sw, 20])
line.align = "horiz"
self.children.append(line)
self.snd_line = gui.label("SoundVolume: %d" % assets.sound_volume)
def mod(amt, min, max, var, play):
def modit():
ermsg.text = ""
if not assets.init_sound():
ermsg.text = "Sound not initialized"
else:
n = getattr(assets, var) + amt
if n > max:
n = max
if n < min:
n = min
setattr(assets, var, n)
self.snd_line.text = "SoundVolume: %d" % assets.sound_volume
self.mv_line.text = "MusicVolume: %d" % assets.music_volume
play()
wini(assets)
return modit
line.children.append(self.snd_line)
line.children.append(gui.button(None, "less"))
line.children[-1].less = mod(
-10, 0, 100, "sound_volume",
lambda: assets.play_sound("phoenix/objection.ogg"))
line.children.append(gui.button(None, "more"))
line.children[-1].more = mod(
10, 0, 100, "sound_volume",
lambda: assets.play_sound("phoenix/objection.ogg"))
line = gui.pane([0, 110], [sw, 20])
line.align = "horiz"
self.children.append(line)
self.mv_line = gui.label("MusicVolume: %d" % assets.music_volume)
line.children.append(self.mv_line)
line.children.append(gui.button(None, "less"))
line.children[-1].less = mod(
-10, 0, 100, "music_volume", lambda: assets.play_music(
"Ding.ogg", loop=1, pre="sfx/", reset_track=False))
line.children.append(gui.button(None, "more"))
line.children[-1].more = mod(
10, 0, 100, "music_volume", lambda: assets.play_music(
"Ding.ogg", loop=1, pre="sfx/", reset_track=False))
self.children.append(ermsg)
def display(self):
assets = self.assets
sw, sh = self.sw, self.sh
settings_menu.firstpane = "display"
self.base()
res_box = gui.scrollpane([10, 20])
res_box.width = 200
res_box.height = 120
self.res_box = res_box
self.children.append(res_box)
res_box.add_child(
gui.button(
self,
"Change resolution (%sx%s)" % (assets.swidth, assets.sheight)))
res = res_box.pane.children[-1]
res.checked = True
res.click_down_over = self.popup_resolution
res_box.add_child(
gui.button(self, "dualscreen mode(%s)" % (assets.screen_mode)))
res = res_box.pane.children[-1]
self.screens = []
res.checked = True
res.click_down_over = self.popup_screenmode
res_box.add_child(gui.checkbox("smoothscale"))
self.smoothscale = res_box.pane.children[-1]
res_box.add_child(gui.checkbox("fullscreen"))
self.fs = res_box.pane.children[-1]
res_box.add_child(gui.checkbox("show fps"))
self.show_fps = res_box.pane.children[-1]
s_c1 = self.show_fps.set_checked
def set_checked(val):
s_c1(val)
assets.show_fps = val
wini(assets)
self.show_fps.set_checked = set_checked
self.frameskip = gui.checkbox("frameskip")
res_box.add_child(self.frameskip)
s_c = self.frameskip.set_checked
def set_checked1(val):
s_c(val)
if val:
assets.screen_refresh = 3
else:
assets.screen_refresh = 1
wini(assets)
self.frameskip.set_checked = set_checked1
#self.reses = gui.radiobutton.groups["resopt"]
if assets.fullscreen:
self.fs.checked = True
if assets.show_fps:
self.show_fps.checked = True
if assets.smoothscale:
self.smoothscale.checked = True
if assets.screen_refresh > 1:
self.frameskip.checked = True
self.children.append(gui.button(self, "apply", [10, 140]))
def __init__(self, players, superhero_pick=RandomPick, players_pick={}):
gui.gui_state.__init__(self)
self.library = cards.library("../dc-deck/pack1") # todo need to find a more elegant way, not to hardcode this!
self.game = game_object(self.library)
self.players_cards = []
self.played_cards = []
self.player_widgets = []
self.supervilain_widget = None
self.superhero_pick = superhero_pick
self.players_pick = players_pick
self.current_player = None
self.lineup_width = 106
self.lineup_height = 150
self.zoom_width = 424
self.zoom_height = 600
self.choice_overlay = None
for p in players:
self.game.add_player(p)
self.handle_quit = True
self.card_zoomed = False
self.zoomed_widget = None
self.game.roll_players_start()
if self.superhero_pick == self.RandomPick:
self.game.pick_superhero()
elif self.superhero_pick == self.ChosenPick:
self.game.assign_superhero(players_pick)
self.game.create_cards()
self.supervilain_widget = card_widget(self, self.game.current_supervilain, 106, 150)
self.supervilain_widget.zoom_width = 424
self.supervilain_widget.zoom_height = 600
self.add(self.supervilain_widget)
current_y = 0
for p in self.game.players:
widget = player_widget(p, 300, 120)
widget.y = current_y
self.add(widget)
self.player_widgets.append(widget)
current_y += widget.height
self.lineups = []
self.lineups_empty_case = []
self.curse_stack = card_widget(self, self.game.curses[0], 106, 150)
self.buyable_power_stack = card_widget(self, self.game.buyable_powers[0], 106, 150)
self.add(self.curse_stack)
self.add(self.buyable_power_stack)
l_start_x = 250
l_start_y = 300
self.curse_stack.x = l_start_x - 121*2
self.curse_stack.y = l_start_y
self.curse_stack.zoom_width = 424
self.curse_stack.zoom_height = 600
self.buyable_power_stack.x = l_start_x - 121
self.buyable_power_stack.y = l_start_y
self.buyable_power_stack.zoom_width = 424
self.buyable_power_stack.zoom_height = 600
self.supervilain_widget.x = l_start_x - 121
self.supervilain_widget.y = l_start_y + self.buyable_power_stack.height + 10
row = 0
for i in range(len(self.game.lineups)):
iw = i
if row == 1:
iw -= 3
widget = card_widget(self, self.game.lineups[i], 106, 150)
self.lineups.append(widget)
widget.x = l_start_x + 121*iw
widget.y = l_start_y + row*160
widget.zoom_width = 424
widget.zoom_height = 600
if i == 2:
row += 1
self.add(widget)
#turn info
self.lbl_current_turn = gui.label()
self.lbl_current_turn.text = "%s turns" % self.game.get_current_player().name
self.lbl_current_turn.x = 5
self.lbl_current_turn.y = 5
self.add(self.lbl_current_turn)
self.lbl_hand = gui.label()
self.lbl_hand.text = "Hand :"
self.lbl_hand.x = 10
self.lbl_hand.y = 160
self.add(self.lbl_hand)
self.hand_x = 70
self.hand_y = 160
self.hand_width = 91
self.hand_height = 130
self.play_x = 70
self.play_y = 20
self.play_width = 91
self.play_height = 130
#todo need a place for gained cards, or a widget that pop up on button..
self.gained_card_x = 0
self.gained_card_y = 0
#quit to main menu button
self.btn_quit_game = gui.button(200, 30)
self.btn_quit_game.x = 10
self.btn_quit_game.y = 10
self.btn_quit_game.caption = "Quit game"
self.btn_quit_game.add_receivers(self.quit_game)
self.btn_end_turn = gui.button(200, 50)
self.btn_end_turn.caption = "End turn"
self.btn_end_turn.add_receivers(self.end_turn)
self.ta_actions = gui.textarea(400, 100)
self.ta_actions.text = "Starting game"
self.add(self.ta_actions)
#actions bindings
self.game.change_turn = self.player_turn
self.game.card_played = self.played_card
self.game.lineup_changed = self.apply_lineup_action
self.buyable_power_stack.activated = self.buy_card
self.game.drawn_card = self.drawn_card
self.game.ask_player = self.ask_player
self.game.game_text = self.ta_actions.append
self.game.refresh_hands = self.refresh_hands
self.game.start_game()
def make_button(self,text,pos):
b = gui.button(self,text,pos)
self.children.append(b)
return b
def initButtonControls(x, y):
selectButton = gui.button("Select", 10+x, 5+y, selectHandler)
pass
FPS_LIMIT = 30 # frames per second
# Init
pygame.mixer.init(engine.synths.SOUND_SAMPLERATE, -16, 1)
pygame.init()
pygame.display.set_caption("8BitTracker")
screen = gui.init_screen(gui.SCREEN_WIDTH, gui.SCREEN_HEIGHT)
# Testing beep. This one lasts for 100 milliseconds and is at 880Hz (A5).
sound = engine.synths.make_beep(880, .1)
labelFPS = gui.label(10, 24, "60 fps")
buttonAccept = gui.button(10, 15, "Accept", 0, 8, False)
gui.rect(screen.chars, 9, 9, 13, 3, 12, 4, 0)
lastRefresh = 0
currentFPS = 0
# Main Loop
while 1:
# events
for event in pygame.event.get():
if event.type is pygame.KEYDOWN:
# Press ESCAPE to exit the program
if event.key is pygame.K_ESCAPE:
sys.exit()
def run(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
elif event.type == pygame.VIDEORESIZE:
pygame.display.set_mode(
(event.size[0], event.size[1] - GRID_CELL_SIZE),
pygame.RESIZABLE)
break
pygame.init()
self.screen = pygame.display.get_surface()
if self.screen:
self.screensize = self.screen.get_size()
else:
info = pygame.display.Info()
self.screensize = (info.current_w, info.current_h)
self.screen = pygame.display.set_mode(self.screensize)
screensize = self.screensize
decksel = False
c8sheader = gui.label((100, 300), (200, 75), _('Crazy Eights'),
(0, 128, 0))
c8s2p = gui.button((100, 400), (200, 35), _("Two players"))
c8s3p = gui.button((100, 450), (200, 35), _("Three players"))
c8s4p = gui.button((100, 500), (200, 35), _("Four players"))
c8sframe = gui.frame((c8sheader, c8s2p, c8s3p, c8s4p), (75, 275),
(250, 275))
maindeck = gui.button((50, screensize[1] - 75), (85, 35), _("Deck"))
mainphoto = gui.button((screensize[0] - 200, screensize[1] - 75),
(160, 35), _("Photo deck"))
mainheader = gui.image((50, 25), (screensize[0] - 100, 200),
'fiftytwo.png', -1)
mainframe = gui.frame((mainheader, maindeck, mainphoto),
(25, screensize[1] - 100),
(screensize[0] - 50, 75))
deckselexit = gui.button((screensize[0] - 215, screensize[1] - 145),
(115, 35), _("Cancel"))
deckfromjournal = gui.button(
(screensize[0] - 445, screensize[1] - 145), (200, 35),
_("from Journal"))
deckselregular = gui.image(
(115, 115), (crazyeights.card_width(), crazyeights.card_height()),
'back.regular.png')
deckselgnome = gui.image(
(300, 115), (crazyeights.card_width(), crazyeights.card_height()),
'back.gnome.png')
deckselparis = gui.image(
(485, 115), (crazyeights.card_width(), crazyeights.card_height()),
'back.paris.png')
deckselshapes = gui.image(
(670, 115), (crazyeights.card_width(), crazyeights.card_height()),
'back.shapes.png')
self.deckseluser = gui.image(
(855, 115), (crazyeights.card_width(), crazyeights.card_height()),
'back.user.png')
deckselpopup = gui.popup(
(deckselexit, deckfromjournal, deckselregular, deckselgnome,
deckselparis, deckselshapes, self.deckseluser), (100, 100),
(screensize[0] - 200, screensize[1] - 200))
mouseposition = [0, 0, 0]
self.screen.fill((192, 64, 255))
# Set the name of the players
names = []
names.append('l' + _('You'))
names.append('a' + _('XO player #1'))
names.append('a' + _('XO player #2'))
names.append('a' + _('XO player #3'))
names.append('a' + _('The XO'))
fpslimiter = pygame.time.Clock()
while True:
fpslimiter.tick(20)
while Gtk.events_pending():
Gtk.main_iteration()
for event in pygame.event.get():
if event.type == pygame.MOUSEMOTION:
mouseposition[0] = event.pos[0]
mouseposition[1] = event.pos[1]
elif event.type == pygame.MOUSEBUTTONDOWN:
mouseposition[2] = 1
elif event.type == pygame.MOUSEBUTTONUP:
mouseposition[2] = 0
if not decksel and c8s2p.detect_click(event.pos):
crazyeights.main((names[4], names[0]), screensize)
self.screen.fill(MMCOL)
pygame.event.set_allowed(pygame.MOUSEMOTION)
elif not decksel and c8s3p.detect_click(event.pos):
crazyeights.main((names[1], names[2], names[0]),
screensize)
self.screen.fill(MMCOL)
pygame.event.set_allowed(pygame.MOUSEMOTION)
elif not decksel and c8s4p.detect_click(event.pos):
crazyeights.main(
(names[1], names[2], names[0], names[3]),
screensize)
self.screen.fill(MMCOL)
pygame.event.set_allowed(pygame.MOUSEMOTION)
elif not decksel and maindeck.detect_click(event.pos):
decksel = True
elif not decksel and mainphoto.detect_click(event.pos):
self.photo()
self.screen.fill(MMCOL)
elif decksel and deckselexit.detect_click(event.pos):
decksel = False
self.screen.fill(MMCOL)
elif decksel and deckfromjournal.detect_click(event.pos):
picture = self.parent.load_image_from_journal()
if picture:
self.update_user_deck(picture.file_path)
self.screen.fill(MMCOL)
elif decksel and deckselgnome.detect_click(event.pos):
deck.deck = 'gnome'
decksel = False
self.screen.fill(MMCOL)
elif decksel and deckselregular.detect_click(event.pos):
deck.deck = 'regular'
decksel = False
self.screen.fill(MMCOL)
elif decksel and deckselparis.detect_click(event.pos):
deck.deck = 'paris'
decksel = False
self.screen.fill(MMCOL)
elif decksel and deckselshapes.detect_click(event.pos):
deck.deck = 'shapes'
decksel = False
self.screen.fill(MMCOL)
elif decksel and self.deckseluser.detect_click(event.pos):
deck.deck = 'user'
decksel = False
self.screen.fill(MMCOL)
if not decksel:
c8sframe.update()
c8sframe.draw(self.screen, mouseposition)
mainframe.update()
mainframe.draw(self.screen, mouseposition)
else:
deckselpopup.update()
deckselpopup.draw(self.screen, mouseposition)
pygame.display.flip()
def photo(self):
screensize = self.screensize
mouseposition = [0, 0, 0]
self.screen = pygame.display.get_surface()
fpslimiter = pygame.time.Clock()
photodynamic = gui.image((125, 125), (640, 480), 'back.regular.png')
photoreturn = gui.button((screensize[0] - 300, screensize[1] - 175),
(150, 35), _("Cancel"))
photopopup = gui.popup((photodynamic, photoreturn), (100, 100),
(screensize[0] - 200, screensize[1] - 200))
pygame.camera.init()
cams = pygame.camera.list_cameras()
if cams:
photocamera = pygame.camera.Camera(cams[0], (640, 480), 'RGB')
photocamera.start()
photocamera.set_controls(True, False)
camera_size = photocamera.get_size()
capture = pygame.surface.Surface(camera_size, 0, self.screen)
photodynamic.image = photocamera.get_image(capture)
running = True
while running:
fpslimiter.tick(20)
photodynamic.image = photocamera.get_image(capture)
while Gtk.events_pending():
Gtk.main_iteration()
for event in pygame.event.get():
"""if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
photodynamic.image = photocamera.get_image(capture)"""
if event.type == pygame.MOUSEMOTION:
mouseposition[0] = event.pos[0]
mouseposition[1] = event.pos[1]
elif event.type == pygame.MOUSEBUTTONDOWN:
mouseposition[2] = 1
self.flush_queue()
elif event.type == pygame.MOUSEBUTTONUP:
mouseposition[2] = 0
if photoreturn.detect_click(event.pos):
running = False
elif photodynamic.detect_click(event.pos):
r = photodynamic.image.get_rect()
r.x = mouseposition[0] - 125
r.y = mouseposition[1] - 125
r.w = 156
r.h = 244
sub = photodynamic.image.subsurface(r)
# borde negro
pygame.draw.rect(sub, (0, 0, 0), (0, 0, r.w, r.h),
3)
pygame.image.save(sub, 'data/back.user.png')
self.deckseluser.image = sub
deck.deck = 'user'
running = False
photopopup.update()
photopopup.draw(self.screen, mouseposition)
r = self.screen.get_rect()
r.x = 125
r.y = 125
r.w = 640
r.h = 480
self.screen.set_clip(r)
r.x = mouseposition[0]
r.y = mouseposition[1]
r.w = 156
r.h = 244
pygame.draw.rect(self.screen, (255, 0, 0), r, 4)
self.screen.set_clip()
pygame.display.flip()
photocamera.stop()
def make_button(self, text, pos):
b = gui.button(self, text, pos)
self.children.append(b)
return b
pass
if __name__ == "__main__":
screen = pygame.display.set_mode((800, 600))
mytimer = pygame.time.Clock()
def toolHandler(selectedTool):
global tool
tool = selectedTool
printTool()
def selectHandler():
toolHandler(SELECT)
selectButton = gui.button("Select", 10, 5, selectHandler)
def createBoxHandler():
toolHandler(CREATEBOX)
boxButton = gui.button("Box", 10, 35, createBoxHandler)
def createSphereHandler():
toolHandler(CREATESPHERE)
sphereButton = gui.button("Sphere", 10, 65, createSphereHandler)
def createConnectionHandler():
toolHandler(CREATECONNECTION)
connectionButton = gui.button("Connection", 10, 95, createConnectionHandler)
def printTool():
def saves(self):
assets = self.assets
sw,sh = self.sw,self.sh
settings_menu.firstpane = "saves"
self.base()
line = gui.pane([0,30],[sw,20])
line.align = "horiz"
self.children.append(line)
line.children.append(gui.label("Autosave?"))
class myb(gui.checkbox):
def click_down_over(self,*args):
super(myb,self).click_down_over(*args)
if self.checked:
assets.autosave = 1
else:
assets.autosave = 0
wini(assets)
line.children.append(myb("autosave"))
cb = line.children[-1]
if assets.autosave: cb.checked = True
line = gui.pane([0,50],[sw,20])
line.align = "horiz"
self.children.append(line)
line.children.append(gui.label("Minutes between autosave"))
class mymin(gui.editbox):
def insert(self,val):
if val not in u"0123456789":
return
super(mymin,self).insert(val)
def set(self,val):
super(mymin,self).set(val)
if not val:
val = 0
assets.autosave_interval = int(val)
wini(assets)
self.autosave_interval = str(assets.autosave_interval)
line.children.append(mymin(self,"autosave_interval"))
line = gui.pane([0,70],[sw,20])
line.align = "horiz"
self.children.append(line)
line.children.append(gui.label("Autosave backups"))
class mye(gui.editbox):
def insert(self,val):
if val not in u"0123456789":
return
super(mye,self).insert(val)
def set(self,val):
super(mye,self).set(val)
if not val:
val = 0
assets.autosave_keep = int(val)
wini(assets)
self.autosave_keep = str(assets.autosave_keep)
line.children.append(mye(self,"autosave_keep"))
line = gui.pane([0,90],[sw,20])
line.align = "horiz"
self.children.append(line)
if not assets.variables.get("_allow_saveload","true"):
line.children.append(gui.label("Save/Load currently disabled by game"))
else:
line.children.append(gui.label("Save/Load"))
line.children.append(gui.button(self,"save_game"))
line.children.append(gui.button(self,"load_game"))
def sound(self):
assets = self.assets
sw,sh = self.sw,self.sh
settings_menu.firstpane = "sound"
self.base()
ermsg = gui.label("")
ermsg.rpos = [0,140]
ermsg.textcol = [255,0,0]
line = gui.pane([0,130],[sw,20])
line.align = "horiz"
self.children.append(line)
class myb(gui.checkbox):
def click_down_over(self,*args):
super(myb,self).click_down_over(*args)
if self.checked:
assets.set_mute_sound(True)
else:
assets.set_mute_sound(False)
line.children.append(myb("mute sound"))
if assets.mute_sound:
line.children[-1].checked = True
if android:
return
line = gui.pane([0,30],[sw,20])
line.align = "horiz"
self.children.append(line)
class newr(gui.radiobutton):
def click_down_over(s,*args):
ermsg.text = ""
gui.radiobutton.click_down_over(s,*args)
assets.sound_format = int(s.text)
if not assets.init_sound(True):
ermsg.text = "Sound not initialized"
else:
assets.play_sound("phoenix/objection.ogg")
wini(assets)
line.children.append(gui.label("Format:"))
line.children.append(newr("11025","formchoice"))
line.children.append(newr("22050","formchoice"))
line.children.append(newr("44100","formchoice"))
for t in line.children:
if t.text==str(assets.sound_format):
t.checked = True
line = gui.pane([0,50],[sw,20])
line.align = "horiz"
self.children.append(line)
class newr(gui.radiobutton):
def click_down_over(s,*args):
ermsg.text = ""
gui.radiobutton.click_down_over(s,*args)
assets.sound_bits = int(s.text)
if not assets.init_sound(True):
ermsg.text = "Sound not initialized"
else:
assets.play_sound("phoenix/objection.ogg")
wini(assets)
line.children.append(gui.label("Bits:"))
line.children.append(newr("8","bitschoice"))
line.children.append(newr("16","bitschoice"))
for t in line.children:
if t.text==str(assets.sound_bits):
t.checked = True
line = gui.pane([0,70],[sw,20])
line.align = "horiz"
self.children.append(line)
class newr(gui.radiobutton):
def click_down_over(s,*args):
ermsg.text = ""
gui.radiobutton.click_down_over(s,*args)
assets.sound_buffer = int(s.text)
if not assets.init_sound(True):
ermsg.text = "Sound not initialized"
else:
assets.play_sound("phoenix/objection.ogg")
wini(assets)
line.children.append(gui.label("Buffer:"))
line.children.append(newr("512","bufchoice"))
line.children.append(newr("1024","bufchoice"))
line.children.append(newr("2048","bufchoice"))
line.children.append(newr("4096","bufchoice"))
for t in line.children:
if t.text==str(assets.sound_buffer):
t.checked = True
line = gui.pane([0,90],[sw,20])
line.align = "horiz"
self.children.append(line)
self.snd_line = gui.label("SoundVolume: %d"%assets.sound_volume)
def mod(amt,min,max,var,play):
def modit():
ermsg.text = ""
if not assets.init_sound():
ermsg.text = "Sound not initialized"
else:
n = getattr(assets,var) + amt
if n>max:
n = max
if n<min:
n=min
setattr(assets,var,n)
self.snd_line.text = "SoundVolume: %d"%assets.sound_volume
self.mv_line.text = "MusicVolume: %d"%assets.music_volume
play()
wini(assets)
return modit
line.children.append(self.snd_line)
line.children.append(gui.button(None,"less"))
line.children[-1].less = mod(-10,0,100,"sound_volume",lambda:assets.play_sound("phoenix/objection.ogg"))
line.children.append(gui.button(None,"more"))
line.children[-1].more = mod(10,0,100,"sound_volume",lambda:assets.play_sound("phoenix/objection.ogg"))
line = gui.pane([0,110],[sw,20])
line.align = "horiz"
self.children.append(line)
self.mv_line = gui.label("MusicVolume: %d"%assets.music_volume)
line.children.append(self.mv_line)
line.children.append(gui.button(None,"less"))
line.children[-1].less = mod(-10,0,100,"music_volume",lambda:assets.play_music("Ding.ogg",loop=1,pre="data/sfx/",reset_track=False))
line.children.append(gui.button(None,"more"))
line.children[-1].more = mod(10,0,100,"music_volume",lambda:assets.play_music("Ding.ogg",loop=1,pre="data/sfx/",reset_track=False))
self.children.append(ermsg)
def display(self):
assets = self.assets
sw,sh = self.sw,self.sh
settings_menu.firstpane = "display"
self.base()
res_box = gui.scrollpane([10,20])
res_box.width = 200
res_box.height = 120
self.res_box = res_box
self.children.append(res_box)
res_box.add_child(gui.button(self,"Change resolution (%sx%s)"%(assets.swidth,assets.sheight)))
res = res_box.pane.children[-1]
res.checked = True
res.click_down_over = self.popup_resolution
res_box.add_child(gui.button(self,"dualscreen mode(%s)"%(assets.screen_mode)))
res = res_box.pane.children[-1]
self.screens = []
res.checked = True
res.click_down_over = self.popup_screenmode
res_box.add_child(gui.checkbox("smoothscale"))
self.smoothscale = res_box.pane.children[-1]
res_box.add_child(gui.checkbox("fullscreen"))
self.fs = res_box.pane.children[-1]
res_box.add_child(gui.checkbox("show fps"))
self.show_fps = res_box.pane.children[-1]
s_c1 = self.show_fps.set_checked
def set_checked(val):
s_c1(val)
assets.show_fps = val
wini(assets)
self.show_fps.set_checked = set_checked
self.frameskip = gui.checkbox("frameskip")
res_box.add_child(self.frameskip)
s_c = self.frameskip.set_checked
def set_checked1(val):
s_c(val)
if val:
assets.screen_refresh = 3
else:
assets.screen_refresh = 1
wini(assets)
self.frameskip.set_checked = set_checked1
#self.reses = gui.radiobutton.groups["resopt"]
if assets.fullscreen:
self.fs.checked = True
if assets.show_fps:
self.show_fps.checked = True
if assets.smoothscale:
self.smoothscale.checked = True
if assets.screen_refresh>1:
self.frameskip.checked = True
self.children.append(gui.button(self,"apply",[10,140]))
def __init__(self):
gui.gui_state.__init__(self)
#loading superheroes
self.library = cards.library("../dc-deck/pack1")
self.lbl_title = gui.label()
self.lbl_title.font = gui.get_big_font()
self.lbl_title.text = "Game Setup"
self.lbl_players_name = gui.label()
self.lbl_players_name.text = "Players name"
self.lbl_players_num = gui.label()
self.lbl_players_num.text = "Number of players : "
self.lbl_players_num.render()
self.cb_players_num = gui.combobox(50, 22)
self.cb_players_num.items.append("2")
self.cb_players_num.items.append("3")
self.cb_players_num.items.append("4")
self.cb_players_num.items.append("5")
self.cb_players_num.add_receiver(self.player_num_changed)
self.lbl_cb_superhero_pick = gui.label()
self.lbl_cb_superhero_pick.text = "Random superhero : "
self.cb_superhero_pick = gui.checkbox()
self.cb_superhero_pick.checked = True
self.cb_superhero_pick.state_changed = self.pick_random_changed
self.add(self.lbl_title)
self.add(self.lbl_players_name)
self.add(self.lbl_players_num)
self.add(self.cb_players_num)
self.add(self.lbl_cb_superhero_pick)
self.add(self.cb_superhero_pick)
self.tb_players = []
self.lbl_players = []
self.slider_player_superhero = []
nb_players = int(self.cb_players_num.get_item())
for i in range(5):
tb = gui.textbox(180, 22)
self.tb_players.append(tb)
self.add(tb)
lbl = gui.label(25, 22)
lbl.text = str(i+1) + " : "
self.lbl_players.append(lbl)
self.add(lbl)
if i < nb_players:
tb.visible = True
lbl.visible = True
else:
tb.visible = False
lbl.visible = False
slider = gui.slider(100, 22)
slider.visible = False
for s in self.library.superheroes:
slider.items.append(s.name)
self.slider_player_superhero.append(slider)
self.add(slider)
self.btn_start = gui.button(180, 40)
self.btn_start.caption = "Start !"
self.btn_start.add_receivers(self.start_game)
self.btn_back = gui.button(180, 40)
self.btn_back.caption = "Back"
self.btn_back.add_receivers(self.back)
self.add(self.btn_start)
self.add(self.btn_back)
