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):
