def __init__(self, text, length, limvals, initial_value, reblit=None, type_=float, order="ins"): import thorpy self.text = thorpy.make_button(text, self.focus) self.slider = thorpy.SliderX.make(length, limvals, "", type_, initial_value) self.ins = thorpy.Inserter.make("", value=str(initial_value)) if order == "ins": els = [self.text, self.ins, self.slider] else: els = [self.text, self.slider, self.ins] self.e = thorpy.make_group(els) reac_slide = thorpy.Reaction( reacts_to=thorpy.constants.THORPY_EVENT, reac_func=self.at_slide, event_args={"id": thorpy.constants.EVENT_SLIDE}) reac_ins = thorpy.Reaction( reacts_to=thorpy.constants.THORPY_EVENT, reac_func=self.at_insert, event_args={"id": thorpy.constants.EVENT_INSERT}) self.e.add_reactions([reac_slide, reac_ins]) self.e._manager = self self.ins._manager = self self.slider._manager = self self.e.get_value = self.slider.get_value self.reblit = reblit if not self.reblit: self.reblit = self.e.unblit_and_reblit
def first_render(self, location): self.elements = [] self.elements.append(thorpy.make_text("Smelter")) self.smelt_items = [thorpy.Clickable.make("None") for x in range(self.max_inv_size)] self.button = thorpy.make_button("Smelt", func=self.smelt) self.smelt_item_box = thorpy.Box.make(elements=self.smelt_items) self.elements.append(self.smelt_item_box) self.elements.append(self.button) self.smelted_item = thorpy.Clickable.make("None") self.smelted_item_box = thorpy.Box.make(elements=[self.smelted_item]) self.elements.append(self.smelted_item_box) self.box = thorpy.Box.make(elements=self.elements) self.drag = thorpy.Draggable.make(elements=[self.box]) reaction = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT, reac_func=self._pop_smelter, params={"item": self.smelted_item}, event_args={"id":thorpy.constants.EVENT_PRESS}) for item in self.elements: item.center(axis=(True, False), element=self.box) self.drag.add_reaction(reaction) self.drag.set_topleft(location) self.sub_menu = thorpy.Menu(self.drag) thorpy.functions.set_current_menu(self.sub_menu) self.sub_menu.blit_and_update()
def first_render(self, location): self.elements = [] self.elements.append(thorpy.make_text("Inventory")) self.item_clickables = [thorpy.Clickable.make("None") for x in range(self.max_inv_size)] self.item_box = thorpy.Box.make(elements=self.item_clickables) self.elements.append(self.item_box) self.button = thorpy.make_button("Inv", func=self._print_all) self.elements.append(self.button) self.inv_box = thorpy.Box.make(elements=self.elements) self.inv_drag = thorpy.Draggable.make(elements=[self.inv_box]) for item in self.item_clickables: item.center(axis=(True, False), element=self.inv_box) # this reaction allows us to click the item we want to smelt # and transfer it into the smelter reaction = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT, reac_func=self._add_to_smelter, params={"item": item}, event_args={"id":thorpy.constants.EVENT_PRESS}) self.inv_drag.add_reaction(reaction) self.inv_drag.set_topleft(location) self.inv_menu = thorpy.Menu(self.inv_drag) thorpy.functions.set_current_menu(self.inv_menu) self.inv_menu.blit_and_update()
def join_game(self): self.playerJoiningEdit = thorpy.Inserter.make("Player name: ") playerJoiningEnterReaction = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT, reac_func=self.get_games_list, event_args={"id": thorpy.constants.EVENT_INSERT}) self.playerJoiningEdit.add_reaction(playerJoiningEnterReaction) self.replace_elements([self.playerJoiningEdit])
def init_ui(screen): slider = thorpy.SliderX(100, (5, 15), "Simulation speed") slider.user_func = slider_reaction button_stop = thorpy.make_button("Quit", func=stop_execution) button_pause = thorpy.make_button("Pause", func=pause_execution) button_play = thorpy.make_button("Play", func=start_execution) timer = thorpy.OneLineText("Seconds passed") button_load = thorpy.make_button(text="Load a file", func=open_file) box = thorpy.Box(elements=[ slider, button_pause, button_stop, button_play, button_load, timer ]) reaction1 = thorpy.Reaction( reacts_to=thorpy.constants.THORPY_EVENT, reac_func=slider_reaction, event_args={"id": thorpy.constants.EVENT_SLIDE}, params={}, reac_name="slider reaction") box.add_reaction(reaction1) menu = thorpy.Menu(box) for element in menu.get_population(): element.surface = screen box.set_topleft((0, 0)) box.blit() box.update() return menu, box, timer
def _initialize(self): self.reac_keydown = thorpy.Reaction(pygame.KEYDOWN, self.func_keydown) self.e.add_reaction(self.reac_keydown) # self.reac_time = thorpy.ConstantReaction( thorpy.constants.THORPY_EVENT, self.func_time, {"id": thorpy.constants.EVENT_TIME}) self.e.add_reaction(self.reac_time)
def add_reactions(self): reac_click = thorpy.Reaction(pygame.MOUSEBUTTONDOWN, self.lmb, {"button": 1}) self.me.e_box.add_reaction(reac_click) reac_click = thorpy.Reaction(pygame.MOUSEBUTTONDOWN, self.rmb, {"button": 3}) self.me.e_box.add_reaction(reac_click) reac_motion = thorpy.Reaction(pygame.MOUSEMOTION, self.mousemotion) self.me.e_box.add_reaction(reac_motion) ## reac_escape = thorpy.ConstantReaction(pygame.KEYDOWN, self.esc_menu, {"key":pygame.K_ESCAPE}) ## self.me.e_box.add_reaction(reac_escape) shortcuts = [(pygame.K_l, self.toggle_show_life), (pygame.K_ESCAPE, self.launch_map_menu), (pygame.K_PERIOD, self.find_free_unit), (pygame.K_BACKSPACE, self.cancel)] reacs = [] for key, func in shortcuts: reacs.append( thorpy.ConstantReaction(pygame.KEYDOWN, func, {"key": key})) self.me.e_box.add_reactions(reacs)
def __init__(self, size, cell_size, redraw, external_e): self.unit = None ## self.cell = None probleme self.e_img = thorpy.Image.make(pygame.Surface(cell_size)) ## self.e_img = thorpy.Image.make(pygame.Surface((1,1))) self.blank_img = pygame.Surface(cell_size) self.e_name = guip.get_title("Unit infos (no unit)") # ## self.e_group = thorpy.make_group([self.e_img, self.e_name]) ghost = thorpy.Ghost([self.e_img, self.e_name]) ghost.finish() self.e_img.set_center_pos(ghost.get_fus_center()) self.e_name.set_center_pos(self.e_img.get_fus_center()) ghost.fit_children() self.e_group = ghost # self.elements = [self.e_group] self.e = thorpy.Box.make(self.elements) self.e.set_size((size[0], None)) for e in self.e.get_elements(): e.recenter() ## #emap : to be displayed when a cell is clicked self.em_title = guip.get_title("Unit informations") ## self.em_coord = guip.get_text("") ## self.em_altitude = guip.get_text("") self.em_name = guip.get_small_text("") self.em_rename = guip.get_small_button("Rename", self.rename_current_unit) self.em_name_rename = thorpy.make_group([self.em_name, self.em_rename]) #### self.em_name_rename = thorpy.Clickable.make(elements=[self.em_name, self.em_rename]) #### thorpy.store(self.em_name_rename) self.em_name_rename.fit_children() self.em_unit_img_img = thorpy.Image.make(pygame.Surface(cell_size)) self.em_unit_img = thorpy.Clickable.make( elements=[self.em_unit_img_img]) self.em_unit_img.fit_children() self.em_unit_name = guip.get_text("") self.em_unit = thorpy.make_group([self.em_unit_img, self.em_unit_name]) self.em_elements = [ self.em_title, thorpy.Line.make(100), self.em_unit, self.em_name_rename ] self.em = thorpy.Box.make(self.em_elements) self.em.set_main_color((200, 200, 200, 150)) self.launched = False self.redraw = redraw self.external_e = external_e reac = thorpy.Reaction(thorpy.THORPY_EVENT, self.set_unlaunched, {"id": thorpy.constants.EVENT_UNLAUNCH}) external_e.add_reaction(reac) self.last_cell_clicked = None self.e_img.visible = False
def run_application(): W, H = 300, 300 application = thorpy.Application(size=(W, H), caption="Real life example") draggable = thorpy.Draggable("Drag me") sx = thorpy.SliderX(length=100, limvals=(0, W), text="X:", type_=int) sy = thorpy.SliderX(length=100, limvals=(0, H), text="Y:", type_=int) background = thorpy.Background(color=(200, 255, 255), elements=[draggable, sx, sy]) thorpy.store(background, [sx, sy]) reaction1 = thorpy.Reaction( reacts_to=thorpy.constants.THORPY_EVENT, reac_func=refresh_drag, event_args={"id": thorpy.constants.EVENT_SLIDE}, params={ "drag": draggable, "sx": sx, "sy": sy }, reac_name="my reaction to slide event") reaction2 = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT, reac_func=refresh_sliders, event_args={"id": thorpy.constants.EVENT_DRAG}, params={ "drag": draggable, "sx": sx, "sy": sy }, reac_name="my reaction to drag event") background.add_reaction(reaction1) background.add_reaction(reaction2) menu = thorpy.Menu(background) #create a menu for auto events handling menu.play() #launch the menu application.quit()
def get_games_list(self, event): player_name = event.el.get_value() r = Api.getPlayerInfo(player_name) games_list = [id for id in r["games"]] if r is not None else [] label = thorpy.OneLineText.make("Here's a list of games " + player_name + " is in:") self.gamesListEdit = thorpy.DropDownList.make(games_list, size=(250,150), x=5) self.gamesListEdit.finish() gameSelectReaction = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT, reac_func=self.start_game_join, event_args={"id": thorpy.constants.EVENT_DDL}) self.gamesListEdit.add_reaction(gameSelectReaction) goBackButton = thorpy.make_button("Go Back", func=self.start_menu) self.replace_elements([label, self.gamesListEdit, goBackButton])
def launch_blocking_choices_str(text, choices, parent=None, title_fontsize=None, title_fontcolor=None, func=None, store="v"): """choices are tuple (text,func)""" if title_fontsize is None: title_fontsize = thorpy.style.FONT_SIZE if title_fontcolor is None: title_fontcolor = thorpy.style.FONT_COLOR class Choice: value = None def choice_func(value): Choice.value = value elements = [] for name in choices: e = thorpy.make_button(name, choice_func, {"value": name}) elements.append(e) ghost = thorpy.make_group(elements, mode=store) e_text = thorpy.make_text(text, title_fontsize, title_fontcolor) box = thorpy.Box.make([e_text, thorpy.Line(100, "h"), ghost]) box.center() from thorpy.miscgui.reaction import ConstantReaction for e in elements: reac = ConstantReaction(thorpy.constants.THORPY_EVENT, thorpy.functions.quit_menu_func, { "id": thorpy.constants.EVENT_UNPRESS, "el": e }) box.add_reaction(reac) def click_outside(e): if not box.get_fus_rect().collidepoint(e.pos): thorpy.functions.quit_menu_func() reac = thorpy.Reaction(pygame.MOUSEBUTTONDOWN, click_outside) box.add_reaction(reac) from thorpy.menus.tickedmenu import TickedMenu m = TickedMenu(box) m.play() box.unblit() if parent: parent.partial_blit(None, box.get_fus_rect()) box.update() if func: func() return Choice.value
def Menu(): '''Создает окно запуска''' button_play = thorpy.make_button("Play",start_execution) timer = thorpy.OneLineText("Seconds passed") box = thorpy.Box(elements=[ button_play, timer]) my_reaction = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT, reac_func=start_execution) menu = thorpy.Menu(box) for element in menu.get_population(): element.surface = screen box.set_topleft((0, 0)) box.blit() box.update() return menu,box,timer
def __init__(self, me, size, cell_size, redraw, external_e): self.me = me self.wline = int(0.75*size[0]) self.e_coordalt = thorpy.make_text("(?,?)", font_size=10, font_color=(200,200,200)) self.e_mat_img = thorpy.Image.make(pygame.Surface(cell_size)) self.e_mat_name = guip.get_text("") self.e_obj_name = guip.get_text("") self.e_mat_obj = thorpy.make_group([self.e_mat_name, self.e_obj_name], "v") ## self.e_mat = thorpy.make_group([self.e_mat_img, self.e_mat_obj]) self.e_mat = thorpy.Box(elements=[self.e_mat_img, self.e_mat_obj]) ## self.e_mat.fit_children(axis=(False, True)) self.elements = [self.e_mat, self.e_coordalt] self.e = thorpy.Box.make(self.elements) self.e.set_main_color((20,20,20)) self.e.set_size((size[0],int(0.8*self.e.get_fus_size()[1])), margins=(2,2)) for e in self.e.get_elements(): e.recenter() self.cell = None #emap : to be displayed when a cell is clicked self.em_title = guip.get_title("Cell informations") self.em_coord = guip.get_text("") self.em_altitude = guip.get_text("") self.em_name = guip.get_small_text("") self.em_rename = guip.get_small_button("Rename", self.rename_current_cell) self.em_name_rename = thorpy.make_group([self.em_name, self.em_rename]) ## self.em_name_rename = thorpy.Clickable.make(elements=[self.em_name, self.em_rename]) ## thorpy.store(self.em_name_rename) self.em_name_rename.fit_children() self.em_mat_img_img = thorpy.Image.make(pygame.Surface(cell_size)) self.em_mat_img = thorpy.Clickable.make(elements=[self.em_mat_img_img]) self.em_mat_img.fit_children() self.em_mat_name = guip.get_text("") self.em_obj_name = guip.get_text("") self.em_mat_obj = thorpy.make_group([self.em_mat_name, self.em_obj_name], "v") self.em_mat = thorpy.make_group([self.em_mat_img, self.em_mat_obj]) ## self.em_elements = [self.em_title, thorpy.Line.make(self.wline), self.em_mat, self.em_coord, self.em_altitude, self.em_name_rename] self.em_elements = [self.em_title, thorpy.Line.make(self.wline), self.em_mat, self.em_coord, self.em_name_rename] self.em = thorpy.Box.make(self.em_elements) self.em.set_main_color((200,200,200,150)) self.launched = False self.redraw = redraw self.external_e = external_e reac = thorpy.Reaction(thorpy.THORPY_EVENT, self.set_unlaunched, {"id":thorpy.constants.EVENT_UNLAUNCH}) external_e.add_reaction(reac) self.last_cell_clicked = None
def create_menu(self): self.acceleration_button = thorpy.Checker.make( "Computer Controlled Accel") self.acceleration_slider = thorpy.SliderX.make( length=80, limvals=(0, self.slide_limit), text="Acceleration:", type_=int) self.maxSpeed_slider = thorpy.SliderX.make(length=80, limvals=(0, self.slide_limit), text="Speed Limit:", type_=int) self.quit_button = thorpy.make_button("Quit", func=thorpy.functions.quit_func) self.menu_content = thorpy.Box.make(elements=[ self.acceleration_button, self.acceleration_slider, self.maxSpeed_slider, self.quit_button ]) self.menu_slide_reaction = thorpy.Reaction( reacts_to=thorpy.constants.THORPY_EVENT, reac_func=self.react_slider, event_args={"id": thorpy.constants.EVENT_SLIDE}, reac_name="slider reaction") self.menu_content.add_reaction(self.menu_slide_reaction) self.menu = thorpy.Menu(self.menu_content) for element in self.menu.get_population(): element.surface = self.screen self.menu_content.set_topleft((self.frame_width, 100)) self.menu_content.blit() self.menu_content.update()
def launch_blocking_alert(title, text, parent=None, font_size=None, font_color=None, ok_text="Ok", transp=False, alpha_dialog=200, func=None, outside_click_quit=False): if font_size is None: font_size = thorpy.style.FONT_SIZE if font_color is None: font_color = thorpy.style.FONT_COLOR box_alert = make_textbox(title, text, font_size, font_color, ok_text) box_alert.center() if transp: color_transp = tuple(list(thorpy.style.DEF_COLOR)[:3] + [alpha_dialog]) box_alert.set_main_color(color_transp) def click_quit(e): if not box_alert.get_fus_rect().collidepoint(e.pos): thorpy.functions.quit_menu_func() if outside_click_quit: box_alert.add_reaction( thorpy.Reaction(pygame.MOUSEBUTTONDOWN, click_quit)) from thorpy.menus.tickedmenu import TickedMenu m = TickedMenu(box_alert) box_alert.get_elements_by_text( ok_text)[0].user_func = thorpy.functions.quit_menu_func box_alert.get_elements_by_text(ok_text)[0].user_params = {} m.play() box_alert.unblit() if parent: parent.partial_blit(None, box_alert.get_fus_rect()) box_alert.update() if func: func()
def __init__(self, me, size, cell_size, redraw, external_e): self.me = me self.wline = int(0.75*size[0]) self.unit = None ## self.cell = None probleme self.e_img = thorpy.Image.make(pygame.Surface(cell_size)) ## self.e_img = thorpy.Image.make(pygame.Surface((1,1))) self.blank_img = pygame.Surface(cell_size) self.e_name = guip.get_text("") self.e_race = guip.get_text("") self.e_name_and_race = thorpy.Box([self.e_name, self.e_race]) self.e_name_and_race.fit_children() ghost = thorpy.Ghost([self.e_img, self.e_name_and_race]) ghost.finish() self.e_img.set_center_pos(ghost.get_fus_center()) self.e_name.set_center_pos(self.e_img.get_fus_center()) ghost.fit_children() self.e_group = ghost # self.elements = [self.e_group] self.e = thorpy.Box.make(self.elements) self.e.set_main_color((20,20,20)) self.e.set_size((size[0],None)) for e in self.e.get_elements(): e.recenter() ## #emap : to be displayed when a cell is clicked self.em_title = guip.get_title("Unit informations") ## self.em_coord = guip.get_text("") ## self.em_altitude = guip.get_text("") ## self.em_name = guip.get_small_text("") self.em_rename = guip.get_small_button("Rename", self.rename_current_unit) ## self.em_rename.scale_to_title() ## self.em_name_rename = thorpy.make_group([self.em_name, self.em_rename]) #### self.em_name_rename = thorpy.Clickable.make(elements=[self.em_name, self.em_rename]) #### thorpy.store(self.em_name_rename) ## self.em_name_rename.fit_children() self.em_unit_img_img = thorpy.Image.make(pygame.Surface(cell_size)) self.em_unit_img = thorpy.Clickable.make(elements=[self.em_unit_img_img]) self.em_unit_img.fit_children() self.em_unit_name = guip.get_text("") self.em_unit_race = guip.get_text("") self.em_nameNrace = thorpy.make_group([self.em_unit_name, self.em_unit_race], "v") self.em_unit = thorpy.make_group([self.em_unit_img, self.em_nameNrace]) self.em_elements = [self.em_title, thorpy.Line.make(self.wline), self.em_unit, self.em_rename]#self.em_name_rename] # self.em_mat_img_img = thorpy.Image.make(pygame.Surface(cell_size)) self.em_mat_img = thorpy.Clickable.make(elements=[self.em_mat_img_img]) self.em_mat_img.fit_children() def show_terrain_infos(): cell = self.unit.cell self.me.cell_info.last_cell_clicked = cell pos = self.me.cam.get_rect_at_coord(cell.coord).center self.me.cell_info.launch_em(cell, pos, self.me.cam.map_rect) ## self.em_button_cell = guip.get_button("Terrain infos", show_terrain_infos) self.em_mat_img.user_func = show_terrain_infos self.em_elements += [thorpy.Line.make(self.wline), self.em_mat_img] self.em = thorpy.Box.make(self.em_elements) self.em.set_main_color((200,200,200,150)) self.launched = False self.redraw = redraw self.external_e = external_e reac = thorpy.Reaction(thorpy.THORPY_EVENT, self.set_unlaunched, {"id":thorpy.constants.EVENT_UNLAUNCH}) external_e.add_reaction(reac) self.last_cell_clicked = None self.e_img.visible = False
def __init__(self): self.level_objects = [] self.spawner_objects = [] self.render_queue = RenderQueue() self.dragging_object = None self.dragging_spawner = None self.selected_object = None self.selected_spawner = None self.drag_offset = None self.zoom = 1.0 self.camera_x = 0 self.camera_y = 0 # Game area self.game_area = thorpy.Box.make([], size=(SCREEN_WIDTH, SCREEN_HEIGHT)) self.game_area.set_main_color((220, 255, 220, 0)) # TODO: Add horizontal and vertical scroller to game area # Level details area self.level_details_title = thorpy.make_text('Level Details', 18, (0, 0, 0)) self.level_name_box = thorpy.Inserter.make(name='Name: ', value='new_level') load_level_button = thorpy.make_button('Load level', self.load_level) self.level_width_box = thorpy.Inserter.make(name='Width: ', value='') self.level_height_box = thorpy.Inserter.make(name='Height: ', value='') self.gravity_box = thorpy.Inserter.make(name='Gravity: ', value='') self.jump_height_box = thorpy.Inserter.make(name='Jump height: ', value='') self.player_speed_box = thorpy.Inserter.make(name='Player speed: ', value='') save_level_button = thorpy.make_button('Save level', self.save_level) self.level_details_area = thorpy.Box.make([ self.level_details_title, self.level_name_box, load_level_button, self.level_width_box, self.level_height_box, self.gravity_box, self.jump_height_box, self.player_speed_box, save_level_button ]) self.level_details_area.fit_children() # Pattern details area pattern_details_title = thorpy.make_text('Pattern Details', 18, (0, 0, 0)) self.pattern_id_box = thorpy.Inserter.make(name='ID: ', value='') self.image_file_box = thorpy.Inserter.make(name='Image file: ', value='') self.pattern_width_box = thorpy.Inserter.make(name='Width: ', value='') self.pattern_height_box = thorpy.Inserter.make(name='Height: ', value='') self.block_data_box = thorpy.Inserter.make(name='Block data: ', value='') self.stand_data_box = thorpy.Inserter.make(name='Stand data: ', value='') self.climb_data_box = thorpy.Inserter.make(name='Climb data: ', value='') self.damage_data_box = thorpy.Inserter.make(name='Damage data: ', value='') self.pattern_details_area = thorpy.Box.make([ pattern_details_title, self.pattern_id_box, self.image_file_box, self.pattern_width_box, self.pattern_height_box, self.block_data_box, self.stand_data_box, self.climb_data_box, self.damage_data_box ]) # Object details area object_details_title = thorpy.make_text('Object Details', 18, (0, 0, 0)) self.top_box = thorpy.Inserter.make(name='Top: ', value='') self.left_box = thorpy.Inserter.make(name='Left: ', value='') self.z_box = thorpy.Inserter.make(name='Z index: ', value='') self.object_details_area = thorpy.Box.make( [object_details_title, self.top_box, self.left_box, self.z_box]) def change_z_index(event): self.selected_object.z_index = str_to_int(event.value) z_index_reaction = thorpy.Reaction( reacts_to=thorpy.constants.THORPY_EVENT, reac_func=change_z_index, event_args={ 'id': thorpy.constants.EVENT_INSERT, 'el': self.z_box }) self.z_box.add_reaction(z_index_reaction) self.details_area = thorpy.Box.make([ self.level_details_area, self.pattern_details_area, self.object_details_area ], size=(DETAILS_AREA_WIDTH, SCREEN_HEIGHT)) self.details_area.set_main_color((255, 220, 255, 180)) self.details_area.set_topleft((SCREEN_WIDTH, 0)) self.debug_draw = False # Patterns area patterns_title = thorpy.make_text('Patterns', 18, (0, 0, 0)) def click_pattern(pattern_id, surfdata): position = self.backwardMouseTransform( (SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2)) level_object = LevelObject( objectDefinition={ 'type': pattern_id, 'x': math.floor(position[0] / BLOCK_SIZE), 'y': math.floor(position[1] / BLOCK_SIZE), 'z': 0, }) # TODO: Do we need to pass in surf data here? self.level_objects.append(level_object) # Load the already-created patterns patterns = [] pattern_objects = [] LevelObjectPattern.init() with open('patterns.json', 'r') as patterns_file: patterns_descriptions = json.load(patterns_file) patterns_temp = list(patterns_descriptions.items()) patterns_temp.sort(key=lambda x: x[0]) for pattern_id, pattern_definition in patterns_temp: pattern = LevelObjectPattern(pattern_definition, pattern_id) patterns.append(pattern) # TODO: Add a small version of the image to this object pattern_object = thorpy.make_button( pattern_id, func=click_pattern, params={ 'pattern_id': pattern_id, 'surfdata': pattern_definition['surfdata'] }) pattern_objects.append(pattern_object) self.patterns_area = thorpy.Box.make( [patterns_title, *pattern_objects], size=(PATTERNS_AREA_WIDTH, SCREEN_HEIGHT)) self.patterns_area.set_main_color((220, 220, 255, 180)) self.patterns_area.set_topleft((SCREEN_WIDTH + DETAILS_AREA_WIDTH, 0)) thorpy.store(self.patterns_area, y=0) self.patterns_area.refresh_lift() # Spawners area def click_add_spawner(): position = self.backwardMouseTransform( (SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2)) spawner_object = Spawner(x=math.floor(position[0] / BLOCK_SIZE), y=math.floor(position[1] / BLOCK_SIZE), entity_type='', spawner_type='', rate=0.3, filter='') self.spawner_objects.append(spawner_object) spawners_title = thorpy.make_text('Spawners', 18, (0, 0, 0)) add_spawner_button = thorpy.make_button('Add spawner', func=click_add_spawner, params={}) # Spawner details area spawner_details_title = thorpy.make_text('Spawner Details', 18, (0, 0, 0)) self.spawner_x_box = thorpy.Inserter.make(name='X: ', value='') self.spawner_y_box = thorpy.Inserter.make(name='Y: ', value='') self.spawner_entity_type_box = thorpy.Inserter.make( name='Entity type: ', value='') self.spawner_filter_box = thorpy.Inserter.make(name='Filter: ', value='') self.spawner_spawner_type_box = thorpy.Inserter.make( name='Spawner type: ', value='') self.spawner_rate_box = thorpy.Inserter.make(name='Rate: ', value='') def change_spawner_entity_type(event): self.selected_spawner.entity_type = event.value def change_spawner_filter(event): self.selected_spawner.filter = event.value def change_spawner_spawner_type(event): self.selected_spawner.spawner_type = event.value def change_spawner_rate(event): self.selected_spawner.rate = str_to_float(event.value) entity_type_reaction = thorpy.Reaction( reacts_to=thorpy.constants.THORPY_EVENT, reac_func=change_spawner_entity_type, event_args={ 'id': thorpy.constants.EVENT_INSERT, 'el': self.spawner_entity_type_box }) filter_reaction = thorpy.Reaction( reacts_to=thorpy.constants.THORPY_EVENT, reac_func=change_spawner_filter, event_args={ 'id': thorpy.constants.EVENT_INSERT, 'el': self.spawner_filter_box }) spawner_type_reaction = thorpy.Reaction( reacts_to=thorpy.constants.THORPY_EVENT, reac_func=change_spawner_spawner_type, event_args={ 'id': thorpy.constants.EVENT_INSERT, 'el': self.spawner_spawner_type_box }) rate_reaction = thorpy.Reaction( reacts_to=thorpy.constants.THORPY_EVENT, reac_func=change_spawner_rate, event_args={ 'id': thorpy.constants.EVENT_INSERT, 'el': self.spawner_rate_box }) self.spawner_entity_type_box.add_reaction(entity_type_reaction) self.spawner_filter_box.add_reaction(filter_reaction) self.spawner_spawner_type_box.add_reaction(spawner_type_reaction) self.spawner_rate_box.add_reaction(rate_reaction) spawner_details_area = thorpy.Box.make([ spawner_details_title, self.spawner_x_box, self.spawner_y_box, self.spawner_spawner_type_box, self.spawner_entity_type_box, self.spawner_filter_box, self.spawner_rate_box, ]) self.spawners_area = thorpy.Box.make( [spawners_title, add_spawner_button, spawner_details_area], size=(SPAWNERS_AREA_WIDTH, SCREEN_HEIGHT)) self.spawners_area.set_main_color((255, 255, 220, 180)) self.spawners_area.set_topleft( (SCREEN_WIDTH + DETAILS_AREA_WIDTH + PATTERNS_AREA_WIDTH, 0)) thorpy.store(self.spawners_area, gap=30) self.menu = thorpy.Menu([ self.game_area, self.patterns_area, self.details_area, self.spawners_area ])
def build_gui_elements(self): #worst function ever e_hmap = thorpy.Image.make(self.cam.img_hmap) e_hmap.stick_to("screen", "right", "right", False) e_hmap.add_reaction(thorpy.Reaction(pygame.MOUSEMOTION, self.func_reac_mousemotion)) e_hmap.add_reaction(thorpy.Reaction(pygame.MOUSEBUTTONDOWN, self.func_reac_click)) e_hmap.add_reaction(thorpy.Reaction(pygame.MOUSEBUTTONUP, self.func_reac_unclick)) self.e_hmap = e_hmap box_hmap = thorpy.Box.make([e_hmap]) box_hmap.fit_children((self.box_hmap_margin,)*2) thorpy.makeup.add_basic_help(box_hmap, "Click to move camera on miniature map") ## e_title_hmap = guip.get_text("Map") ## self.topbox = thorpy.make_group([e_title_hmap, box_hmap], "v") self.topbox = box_hmap self.box_hmap = box_hmap ######################################################################## self.cam.set_gui_elements(e_hmap, box_hmap) ######################################################################## if len(self.zoom_cell_sizes) > 1: self.e_zoom = thorpy.SliderX.make(self.menu_width//4, (0, 100), "Zoom (%)", int, initial_value=100) def func_reac_zoom(e): levels = len(self.zoom_cell_sizes) - 1 level = int(levels*self.e_zoom.get_value()/self.e_zoom.limvals[1]) self.set_zoom(levels-level,False) ######################################################################## self.cell_info = gui.CellInfo(self, self.menu_rect.inflate((-10,0)).size, self.cell_rect.size, self.draw_no_update, e_hmap) self.unit_info = gui.UnitInfo(self,self.menu_rect.inflate((-10,0)).size, self.cell_rect.size, self.draw_no_update, e_hmap) ## self.misc_info = gui.MiscInfo(self.menu_rect.inflate((-10,0)).size) self.menu_button = thorpy.make_menu_button(force_convert_alpha=True) ######################################################################## elements =[ self.topbox, self.cell_info.e, self.unit_info.e, self.menu_button] if len(self.zoom_cell_sizes) > 1: elements.insert(0, self.e_zoom) self.e_box = thorpy.Element.make(elements=elements, size=self.menu_rect.size) self.e_box.set_main_color((200,200,200,160)) thorpy.store(self.e_box) self.e_box.stick_to("screen","right","right") ######################################################################## if len(self.zoom_cell_sizes) > 1: reac_zoom = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT, reac_func=func_reac_zoom, event_args={"id":thorpy.constants.EVENT_SLIDE, "el":self.e_zoom}, reac_name="zoom slide") self.e_box.add_reaction(reac_zoom) ######################################################################## thorpy.add_keydown_reaction(self.e_box, pygame.K_KP_PLUS, self.increment_zoom, params={"value":-1}, reac_name="k plus") thorpy.add_keydown_reaction(self.e_box, pygame.K_KP_MINUS, self.increment_zoom, params={"value":1}, reac_name="k minus") wheel_reac1 = thorpy.ConstantReaction(pygame.MOUSEBUTTONDOWN, self.increment_zoom, {"button":4}, {"value":1}) wheel_reac2 = thorpy.ConstantReaction(pygame.MOUSEBUTTONDOWN, self.increment_zoom, {"button":5}, {"value":-1}) self.e_box.add_reactions([wheel_reac1, wheel_reac2]) ######################################################################## velocity = 0.2 thorpy.add_keydown_reaction(self.e_box, pygame.K_LEFT, self.move_cam_and_refresh, params={"delta":(-velocity,0)}, reac_name="k left") thorpy.add_keydown_reaction(self.e_box, pygame.K_RIGHT, self.move_cam_and_refresh, params={"delta":(velocity,0)}, reac_name="k right") thorpy.add_keydown_reaction(self.e_box, pygame.K_UP, self.move_cam_and_refresh, params={"delta":(0,-velocity)}, reac_name="k up") thorpy.add_keydown_reaction(self.e_box, pygame.K_DOWN, self.move_cam_and_refresh, params={"delta":(0,velocity)}, reac_name="k down") ######################################################################## self.help_box = gui.HelpBox([ ("Move camera", [("To move the map, drag it with", "<LMB>", "or hold", "<LEFT SHIFT>", "while moving mouse."), ("The minimap on the upper right can be clicked or hold with", "<LMB>", "in order to move the camera."), ("The","<KEYBOARD ARROWS>", "can also be used to scroll the map view.")]), ("Zoom", [("Use the","zoom slider","or","<NUMPAD +/- >", "to change zoom level."), ("You can also alternate zoom levels by pressing","<RMB>",".")]), ("Miscellaneous", [("Press","<g>","to toggle grid lines display.")]) ]) thorpy.add_keydown_reaction(self.e_box, pygame.K_g, self.toggle_show_grid_lines, reac_name="toggle grid")
Camtype=parameters.get_camera_type() cam = Camtype(chunk=(0,0), pos=(0,0), seed=SEED, world_size=parameters.WORLD_SIZE) core.load_images() core.compute_parameters() wind = Wind((-1.,-1.),(1.,1.),(-1., -1.),(1.,1.),(10000,10000)) game = core.Game(cam, wind, climate, e_bckgr) game.set_ship(Ship(mass=0.3, maxvel=3., life=1., captain=None)) game.refresh_controllables() reac_time = thorpy.ConstantReaction(thorpy.constants.THORPY_EVENT, game.reac_time, {"id":thorpy.constants.EVENT_TIME}) reac_keydown = thorpy.Reaction(pygame.KEYDOWN, game.reac_keydown) e_bckgr.add_reaction(reac_keydown) e_bckgr.add_reaction(reac_time) gu = gui.GUI(game) if not savefile: #configure new game varset = gui.game_parameters_menu() # #difficulty : TREASURE_PROB, MAX_FLAG, FOOD_PER_TURN, MAX_CAMPS, OASIS_PROB difficulties = {"easy":(1., 10, 1, 5, 1.), "medium":(0.8, 5, 1, 3, 0.8), "hard":(0.4, 3, 1, 1, 0.7)} seed = varset.get_value("seed") ## seed = 42877
def __init__(self): ## if not parameters.canonic_vessels: ## get_all_parts() self.vessel = parameters.player.vessel.get_copy() self.ovessel = parameters.player.vessel self.screen = thorpy.get_screen() # light_pos = V3(0,1000,-1000) light_m = V3(20,20,20) light_M = V3(200,200,200) self.light = light.Light(light_pos, light_m, light_M) # self.e_bckgr = thorpy.Background.make((255,255,255)) self.vessel.set_pos(parameters.GARAGE_POS) reaction = thorpy.ConstantReaction(thorpy.THORPY_EVENT, self.refresh_display, {"id":thorpy.constants.EVENT_TIME}) self.e_bckgr.add_reaction(reaction) reaction = thorpy.Reaction(pygame.MOUSEMOTION, self.mousemotion) self.e_bckgr.add_reaction(reaction) # self.viewport = pygame.Surface((400,400)) self.viewport_color = (200,200,200) self.viewport_rect = pygame.Rect((0,0),self.viewport.get_size()) self.viewport_rect.right = parameters.W - 20 self.viewport_rect.centery = parameters.H//2 self.cam = camera.Camera(self.viewport, fov=512, d=2, objs=[]) # # # self.e_ok = thorpy.make_button("Go to next race", func=thorpy.functions.quit_menu_func) self.e_ok.set_main_color((0,255,0)) self.e_ok.set_font_size(thorpy.style.FONT_SIZE+3) self.e_ok.scale_to_title() # # def refresh_repair(): damages = str(round(100.*(1. - self.ovessel.life/self.ovessel.max_life))) self.e_damage.set_text("Vessel damages: " + damages + "%") self.e_money.set_text("Money: "+str(parameters.player.money)+" $") def choice_repair(): cost = (self.ovessel.max_life - self.ovessel.life)*300 if cost <= parameters.player.money: if thorpy.launch_binary_choice("Are you sure? This will cost "+\ str(cost)+"$"): self.ovessel.life = self.ovessel.max_life parameters.player.money -= cost refresh_repair() elif thorpy.launch_binary_choice("Repairing costs "+str(cost)+\ " $. You don't have enough money.\n"+\ "Do you want to use all your money for"+\ " repairing as much as possible?"): #(after_repair - self.ovessel.life)*300 = money #==> after_repair = money/300 + self.ovessel.life repaired = int(parameters.player.money/300. + self.ovessel.life) parameters.player.money -= (repaired - self.ovessel.life)*300 self.ovessel.life = repaired refresh_repair() self.e_bckgr.blit() self.refresh_display() pygame.display.flip() self.e_repair = thorpy.make_button("Repair vessel",choice_repair) # damages = str(round(100.*(1. - self.ovessel.life/self.ovessel.max_life))) self.e_damage = thorpy.make_text("Vessel damages: " + damages + "%") self.e_ranking = thorpy.make_button("See rankings", launch_rankings, {"garage":self}) ## self.e_ranking = get_rankings_box() def quit_forever(): if thorpy.launch_binary_choice("Are you sure ?"): thorpy.functions.quit_func() else: self.e_bckgr.unblit_and_reblit() self.e_menu = thorpy.make_button("Stop career and die (forever)", func=quit_forever) self.e_menu.set_main_color((255,0,0)) self.e_menu.set_font_size(thorpy.style.FONT_SIZE-2) self.e_menu.scale_to_title() # vw,vh = self.viewport_rect.size self.e_viewport_frame = thorpy.Element() painter = thorpy.painterstyle.ClassicFrame((vw+3,vh+3), color=self.viewport_color, pressed=True) self.e_viewport_frame.set_painter(painter) self.e_viewport_frame.finish() self.e_viewport_frame.set_center(self.viewport_rect.center) # import hud fuel = str(round(100*self.ovessel.engine.fuel/self.ovessel.engine.max_fuel)) self.e_fuel = hud.LifeBar("Fuel: "+fuel+" %",text_color=(255,0,0),size=(100,30)) self.e_fuel.set_life(self.ovessel.engine.fuel/self.ovessel.engine.max_fuel) def refresh_refuel(): life = self.ovessel.engine.fuel / self.ovessel.engine.max_fuel self.e_fuel.set_life(life) self.e_fuel.set_text("Fuel: "+str(round(life*100))+" %") self.e_money.set_text("Money: "+str(parameters.player.money)+" $") def choice_refuel(): cost = (self.ovessel.engine.max_fuel - self.ovessel.engine.fuel)//2 if cost <= parameters.player.money: if thorpy.launch_binary_choice("Are you sure? This will cost "+\ str(cost)+"$"): self.ovessel.engine.fuel = self.ovessel.engine.max_fuel parameters.player.money -= cost refresh_refuel() ## self.e_fuel.set_life(1.) ## self.e_fuel.set_life_text("Fuel: 100 %") ## parameters.player.money -= cost ## self.e_money.set_text("Money: "+str(parameters.player.money)+" $") ## self.ovessel.engine.fuel = self.ovessel.engine.max_fuel elif thorpy.launch_binary_choice("Refueling costs "+str(cost)+" $. You don't have enough money.\n"+\ "Do you want to spend all your money to refuel as much as possible?"): #cost = (newfuel - fuel)//2 ==> 2*cost + fuel = newfuel self.ovessel.engine.fuel += 2*parameters.player.money parameters.player.money = 0 refresh_refuel() ## thorpy.launch_blocking_alert("Refueling costs "+str(cost)+" $. You don't have enough money.") self.e_bckgr.blit() self.refresh_display() pygame.display.flip() self.e_refuel = thorpy.make_button("Refuel",choice_refuel) self.e_money = thorpy.make_text("Money: "+str(parameters.player.money)+" $", thorpy.style.TITLE_FONT_SIZE,(255,0,0)) self.e_money.stick_to("screen","top","top") self.e_money.move((0,30)) # self.e_box = thorpy.Box.make([self.e_damage,self.e_repair, thorpy.Line.make(100,"h"),self.e_fuel, self.e_refuel, thorpy.Line.make(100,"h"), self.e_ranking,self.e_ok]) self.e_bckgr.add_elements([self.e_box,self.e_menu]) thorpy.store(self.e_bckgr, x = 200) self.e_skills = get_vessel_element(parameters.player.vessel) self.e_bckgr.add_elements([self.e_viewport_frame,self.e_money, self.e_skills]) self.e_menu.move((0,30)) self.e_skills.stick_to(self.e_viewport_frame, "left", "right") self.i = 0
#Quit button quit = thorpy.make_button("QUIT", func=thorpy.functions.quit_menu_func) quit.set_font_size(40) quit.set_font("Bahnschrift SemiBold") quit.set_main_color((0,148,0)) quit.set_font_color((255,255,255)) quit.set_size((200,100)) quit.center() def start_game(event): b = boardGUI.GUI() b.board() game_reaction = thorpy.Reaction(reacts_to=pygame.MOUSEBUTTONDOWN, reac_func=start_game) start.add_reaction(game_reaction) #Setting background and adding elements to background background = thorpy.Background(color=(0, 102, 204), elements=[pic_button, title, start, quit]) thorpy.store(background) #Adding background to menu and launching menu. menu = thorpy.Menu(background) menu.play()
def create_menu(self): self.lane1_button = thorpy.make_button("Lane 1 Color Choice", func=self.lane1_update) self.lane2_button = thorpy.make_button("Lane 2 Color Choice", func=self.lane2_update) self.object_button = thorpy.make_button("Object Color Choice", func=self.object_update) self.finish_button = thorpy.make_button("Finish Line Color Choice", func=self.finish_update) self.disable_obstacle_button = thorpy.make_button( ("Disable Obstacle Detection"), func=self.obstacle_update) self.stop_button = thorpy.make_button("STOP!!", func=self.stop_update) self.quit_button = thorpy.make_button("Quit", func=thorpy.functions.quit_func) self.Upper_Hue_Inserter = thorpy.Inserter.make(name="Upper Hue:", value="0") self.Upper_Saturation_Inserter = thorpy.Inserter.make( name="Upper Sat:", value="0") self.Upper_Value_Inserter = thorpy.Inserter.make(name="Upper Value: ", value="0") self.Lower_Hue_Inserter = thorpy.Inserter.make(name="Lower Hue: ", value="0") self.Lower_Saturation_Inserter = thorpy.Inserter.make( name="Lower Sat:", value="0") self.Lower_Value_Inserter = thorpy.Inserter.make(name="Lower Value: ", value="0") self.Upper_Canny_Inserter = thorpy.Inserter.make(name="Upper Canny:", value="0") self.Lower_Canny_Inserter = thorpy.Inserter.make(name="Lower Canny: ", value="0") self.Upper_Hue_Slider = thorpy.SliderX.make(length=100, limvals=(0, self.slide_limit), text="Upper Hue:", type_=int) self.Upper_Saturation_Slider = thorpy.SliderX.make( length=100, limvals=(0, self.slide_limit), text="Upper Sat:", type_=int) self.Upper_Value_Slider = thorpy.SliderX.make( length=100, limvals=(0, self.slide_limit), text="Upper Value:", type_=int) self.Lower_Hue_Slider = thorpy.SliderX.make(length=100, limvals=(0, self.slide_limit), text="Lower Hue:", type_=int) self.Lower_Saturation_Slider = thorpy.SliderX.make( length=100, limvals=(0, self.slide_limit), text="Lower Sat:", type_=int) self.Lower_Value_Slider = thorpy.SliderX.make( length=100, limvals=(0, self.slide_limit), text="Lower Value:", type_=int) self.menu_content = thorpy.Box.make(elements=[ self.lane1_button, self.lane2_button, self.object_button, self.finish_button, self.disable_obstacle_button, self.stop_button, self.Upper_Hue_Slider, self.Upper_Saturation_Slider, self.Upper_Value_Slider, self.Lower_Hue_Slider, self.Lower_Saturation_Slider, self.Lower_Value_Slider, self.Upper_Hue_Inserter, self.Upper_Saturation_Inserter, self.Upper_Value_Inserter, self.Lower_Hue_Inserter, self.Lower_Saturation_Inserter, self.Lower_Value_Inserter, self. Upper_Canny_Inserter, self.Lower_Canny_Inserter, self.quit_button ]) self.menu_slide_reaction = thorpy.Reaction( reacts_to=thorpy.constants.THORPY_EVENT, reac_func=self.react_slider, event_args={"id": thorpy.constants.EVENT_SLIDE}, reac_name="slider reaction") self.menu_content.add_reaction(self.menu_slide_reaction) self.menu_inserter_reaction = thorpy.Reaction( reacts_to=thorpy.constants.THORPY_EVENT, reac_func=self.react_inserter, event_args={"id": thorpy.constants.EVENT_INSERT}, reac_name="inserter reaction") self.menu_content.add_reaction(self.menu_inserter_reaction) self.menu = thorpy.Menu(self.menu_content) for element in self.menu.get_population(): element.surface = self.screen self.lane1_update() self.menu_content.set_topleft((self.frame_width, 100)) self.menu_content.blit() self.menu_content.update()
def manage_stocks(stock1, stock2): c = stock1.food + stock2.food #remains constant class Os1: v = stock1.food class Os2: v = stock2.food title = thorpy.make_text("Food stock management", font_size=thorpy.style.FONT_SIZE + 3, font_color=TCOLOR) line = thorpy.Line.make(300, "h") def take_all(): stock1.refood_from(stock2) thorpy.functions.quit_menu_func() ## print(stock1,stock2) e_take = thorpy.make_button("Take all", func=take_all) s1 = thorpy.SliderX.make(length=350, limvals=(0, stock1.max_food), text=stock1.name, type_=int, initial_value=int(stock1.food)) s2 = thorpy.SliderX.make(length=350, limvals=(0, stock2.max_food), text=stock2.name, type_=int, initial_value=int(stock2.food)) e1 = thorpy.Box.make(elements=[s1]) e2 = thorpy.Box.make(elements=[s2]) arrow = thorpy.Image.make("doublearrow32.bmp", colorkey=(255, 255, 255)) # box = thorpy.make_ok_cancel_box([title, line, e_take, e1, arrow, e2]) box.set_main_color((200, 200, 255, 150)) box.center() # def refresh_sliders(e): ns1 = s1.get_value() ns2 = s2.get_value() if ns1 + ns2 > c: s1.unblit_and_reblit_func(s1.set_value, value=Os1.v) s2.unblit_and_reblit_func(s2.set_value, value=Os2.v) return if e.el is s1: new_value = c - ns1 if new_value > s2.limvals[1]: new_value = s2.limvals[1] elif new_value < s2.limvals[0]: new_value = s2.limvals[0] s2.unblit_and_reblit_func(s2.set_value, value=new_value) elif e.el is s2: new_value = c - ns2 if new_value > s1.limvals[1]: new_value = s1.limvals[1] elif new_value < s1.limvals[0]: new_value = s1.limvals[0] s1.unblit_and_reblit_func(s1.set_value, value=new_value) Os1.v, Os2.v = s1.get_value(), s2.get_value() reaction = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT, reac_func=refresh_sliders, event_args={"id": thorpy.constants.EVENT_SLIDE}) box.add_reaction(reaction) def func_ok(): stock1.food = s1.get_value() stock2.food = s2.get_value() thorpy.functions.quit_menu_func() box.e_cancel.user_func = thorpy.functions.quit_menu_func box.e_cancel.user_params = {} box.e_ok.user_func = func_ok box.e_ok.user_params = {} menu = thorpy.Menu(box) menu.play()
botao_iniciar_cr = thorpy.make_button("Iniciar", func=iniciar_cr) botao_iniciar_cr.set_font('Helvetica') botao_iniciar_cr.set_font_size(18) botao_iniciar_cr.set_size((100, 50)) botao_iniciar_cr.set_main_color((100, 255, 100)) botao_parar_cr = thorpy.make_button("Parar", func=parar_cr) botao_parar_cr.set_font('Helvetica') botao_parar_cr.set_font_size(18) botao_parar_cr.set_size((100, 50)) botao_parar_cr.set_main_color((255, 100, 100)) pasta_cr = thorpy.Inserter(name="Nome da pasta de destino:") #Reacoes Controle Remoto reacao_pasta_cr = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT, reac_func=pasta_destino_cr, event_args={ "id": thorpy.constants.EVENT_INSERT, "el": pasta_cr }) #Launcher do modo controle remoto caixa_cr = thorpy.make_ok_box([ titulo_cr, inv4, texto_cr, inv5, botao_iniciar_cr, inv6, botao_parar_cr, inv7, pasta_cr, inv8 ]) caixa_cr.set_main_color((200, 220, 230)) caixa_cr.fit_children(margins=(20, 20)) caixa_cr.add_reaction(reacao_pasta_cr) botao_cr = thorpy.make_button("Controle Remoto") botao_cr.set_font_size(17) botao_cr.set_font_color((40, 40, 40)) botao_cr.set_size((200, 50))
def __init__(self, title, ok_text, ranking, results=False, choosevessel=False): refresh_ranking() # light_pos = V3(0, 1000, -1000) light_m = V3(20, 20, 20) light_M = V3(200, 200, 200) self.light = light.Light(light_pos, light_m, light_M) self.viewport = pygame.Surface((400, int(parameters.H * 0.6))) self.viewport_color = (200, 200, 200) self.viewport.fill(self.viewport_color) self.viewport_rect = pygame.Rect((0, 0), self.viewport.get_size()) self.viewport_rect.centerx = parameters.W // 2 + 100 self.viewport_rect.centery = parameters.H // 2 self.cam = camera.Camera(self.viewport, fov=512, d=2, objs=[]) self.screen = thorpy.get_screen() self.displayed_vessel = None self.i = 0 # if results: ranking[0].points += 1 ranking[0].money += 300 + (parameters.NPLAYERS - ranking[0].ranking) * 100 ranking[2].points -= 1 ranking[2].money += 100 ranking[1].money += 200 if ranking[2].points < 0: ranking[2].points = 0 # self.trophy = None if choosevessel: self.e_players = [] def other_vessel(): self.vessels[0] = create_vessel(parameters.HERO_COLOR) self.vessels[0].set_pos(V3(0, -1 * 4.5, 20)) self.vessels[0].move(V3(0, 4, 0)) self.displayed_vessel = self.vessels[0] #replace self.ve new_ve = get_vessel_element(self.vessels[0]) self.e_bckgr.replace_element(self.ve, new_ve) thorpy.functions.refresh_current_menu() self.ve = new_ve self.e_bckgr.unblit_and_reblit() b = thorpy.make_button("Generate another vessel", other_vessel) c = thorpy.make_button("Done", thorpy.functions.quit_menu_func) self.e_players.append(b) self.e_players.append(c) from main import create_vessel self.vessels = [create_vessel(parameters.HERO_COLOR)] self.displayed_vessel = self.vessels[0].get_copy() self.ve = get_vessel_element(self.vessels[0]) self.e_players.append(self.ve) else: if results: self.e_players = [ p.get_element(str(i + 1) + ") ") for i, p in enumerate(ranking) ] else: self.e_players = [ p.get_element() for i, p in enumerate(ranking) ] self.vessels = [p.vessel.get_copy() for p in ranking] if results: import core3d from light import Material self.trophy = core3d.Object3D("trophy1.stl") self.trophy.set_color(Material((255, 215, 0))) ## self.trophy.set_color((255,255,0)) self.trophy.set_pos(V3(5., -0 * 4.5 - 0.2, 15)) self.trophy.rotate_around_center_z(90.) self.trophy.rotate_around_center_x(-65.) self.trophy.move(V3(0, 4, 0)) self.background = thorpy.load_image("background1.jpg") self.background = thorpy.get_resized_image( self.background, (parameters.W, parameters.H // 2), type_=max) self.e_bckgr = thorpy.Background.make(image=self.background, elements=self.e_players) # vw, vh = self.viewport_rect.size self.e_viewport_frame = thorpy.Element() painter = thorpy.painterstyle.ClassicFrame((vw + 3, vh + 3), color=self.viewport_color, pressed=True) self.e_viewport_frame.set_painter(painter) self.e_viewport_frame.finish() self.e_viewport_frame.set_center(self.viewport_rect.center) # reaction = thorpy.ConstantReaction(thorpy.THORPY_EVENT, self.refresh_display, {"id": thorpy.constants.EVENT_TIME}) self.e_bckgr.add_reaction(reaction) if not choosevessel: for i, v in enumerate(self.vessels): pos = self.e_players[i].get_fus_rect().center v.set_pos(V3(0, -i * 4.5, 20)) v.move(V3(0, 4, 0)) else: self.vessels[0].set_pos(V3(0, -1 * 4.5, 20)) self.vessels[0].move(V3(0, 4, 0)) # self.displayed_vessel.set_pos(V3(0, -1 * 4.5, 20)) self.displayed_vessel.move(V3(0, 4, 0)) # thorpy.store(self.e_bckgr, gap=40) for e in self.e_players: e.stick_to(self.viewport_rect, "left", "right", align=False) e.move((-5, 0)) self.e_title = get_etitle(title) if not choosevessel: self.e_ok = get_eok(ok_text) self.e_bckgr.add_elements( [self.e_viewport_frame, self.e_title, self.e_ok]) else: self.e_bckgr.add_elements([self.e_viewport_frame, self.e_title]) self.goback = False def return_garage(): self.derotate() self.goback = True thorpy.functions.quit_menu_func() if not results and not choosevessel: self.e_back = thorpy.make_button("Return to garage", return_garage) self.e_back.stick_to(self.e_ok, "left", "right") self.e_back.move((-20, 0)) self.e_bckgr.add_elements([self.e_back]) if not results: reaction = thorpy.Reaction(pygame.MOUSEMOTION, self.mousemotion) self.e_bckgr.add_reaction(reaction) m = thorpy.Menu(self.e_bckgr) m.play()
def apploop(DISPLAY): global display_height, display_width #main app loo pygame.display.set_caption('Planetbox') pygame.display.set_icon(ico) display_width, display_height = DISPLAY.get_size() DISPLAY.fill(RICHBLUE) #display background Bg = Background('../imgs/bg.jpg', [0, 0]) DISPLAY.blit( pygame.transform.scale(Bg.image, (display_width, display_height)), Bg.rect) #display sky preview Skyprev = SkyPrev(DISPLAY) #update pygame.display.update() #thorpy elements #logo logo = pygame.image.load('../imgs/logo300.png') def radius_check(radius, type): if (type == "terrestrial"): if (radius < 300): return 0 else: return 1 elif (type == "ice" or type == "gas"): if (radius < 200): return 0 else: return 1 # checks if the density is ok def density_check(ptype, pmass, prad): # pmass: 10^22 kg, prad: km rad = prad * 100000 # radius in cm vol = (4 / 3) * math.pi * rad * rad * rad # cm3 mass = pmass * pow(10, 25) # g g = mass / vol # g/cm3 if ptype == "terrestrial": if (g < 3.6): # not sure about this one return 0 elif (g > 28): return 1 else: return 2 elif ptype == "gas" or ptype == "ice": if (g < 0.2): # not sure about this one return 0 elif (g > 17): return 1 else: return 2 #Reading inputs functions def read_inserter_func( event): #Reactions functions must take an event as first arg global prad, pmass, pname, pdist try: if (event.el == p_rad): prad = event.el.get_value() prad = int(prad) elif (event.el == p_dist): pdist = event.el.get_value() pdist = float(pdist) elif (event.el == p_mass): pmass = event.el.get_value() pmass = int(pmass) elif (event.el == p_name): pname = event.el.get_value() elif (event.el == p_kind): ptype = event.el.get_value() except: # handling errors AlertBox.AlertBox(1, "valueError") p_rad.set_value("") p_dist.set_value("") p_mass.set_value("") p_rad.unblit_and_reblit() p_dist.unblit_and_reblit() p_mass.unblit_and_reblit() def reset_simulation(): simulation.Planets = [] simulation.PlanetsCord = [] SkyPrev(DISPLAY) # pressing add planet btn reaction def readPlanet(): global prad, pmass, pname, ptype, simulation, pdist ptype = p_kind.get_selected().get_text() den_val = density_check(ptype, pmass, prad) rad_val = radius_check(prad, ptype) if den_val == 0 or den_val == 1: # wrong density AlertBox.AlertBox(den_val, "density") elif rad_val == 0: # radius too small AlertBox.AlertBox(rad_val, "radius") else: #print(ptype) # create a new planet # clean the inserters p_rad.set_value("") p_rad.unblit_and_reblit() p_dist.set_value("") p_dist.unblit_and_reblit() p_mass.set_value("") p_mass.unblit_and_reblit() p_name.set_value("") p_name.unblit_and_reblit() planet = Planet.Planet(prad, pmass, ptype, pdist, pname) simulation.AddPlanet(planet) # update preview SkyPrev(DISPLAY) def startExplorer(): #print("Starting explorer...") planetExp.pe_main() def startSimulation(): #simulation.CreateMoons() #print("Starting simulation...") print(simulation.PrintPlanets()) simulation_gui.create(simulation) # add button: adds planet to a list and updates prev addBtn = thorpy.make_button("Add planet", func=readPlanet) addBtn.set_size((120, 20)) addBtn.set_main_color(RICHBLUE) addBtn.set_font_color(WHITE) # new window: starts simulation startBtn = thorpy.make_button("Start simulation", func=startSimulation) startBtn.set_size((120, 20)) startBtn.set_main_color(RICHBLUE) startBtn.set_font_color(WHITE) # explore planets: lets u choose a planet and prints info about it and moons simulation prevBtn = thorpy.make_button("Explore the planets", func=startExplorer) prevBtn.set_size((120, 20)) prevBtn.set_main_color(RICHBLUE) prevBtn.set_font_color(WHITE) # reset simulation resBtn = thorpy.make_button("Reset simulation", func=reset_simulation) resBtn.set_size((120, 20)) resBtn.set_main_color(RICHBLUE) resBtn.set_font_color(WHITE) # radius input p_rad_txt = thorpy.OneLineText(text="Radius of the planet(km):") p_rad = thorpy.Inserter(name="", value="", size=(100, 20)) radReact = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT, reac_func=read_inserter_func, event_args={ "id": thorpy.constants.EVENT_INSERT, "el": p_rad }) p_rad.add_reaction(radReact) # distance to the sun input p_dist_txt = thorpy.OneLineText(text="Distance to the sun (AU):") p_dist = thorpy.Inserter(name="", value="", size=(100, 20)) distReact = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT, reac_func=read_inserter_func, event_args={ "id": thorpy.constants.EVENT_INSERT, "el": p_dist }) p_dist.add_reaction(distReact) # name input p_name_txt = thorpy.OneLineText(text="Name of the planet: ") p_name = thorpy.Inserter(name="", value="", size=(100, 20)) nameReact = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT, reac_func=read_inserter_func, event_args={ "id": thorpy.constants.EVENT_INSERT, "el": p_name }) p_name.add_reaction(nameReact) # mass input p_mass_txt = thorpy.OneLineText(text="Mass of the planet (10^22 kg):") p_mass = thorpy.Inserter(name="", value="", size=(100, 20)) massReact = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT, reac_func=read_inserter_func, event_args={ "id": thorpy.constants.EVENT_INSERT, "el": p_mass }) p_mass.add_reaction(massReact) # type of planet input radio_txt = thorpy.make_text("Type of the planet: ") radios = [ thorpy.Checker("gas", type_="radio"), thorpy.Checker("ice", type_="radio"), thorpy.Checker("terrestrial", type_="radio") ] p_kind = thorpy.RadioPool(radios, first_value=radios[1], always_value=True) # title above the preview prev_txt = thorpy.make_text("Preview of the planetary system: ", 24, WHITE) prev_txt.set_font("Ubuntu.ttf") prev_txt.set_topleft((420, 200)) # blit thingies entries = [ p_rad_txt, p_rad, p_mass_txt, p_mass, p_dist_txt, p_dist, p_name_txt, p_name ] txts = [radio_txt] buttons = [addBtn, prevBtn, startBtn, resBtn] elements = entries + txts + radios + buttons boxBtn = thorpy.Box.make(elements=elements) boxBtn.set_main_color(WHITE) boxBtn.set_size((260, 500)) thorpy.store(boxBtn, elements, align="center") menu = thorpy.Menu(elements=[prev_txt, boxBtn]) for element in menu.get_population(): element.surface = DISPLAY boxBtn.set_topleft((40, 50)) boxBtn.blit() boxBtn.update() prev_txt.blit() prev_txt.update() DISPLAY.blit(logo, (390, 20)) pygame.display.flip() while True: for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() quit() if event.type == pygame.VIDEORESIZE: DISPLAY = pygame.display.set_mode( event.dict['size'], pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.RESIZABLE) DISPLAY.blit( pygame.transform.scale(Bg.image, event.dict['size']), (0, 0)) display_width, display_height = event.dict['size'] apploop(DISPLAY) pygame.display.flip() menu.react(event)
p.append((int(x),int(y))) if USE_LIGHT: color = light.get_color(t) else: color = t.color ## print(color) ## color = t.color ## print(p) gfx.filled_trigon(screen, p[0][0], p[0][1], p[1][0], p[1][1], p[2][0], p[2][1], color) gfx.aatrigon(screen, p[0][0], p[0][1], p[1][0], p[1][1], p[2][0], p[2][1], color) i+=1 pygame.display.flip() ##thorpy.application.SHOW_FPS = True reac = thorpy.Reaction(pygame.KEYDOWN,func) ##reac = thorpy.Reaction(thorpy.THORPY_EVENT,func,{"id":thorpy.constants.EVENT_TIME}) app = thorpy.Application((800,600)) screen = thorpy.get_screen() cam = Camera(screen, fov=512, d=2) g = thorpy.Ghost.make() g.add_reaction(reac) m = thorpy.Menu(g,fps=100) m.play() app.quit()