def get_item_at_pos (self, position): """L.get_item_at_pos (...) -> ListItem Gets the item at the passed position coordinates. """ eventarea = self.rect_to_client () if not eventarea.collidepoint (position): return None position = position[0] - eventarea.left, position[1] - eventarea.top border = base.GlobalStyle.get_border_size \ (self.__class__, self.style, StyleInformation.get ("ACTIVE_BORDER")) * 2 posy = self.vadjustment items = self.scrolledlist.items width = eventarea.width bottom = eventarea.bottom images = self.images spacing = self.scrolledlist.spacing for item in items: rect = Rect (images [item][1]) rect.y = posy rect.width = width + border if rect.bottom > bottom: rect.height = bottom - rect.bottom + border if rect.collidepoint (position): return item posy += images[item][1].height + spacing + border return None
def replace_draw(self, screen, camera_offset=(0, 0)): if self.image is None: return if self.ignore_offset: x = self._draw_position[0] y = self._draw_position[1] else: x = self._draw_position[0] - camera_offset[0] y = self._draw_position[1] - camera_offset[1] camera_offset = camera_offset[0], camera_offset[1] rect = self.image.get_rect(topleft=self._draw_position) rect.move_ip(0, 0) screen_rect = screen.get_rect(topleft=camera_offset) overlap = screen_rect.clip(rect) overlap.move_ip(-camera_offset[0], -camera_offset[1]) #0 is to left #> is to right corner = overlap.topleft area = Rect(0, 0, 0, 0) area.size = overlap.size if corner[0] == 0: area.x = -x else: area.x = 0 if corner[1] == 0: area.y = -y else: area.y = 0 screen.blit(self.image, overlap, area)
def build_gui(self): super().build_gui() panel_rect = Rect( 0, 0, 500, self.display.get_rect().height - (get_param('panel_padding') * 2)) panel_rect.centerx = self.display.get_rect().centerx panel_rect.y = get_param('panel_padding') self.ui_elements['panel'] = UIPanel(panel_rect, 1, self.gui) # all other elements are relative scene_label_rect = Rect(0, 0, 400, get_param('element_height')) scene_label_rect.y = get_param('element_padding') scene_label_rect.centerx = panel_rect.w // 2 # midpoint of the panel self.ui_elements['scene_label'] = UILabel(scene_label_rect, "Map Editor Menu", self.gui, self.ui_elements['panel']) # buttons button_rect = Rect(0, 100, 400, get_param('element_height')) button_rect.centerx = panel_rect.w // 2 self.ui_elements['btn_new'] = UIButton(button_rect, "New Map", self.gui, self.ui_elements['panel']) button_rect.y += get_param('element_height') + get_param( 'element_padding') self.ui_elements['btn_load'] = UIButton(button_rect, "Load Map", self.gui, self.ui_elements['panel']) button_rect.y += get_param('element_height') + get_param( 'element_padding') self.ui_elements['btn_back'] = UIButton(button_rect, "Back", self.gui, self.ui_elements['panel'])
def build_gui(self): super().build_gui() panel_rect = Rect(0, 0, 500, self.display.get_rect().height - (get_param('panel_padding') * 2)) panel_rect.centerx = self.display.get_rect().centerx panel_rect.y = get_param('panel_padding') self.ui_elements['panel'] = UIPanel(panel_rect, 1, self.gui) # all other elements are relative scene_label_rect = Rect(0, 0, 400, get_param('element_height')) scene_label_rect.y = get_param('element_padding') scene_label_rect.centerx = panel_rect.w // 2 # midpoint of the panel self.ui_elements['scene_label'] = UILabel(scene_label_rect, "Select Existing Game Map", self.gui, self.ui_elements['panel']) # buttons select_rect = Rect(0, 0, 400, get_param('element_height') * 3) select_rect.y = scene_label_rect.bottom + get_param('element_padding') select_rect.centerx = panel_rect.w // 2 self.ui_elements['map_select'] = UISelectionList(select_rect, [f"Map {n}" for n in range(20)], self.gui, container=self.ui_elements['panel']) preview_rect = Rect(0, 0, 256, get_param('element_height') * 8) preview_rect.y = select_rect.bottom + get_param('element_padding') preview_rect.centerx = panel_rect.w // 2 self.ui_elements['preview'] = UILabel(preview_rect, "PREVIEW AREA", self.gui, self.ui_elements['panel']) button_rect = Rect(0, 0, 200, get_param('element_height')) button_rect.y = preview_rect.bottom + get_param('element_padding') button_rect.centerx = (panel_rect.w // 2) - 100 self.ui_elements['btn_back'] = UIButton(button_rect, "Back", self.gui, self.ui_elements['panel']) button_rect.centerx = (panel_rect.w // 2) + 100 self.ui_elements['btn_next'] = UIButton(button_rect, "Next", self.gui, self.ui_elements['panel']) self.ui_elements['btn_next'].disable()
def update_body(self): cell.Cell.update_body(self) val = self.input("A0") * 1 val += self.input("A1") * 2 val += self.input("A2") * 4 val += self.input("A3") * 8 val += self.input("A4") * 16 val += self.input("A5") * 32 val += self.input("A6") * 64 val += self.input("A7") * 128 h = int(self.rect_rel.height / 3); pos = Rect(self.rect_rel) pos.height = h self.parent.draw_text(self.surface, "%02X" % val, pos) pos = Rect(self.rect_rel) pos.y = h * 1 pos.height = h self.parent.draw_text(self.surface, "%03u" % val, pos) if (val < 0b01111111): sig = val else: sig = -(256 - val) pos = Rect(self.rect_rel) pos.y = h * 2 pos.height = h self.parent.draw_text(self.surface, "%+04d" % sig, pos)
def build_gui(self): super().build_gui() panel_rect = Rect( 0, 0, 500, self.display.get_rect().height - (get_param('panel_padding') * 2)) panel_rect.centerx = self.display.get_rect().centerx panel_rect.y = get_param('panel_padding') self.ui_elements['panel'] = UIPanel(panel_rect, 1, self.gui) # all other elements are relative scene_label_rect = Rect(0, 0, 400, get_param('element_height')) scene_label_rect.y = get_param('element_padding') scene_label_rect.centerx = panel_rect.w // 2 # midpoint of the panel self.ui_elements['scene_label'] = UILabel(scene_label_rect, "Settings", self.gui, self.ui_elements['panel']) # screen size label_rect = Rect(0, 0, 150, get_param('element_height')) label_rect.y += scene_label_rect.bottom + get_param('element_padding') dd_rect = Rect(0, 0, 250, get_param('element_height')) dd_rect.y = label_rect.y label_rect.centerx = 125 dd_rect.centerx = 325 self.ui_elements['d_size_label'] = UILabel(label_rect, "Display Size", self.gui, self.ui_elements['panel']) self.ui_elements['dd_d_size'] = UIDropDownMenu( get_param('display_sizes'), get_param('current_display_size'), dd_rect, self.gui, self.ui_elements['panel']) # full screen label_rect.y += get_param('element_height') + get_param( 'element_padding') dd_rect.y = label_rect.y self.ui_elements['fs_label'] = UILabel(label_rect, "Full Screen", self.gui, self.ui_elements['panel']) self.ui_elements['dd_fs'] = UIDropDownMenu( ["On", "Off"], get_param('display_full_screen_value'), dd_rect, self.gui, self.ui_elements['panel']) # buttons button_rect = Rect(0, 0, 200, get_param('element_height')) button_rect.y = label_rect.bottom + get_param('element_padding') button_rect.centerx = (panel_rect.w // 2) - 100 self.ui_elements['btn_back'] = UIButton(button_rect, "Back", self.gui, self.ui_elements['panel']) # the apply button always starts off disabled button_rect.centerx = (panel_rect.w // 2) + 100 self.ui_elements['btn_apply'] = UIButton(button_rect, "Apply", self.gui, self.ui_elements['panel']) self.ui_elements['btn_apply'].disable() # re-assign values for our check parameters, this is to control the apply buttons state self._check_screen_size = get_param('current_display_size') self._check_full_screen = get_param('display_full_screen_value')
def bounce_off_ip(bounce_obj_rect: Rect, bounce_obj_speed, \ hit_obj_rect: Rect, hit_obj_speed): """ Calculate the speed and position of the `bounce_obj` after it bounces off the `hit_obj`. The position of `bounce_obj_rect` and the value of `bounce_obj_speed` will be updated. This function should be called only when two objects are colliding. @param bounce_obj_rect The Rect of the bouncing object @param bounce_obj_speed The 2D speed vector of the bouncing object. @param hit_obj_rect The Rect of the hit object @param hit_obj_speed The 2D speed vector of the hit object """ # Treat the hit object as an unmovable object speed_diff_x = bounce_obj_speed[0] - hit_obj_speed[0] speed_diff_y = bounce_obj_speed[1] - hit_obj_speed[1] # The relative position between top and bottom, and left and right # of two objects at the last frame rect_diff_bT_hB = hit_obj_rect.bottom - bounce_obj_rect.top + speed_diff_y rect_diff_bB_hT = hit_obj_rect.top - bounce_obj_rect.bottom + speed_diff_y rect_diff_bL_hR = hit_obj_rect.right - bounce_obj_rect.left + speed_diff_x rect_diff_bR_hL = hit_obj_rect.left - bounce_obj_rect.right + speed_diff_x # Get the surface distance from the bouncing object to the hit object # and the new position for the bouncing object if it really hit the object # according to their relative position ## The bouncing object is at the bottom if rect_diff_bT_hB < 0 and rect_diff_bB_hT < 0: surface_diff_y = rect_diff_bT_hB extract_pos_y = hit_obj_rect.bottom ## The bouncing object is at the top elif rect_diff_bT_hB > 0 and rect_diff_bB_hT > 0: surface_diff_y = rect_diff_bB_hT extract_pos_y = hit_obj_rect.top - bounce_obj_rect.height else: surface_diff_y = -1 if speed_diff_y > 0 else 1 ## The bouncing object is at the right if rect_diff_bL_hR < 0 and rect_diff_bR_hL < 0: surface_diff_x = rect_diff_bL_hR extract_pos_x = hit_obj_rect.right ## The bouncing object is at the left elif rect_diff_bL_hR > 0 and rect_diff_bR_hL > 0: surface_diff_x = rect_diff_bR_hL extract_pos_x = hit_obj_rect.left - bounce_obj_rect.width else: surface_diff_x = -1 if speed_diff_x > 0 else 1 # Calculate the duration to hit the surface for x and y coordination. time_hit_y = surface_diff_y / speed_diff_y time_hit_x = surface_diff_x / speed_diff_x if time_hit_y >= 0 and time_hit_y >= time_hit_x: bounce_obj_speed[1] *= -1 bounce_obj_rect.y = extract_pos_y if time_hit_x >= 0 and time_hit_y <= time_hit_x: bounce_obj_speed[0] *= -1 bounce_obj_rect.x = extract_pos_x
def get_item_at_pos(self, position): """L.get_item_at_pos (...) -> ListItem Gets the item at the passed position coordinates. """ eventarea = self.rect_to_client() if not eventarea.collidepoint(position): return None position = position[0] - eventarea.left, position[1] - eventarea.top border = base.GlobalStyle.get_border_size \ (self.__class__, self.style, StyleInformation.get ("ACTIVE_BORDER")) * 2 posy = self.vadjustment items = self.scrolledlist.items width = eventarea.width bottom = eventarea.bottom images = self.images spacing = self.scrolledlist.spacing for item in items: rect = Rect(images[item][1]) rect.y = posy rect.width = width + border if rect.bottom > bottom: rect.height = bottom - rect.bottom + border if rect.collidepoint(position): return item posy += images[item][1].height + spacing + border return None
def get_world_collisions(self, collider): tw, th = self.tile_map.tile_width, self.tile_map.tile_height tmw, tmh = self.tile_map.width, self.tile_map.height # determine which grid square(s) the collider is in left, right = int(collider.rect.left / tw), int(collider.rect.right / tw) top, bottom = int(collider.rect.top / th), int(collider.rect.bottom / th) r = Rect(left * tw, top * th, tw, th) collisions = [] # each of these tiles is potentially intersecting the collider for x in range(left, right + 1): if x < 0 or x >= tmw: continue for y in range(top, bottom + 1): if y < 0 or y >= tmh: continue if not self.tile_map.get_passable((x, y)): # a non-passable tile might be within range: now use a pixel-perfect collision test r.x = x * tw r.y = y * th if collider.rect.colliderect(r): collisions.append( Collision(moved_collider=collider, hit_thing=(x, y), moved_collider_position=copy_vector( collider.position))) return collisions
def delta(self, rect: pg.Rect) -> pg.Rect: rect = rect.copy() rect.x = ceil(rect.x * self.dz + self.dx) rect.y = ceil(rect.y * self.dz + self.dy) rect.w = ceil(rect.w * self.dz) rect.h = ceil(rect.h * self.dz) return rect
def build_gui(self): super().build_gui() panel_rect = Rect( 0, 0, 500, self.display.get_rect().height - (get_param('panel_padding') * 2)) panel_rect.centerx = self.display.get_rect().centerx panel_rect.y = get_param('panel_padding') self.ui_elements['panel'] = UIPanel(panel_rect, 1, self.gui) # all other elements are relative scene_label_rect = Rect(0, 0, 400, get_param('element_height')) scene_label_rect.y = get_param('element_padding') scene_label_rect.centerx = panel_rect.w // 2 # midpoint of the panel self.ui_elements['scene_label'] = UILabel(scene_label_rect, "Main Menu", self.gui, self.ui_elements['panel']) # buttons button_rect = Rect(0, 0, 400, get_param('element_height')) button_rect.y = scene_label_rect.bottom + get_param('element_padding') button_rect.centerx = panel_rect.w // 2 self.ui_elements['btn_new'] = UIButton(button_rect, "New Game", self.gui, self.ui_elements['panel']) button_rect.y += get_param('element_height') + get_param( 'element_padding') self.ui_elements['btn_load'] = UIButton(button_rect, "Load Game", self.gui, self.ui_elements['panel']) button_rect.y += get_param('element_height') + get_param( 'element_padding') self.ui_elements['btn_editor'] = UIButton(button_rect, "Map Editor", self.gui, self.ui_elements['panel']) button_rect.y += get_param('element_height') + get_param( 'element_padding') self.ui_elements['btn_settings'] = UIButton(button_rect, "Settings", self.gui, self.ui_elements['panel']) button_rect.y += get_param('element_height') + get_param( 'element_padding') self.ui_elements['btn_quit'] = UIButton(button_rect, "Quit Game", self.gui, self.ui_elements['panel'])
def build_gui(self): super().build_gui() panel_rect = Rect( 0, 0, 500, self.display.get_rect().height - (get_param('panel_padding') * 2)) panel_rect.centerx = self.display.get_rect().centerx panel_rect.y = get_param('panel_padding') self.ui_elements['panel'] = UIPanel(panel_rect, 1, self.gui) # all other elements are relative scene_label_rect = Rect(0, 0, 400, get_param('element_height')) scene_label_rect.y = get_param('element_padding') scene_label_rect.centerx = panel_rect.w // 2 # midpoint of the panel self.ui_elements['scene_label'] = UILabel(scene_label_rect, "Load Saved Game", self.gui, self.ui_elements['panel']) # buttons select_rect = Rect(0, 0, 400, get_param('element_height') * 3) select_rect.y = scene_label_rect.bottom + get_param('element_padding') select_rect.centerx = panel_rect.w // 2 self.ui_elements['game_select'] = UISelectionList( select_rect, [f"Game {n}" for n in range(5)], self.gui, container=self.ui_elements['panel']) button_rect = Rect(0, 0, 200, get_param('element_height')) button_rect.y = select_rect.bottom + get_param('element_padding') button_rect.centerx = (panel_rect.w // 2) - 100 self.ui_elements['btn_load'] = UIButton(button_rect, "Load Save", self.gui, self.ui_elements['panel']) self.ui_elements['btn_load'].disable() button_rect.centerx = (panel_rect.w // 2 + 100) self.ui_elements['btn_delete'] = UIButton(button_rect, "Delete Save", self.gui, self.ui_elements['panel']) self.ui_elements['btn_delete'].disable() button_rect.w = 400 button_rect.centerx = panel_rect.w // 2 button_rect.y += get_param('element_height') + get_param( 'element_padding') self.ui_elements['btn_back'] = UIButton(button_rect, "Back", self.gui, self.ui_elements['panel'])
def render_hidden_hand(board_render, pov, seat): player = board_render.match.players[pov] rect = Rect(board_render.surface.get_rect()) tile_offset = 5 full_hand_width = (len(player.hand) * (SMALL_TILE_SIZE[0] + tile_offset) - tile_offset) TILE_POS = [ ((rect.width - full_hand_width) / 2, (SMALL_TILE_SIZE[1] + 15)), ((SMALL_TILE_SIZE[1] + 15), (rect.height - full_hand_width) / 2), ((rect.width - full_hand_width) / 2, 10), (10, (rect.height - full_hand_width) / 2), ] xpos, ypos = TILE_POS[seat] if seat == 0: rect.bottom = ypos elif seat == 1: rect.x = rect.width - xpos elif seat == 2: rect.y = ypos elif seat == 3: rect.x = xpos hand = [Piece(PieceType.ERROR)] * len(player.hand) if seat % 2 == 0: return _render_hand( board_render, SMALL_TILE_SIZE, player, hand, player.melded_hand, rect, xpos, tile_offset=tile_offset, should_interact=False, small_tile=True, ) return _render_vertical_hand( board_render, SMALL_TILE_SIZE, player, hand, player.melded_hand, rect, ypos, tile_offset=tile_offset, should_interact=False, rotation=1, small_tile=True, )
def update_body(self): cell.Cell.update_body(self) h = int(self.rect_rel.height / 4); pos = Rect(self.rect_rel) pos.height = h self.parent.draw_text(self.surface, "MEMORY", pos) pos = Rect(self.rect_rel) pos.y = h * 1 pos.height = h self.parent.draw_text(self.surface, self.filename, pos) pos = Rect(self.rect_rel) pos.y = h * 2 pos.height = h self.parent.draw_text(self.surface, "address: %04X" % self.address, pos) pos = Rect(self.rect_rel) pos.y = h * 3 pos.height = h self.parent.draw_text(self.surface, "data: %02X" % self.data, pos)
def crop_center(image, size): rect = Rect((0, 0), size) res_surf = Surface(size, SRCALPHA, 32) blit_pos = [0, 0] if image.get_width() > rect.width: blit_pos[0] = (-image.get_width()+rect.width) // 2 else: rect.x = (image.get_width()-rect.width) // 2 if image.get_height() > rect.height: blit_pos[1] = (-image.get_height()+rect.height) // 2 else: rect.y = (image.get_height()-rect.height) // 2 print(rect) print(blit_pos) res_surf.blit(crop(image, rect), blit_pos) return res_surf
def makeRooms(self): numRooms = random.randint(NUMROOMSMIN, NUMROOMSMAX) for roomID in range(numRooms): attempts = 0 room = Rect(0,0,0,0) room.width = random.randint(ROOMMIN, ROOMMAX) room.height = random.randint(ROOMMIN, ROOMMAX) posFound = False while not posFound: if attempts == MAXROOMALLOCATTEMPTS: #print("Could not resolve room placement for room %i, bailing" % (roomID+1)) break room.x = random.randint(2, WORLDSIZE[0] - 1) room.y = random.randint(5, WORLDSIZE[1] - 1) if (room.x + room.width) >= (WORLDSIZE[0] - 1) or (room.y + room.height) >= (WORLDSIZE[1] - 4): attempts += 1 continue posFound = True for r,w in self.roomInfo: if r.inflate(2*ROOMSPACING, 2*ROOMSPACING).colliderect(room): posFound = False attempts += 1 break if not posFound: continue #Place waypoint wpX = random.randint(room.x + 1 + int(CORTHICKNESS / 2), room.x + room.width - 1 - int(CORTHICKNESS / 2)) wpY = random.randint(room.y + 1 + int(CORTHICKNESS / 2), room.y + room.height - 1 - int(CORTHICKNESS / 2) ) self.roomInfo.append( (room, (wpX, wpY)) ) for x in range(room.x, room.x + room.width): for y in range(room.y, room.y + room.height): self.mapGrid[x][y] = "#" #Sort rooms in order of Y coordinates self.roomInfo.sort(key=lambda r: r[0].y)
def render_hand(board_render, player_pov): player = board_render.match.players[player_pov] rect = Rect(board_render.surface.get_rect()) rect.y = rect.height - (TILE_SIZE[1] + 15) tile_offset = 10 full_hand_width = len( player.hand) * (TILE_SIZE[0] + tile_offset) - tile_offset xpos = (rect.width - full_hand_width) / 2 return _render_hand( board_render, TILE_SIZE, player, player.hand, player.melded_hand, rect, xpos, tile_offset, )
def render_dora_pile(board_render): group = Group() match = board_render.match board = match.current_board dora_revealed = board.get_revealed_dora() dora_revealed += [Piece(PieceType.ERROR)] * (5 - board.dora_revealed) tile_offset = 10 full_width = (SMALL_TILE_SIZE[0] + tile_offset) * 5 - tile_offset xpos = 0 rect = Rect(board_render.surface.get_rect()) rect.y = 10 rect.x = rect.width - full_width - 10 for tile in dora_revealed: tile_pos = (rect.x + xpos, rect.y) tile_sprite = TileRender(board_render.small_dictionary, tile, tile_pos, small_tile=True) group.add(tile_sprite) xpos += tile_offset + SMALL_TILE_SIZE[0] return group
def build_gui(self): super().build_gui() panel_rect = Rect( 0, 0, 500, self.display.get_rect().height - (get_param('panel_padding') * 2)) panel_rect.centerx = self.display.get_rect().centerx panel_rect.y = get_param('panel_padding') self.ui_elements['panel'] = UIPanel(panel_rect, 1, self.gui) # all other elements are relative scene_label_rect = Rect(0, 0, 400, get_param('element_height')) scene_label_rect.y = get_param('element_padding') scene_label_rect.centerx = panel_rect.w // 2 # midpoint of the panel self.ui_elements['scene_label'] = UILabel(scene_label_rect, "Start New Game", self.gui, self.ui_elements['panel']) l_side_rect = Rect(0, 0, 150, get_param('element_height')) l_side_rect.centerx = 125 l_side_rect.y = scene_label_rect.bottom + get_param('element_padding') self.ui_elements['l_dd_label'] = UILabel(l_side_rect, "Map Type", self.gui, self.ui_elements['panel']) dd_rect = Rect(0, 0, 250, get_param('element_height')) dd_rect.y = l_side_rect.y dd_rect.centerx = 325 self.ui_elements['l_dd_game_map'] = UIDropDownMenu( ['Existing', 'Random'], 'Existing', dd_rect, self.gui, self.ui_elements['panel']) btn_rect = Rect(0, 0, 200, get_param('element_height')) btn_rect.centerx = (panel_rect.w) // 2 - 100 btn_rect.y = dd_rect.bottom + get_param('element_padding') self.ui_elements['btn_back'] = UIButton(btn_rect, "Back", self.gui, self.ui_elements['panel']) btn_rect = Rect(0, 0, 200, get_param('element_height')) btn_rect.centerx = (panel_rect.w // 2) + 100 btn_rect.y = dd_rect.bottom + get_param('element_padding') self.ui_elements['btn_next'] = UIButton(btn_rect, "Next", self.gui, self.ui_elements['panel'])
def scale_rect(rectangle: pygame.Rect, scale=2): rectangle.x = rectangle.x * scale rectangle.y = rectangle.y * scale rectangle.w = rectangle.w * scale rectangle.h = rectangle.h * scale return rectangle
def build_gui(self): super().build_gui() panel_rect = Rect( 0, 0, 500, self.display.get_rect().height - (get_param('panel_padding') * 2)) panel_rect.centerx = self.display.get_rect().centerx panel_rect.y = get_param('panel_padding') self.ui_elements['panel'] = UIPanel(panel_rect, 1, self.gui) # all other elements are relative scene_label_rect = Rect(0, 0, 400, get_param('element_height')) scene_label_rect.y = get_param('element_padding') scene_label_rect.centerx = panel_rect.w // 2 # midpoint of the panel self.ui_elements['scene_label'] = UILabel(scene_label_rect, "Generate Random Map", self.gui, self.ui_elements['panel']) # map size label_rect = Rect(0, 0, 150, get_param('element_height')) label_rect.y += scene_label_rect.bottom + get_param('element_padding') dd_rect = Rect(0, 0, 250, get_param('element_height')) dd_rect.y = label_rect.y label_rect.centerx = 125 dd_rect.centerx = 325 self.ui_elements['d_size_label'] = UILabel(label_rect, "Map Size", self.gui, self.ui_elements['panel']) self.ui_elements['dd_map_size'] = UIDropDownMenu( ['64', '128', '256'], '64', dd_rect, self.gui, self.ui_elements['panel']) # Seed label_rect.y += get_param('element_height') + get_param( 'element_padding') ip_rect = Rect(0, 0, 180, get_param('element_height')) ip_rect.centerx = (panel_rect.w // 2) + 30 ip_rect.y = label_rect.y s_btn_rect = Rect(0, 0, 60, get_param('element_height')) s_btn_rect.x = ip_rect.right + get_param('element_padding') s_btn_rect.y = ip_rect.y self.ui_elements['seed_label'] = UILabel(label_rect, 'Map Seed', self.gui, self.ui_elements['panel']) self.ui_elements['input_seed'] = UITextEntryLine( ip_rect, self.gui, self.ui_elements['panel']) self.ui_elements['btn_rnd_seed'] = UIButton(s_btn_rect, 'Random', self.gui, self.ui_elements['panel']) # I want to add two sliders, 1 for mountains and 1 for water, these would be used to control the upper # and lower limits of the height mapping. h_sl_ops = (0, 100) h_sl_sel = 50 label_rect.y += get_param('element_height') + get_param( 'element_padding') h_sl_rect = Rect(0, 0, 200, get_param('element_height')) h_sl_rect.centerx = (panel_rect.w // 2) + get_param('element_padding') + 30 h_sl_rect.y = label_rect.y self.ui_elements['hsl_grass'] = UILabel(label_rect, 'Grass', self.gui, self.ui_elements['panel']) self.ui_elements['hs_grass'] = UIHorizontalSlider( h_sl_rect, h_sl_sel, h_sl_ops, self.gui, self.ui_elements['panel']) label_rect.y += get_param('element_height') + get_param( 'element_padding') h_sl_rect.y = label_rect.y self.ui_elements['hsl_water'] = UILabel(label_rect, 'Water', self.gui, self.ui_elements['panel']) self.ui_elements['hs_water'] = UIHorizontalSlider( h_sl_rect, h_sl_sel, h_sl_ops, self.gui, self.ui_elements['panel']) label_rect.y += get_param('element_height') + get_param( 'element_padding') h_sl_rect.y = label_rect.y self.ui_elements['hsl_mountain'] = UILabel(label_rect, 'Mountain', self.gui, self.ui_elements['panel']) self.ui_elements['hs_mountain'] = UIHorizontalSlider( h_sl_rect, h_sl_sel, h_sl_ops, self.gui, self.ui_elements['panel']) # buttons button_rect = Rect(0, 0, 200, get_param('element_height')) button_rect.centerx = panel_rect.w // 2 button_rect.y = label_rect.bottom + get_param('element_padding') self.ui_elements['btn_preview'] = UIButton(button_rect, "Generate Preview", self.gui, self.ui_elements['panel']) button_rect.w = 200 button_rect.y += get_param('element_height') + get_param( 'element_padding') button_rect.centerx = (panel_rect.w // 2) - 100 self.ui_elements['btn_back'] = UIButton(button_rect, "Back", self.gui, self.ui_elements['panel']) # the apply button always starts off disabled button_rect.centerx = (panel_rect.w // 2) + 100 self.ui_elements['btn_next'] = UIButton(button_rect, "Next", self.gui, self.ui_elements['panel']) pv_rect = Rect(0, 0, 300, 300) pv_rect.centerx = panel_rect.w // 2 pv_rect.y = button_rect.bottom + get_param('element_padding') self.ui_elements['pv_image'] = UIImage(pv_rect, self.pv_img, self.gui, self.ui_elements['panel'])
if ai_speed > -maxSpeed: ai_speed -= player_a else: if ai_speed > 0: ai_speed -= player_a elif ai_speed < 0: ai_speed += player_a # update playerPaddle.move_ip(0, player_speed) aiPaddle.move_ip(0, ai_speed) ball.move_ip(ball_speed_x, ball_speed_y) # collisions if playerPaddle.y < 0: playerPaddle.y = 0 player_speed = 0 elif playerPaddle.bottom > height: playerPaddle.bottom = height player_speed = 0 if aiPaddle.y < 0: aiPaddle.y = 0 ai_speed = 0 elif aiPaddle.bottom > height: aiPaddle.bottom = height ai_speed = 0 if playerPaddle.colliderect(ball):