def test_process_event_mouse_button_double_click_in_empty_space(
self, _init_pygame: None, default_ui_manager: UIManager,
_display_surface_return_none: None):
text_entry = UITextEntryLine(relative_rect=pygame.Rect(0, 0, 200, 30),
manager=default_ui_manager)
text_entry.set_text(' dan')
processed_down_event = text_entry.process_event(
pygame.event.Event(pygame.MOUSEBUTTONDOWN, {
'button': 1,
'pos': (90, 15)
}))
processed_up_event = text_entry.process_event(
pygame.event.Event(pygame.MOUSEBUTTONDOWN, {
'button': 1,
'pos': (90, 15)
}))
assert (processed_down_event and processed_up_event
and text_entry.select_range == [0, 1])
def test_process_event_mouse_buttons(self, _init_pygame: None,
default_ui_manager: UIManager,
_display_surface_return_none: None):
text_entry = UITextEntryLine(relative_rect=pygame.Rect(0, 0, 200, 30),
manager=default_ui_manager)
text_entry.set_text('dan is amazing')
processed_down_event = text_entry.process_event(
pygame.event.Event(pygame.MOUSEBUTTONDOWN, {
'button': 1,
'pos': (30, 15)
}))
processed_up_event = text_entry.process_event(
pygame.event.Event(pygame.MOUSEBUTTONUP, {
'button': 1,
'pos': (80, 15)
}))
assert processed_down_event
assert processed_up_event
assert text_entry.select_range == [3, 9]
class EverythingWindow(UIWindow):
def __init__(self, rect, ui_manager):
element_ids = ['everything_window']
super().__init__(rect, ui_manager, element_ids=element_ids)
# create shadow
shadow_padding = (2, 2)
self.image = self.ui_manager.get_shadow(self.rect.size)
self.image.fill(self.ui_manager.get_theme().get_colour(self.object_ids, self.element_ids, 'dark_bg'),
pygame.Rect(shadow_padding,
(self.rect.width - shadow_padding[0] * 2,
self.rect.height - shadow_padding[1] * 2)
))
self.get_container().relative_rect.width = self.rect.width - shadow_padding[0] * 2
self.get_container().relative_rect.height = self.rect.height - shadow_padding[1] * 2
self.get_container().relative_rect.x = self.get_container().relative_rect.x + shadow_padding[0]
self.get_container().relative_rect.y = self.get_container().relative_rect.y + shadow_padding[1]
self.get_container().update_containing_rect_position()
self.close_window_button = UIButton(relative_rect=pygame.Rect((self.get_container().rect.width-20, 0),
(20, 20)),
text='╳',
manager=ui_manager,
container=self.get_container(),
parent_element=self
)
self.menu_bar = UIButton(relative_rect=pygame.Rect((0, 0),
(self.get_container().rect.width-20, 20)),
text='Everything Container',
manager=ui_manager,
container=self.get_container(),
parent_element=self,
object_id='#message_window_title_bar'
)
self.menu_bar.set_hold_range((100, 100))
self.grabbed_window = False
self.starting_grab_difference = (0, 0)
self.test_slider = UIHorizontalSlider(pygame.Rect((int(self.rect.width / 2),
int(self.rect.height * 0.70)),
(240, 25)),
50.0,
(0.0, 100.0),
self.ui_manager,
container=self.get_container(),
parent_element=self)
self.slider_label = UILabel(pygame.Rect((int(self.rect.width / 2) + 250,
int(self.rect.height * 0.70)),
(27, 25)),
str(int(self.test_slider.get_current_value())),
self.ui_manager,
container=self.get_container(),
parent_element=self)
self.test_text_entry = UITextEntryLine(pygame.Rect((int(self.rect.width / 2),
int(self.rect.height * 0.50)),
(200, -1)),
self.ui_manager,
container=self.get_container(),
parent_element=self)
self.test_text_entry.set_forbidden_characters('numbers')
current_resolution_string = 'Item 1'
self.test_drop_down_menu = UIDropDownMenu(['Item 1',
'Item 2',
'Item 3',
'Item 4',
'Item 5',
'Item 6'],
current_resolution_string,
pygame.Rect((int(self.rect.width / 2),
int(self.rect.height * 0.3)),
(200, 25)),
self.ui_manager,
container=self.get_container(),
parent_element=self)
self.health_bar = UIScreenSpaceHealthBar(pygame.Rect((int(self.rect.width / 9),
int(self.rect.height * 0.7)),
(200, 20)),
self.ui_manager,
container=self.get_container(),
parent_element=self)
loaded_test_image = pygame.image.load('data/images/splat.png').convert_alpha()
self.test_image = UIImage(pygame.Rect((int(self.rect.width / 9),
int(self.rect.height * 0.3)),
loaded_test_image.get_rect().size),
loaded_test_image, self.ui_manager,
container=self.get_container(),
parent_element=self)
self.is_selected = False
def select(self):
self.is_selected = True
def unselect(self):
self.is_selected = False
def process_event(self, event):
processed_event = False
if self.is_selected:
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_p:
self.test_slider.set_current_value(50)
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
mouse_x, mouse_y = event.pos
if self.rect.collidepoint(mouse_x, mouse_y):
processed_event = True
self.window_stack.move_window_to_front(self)
return processed_event
def update(self, time_delta):
if self.alive():
if self.test_slider.has_moved_recently:
self.slider_label.set_text(str(int(self.test_slider.get_current_value())))
if self.menu_bar.held:
mouse_x, mouse_y = pygame.mouse.get_pos()
if not self.grabbed_window:
self.window_stack.move_window_to_front(self)
self.grabbed_window = True
self.starting_grab_difference = (mouse_x - self.rect.x,
mouse_y - self.rect.y)
current_grab_difference = (mouse_x - self.rect.x,
mouse_y - self.rect.y)
adjustment_required = (current_grab_difference[0] - self.starting_grab_difference[0],
current_grab_difference[1] - self.starting_grab_difference[1])
self.rect.x += adjustment_required[0]
self.rect.y += adjustment_required[1]
self.get_container().relative_rect.x += adjustment_required[0]
self.get_container().relative_rect.y += adjustment_required[1]
self.get_container().update_containing_rect_position()
else:
self.grabbed_window = False
if self.close_window_button.check_pressed():
self.kill()
super().update(time_delta)
def prepare_inputbox(self):
self.inputbox = UITextEntryLine(
pygame.Rect((560, SCREEN_HEIGHT - 60), (300, 60)), self.ui)
background.fill(pygame.Color("#000000"))
manager = pygame_gui.UIManager((600, 450))
menu = UIDropDownMenu(
options_list=["схема", "спутник", "гибрид"],
starting_option="схема",
relative_rect=pygame.Rect(0, 0, 200, 30),
manager=manager,
)
label = UILabel(relative_rect=pygame.Rect(0, 420, 600, 30),
text=full_adress(json),
manager=manager)
text_entry = UITextEntryLine(relative_rect=pygame.Rect(0, 30, 150, 30),
manager=manager)
search_button = pygame_gui.elements.UIButton(relative_rect=pygame.Rect(
(150, 30), (50, 30)),
text="find",
manager=manager)
cancel_button = pygame_gui.elements.UIButton(relative_rect=pygame.Rect(
(0, 60), (200, 30)),
text="cancel",
manager=manager)
postal_button = pygame_gui.elements.UIButton(
relative_rect=pygame.Rect((0, 90), (200, 30)),
text="wiew postal code",
manager=manager,
def __init__(self, path, title, confirm_callback, save):
super().__init__(
pygame.Rect(SCREEN_WIDTH / 2 - 440 / 2, SCREEN_HEIGHT / 2 - 500 / 2, 440, 500),
ui_manager,
window_display_title=title,
resizable=True
)
# set initial path
self.path = path
self.current_file_list = []
self.confirm_callback = confirm_callback
self.save = save
# set minimum dimensions
minimum_dimensions = (300, 300)
self.set_minimum_dimensions(minimum_dimensions)
# file browser panel
file_selection_rect = pygame.Rect(
10,
20,
self.get_container().get_size()[0] - 20,
self.get_container().get_size()[1] - 70
)
self.update_file_list()
self.file_selection_list = UISelectionList(
relative_rect=file_selection_rect,
item_list=self.current_file_list,
manager=ui_manager,
container=self,
object_id='#file_display_list',
anchors=
{
'left': 'left',
'right': 'right',
'top': 'top',
'bottom': 'bottom'
}
)
register_ui_callback(
self.file_selection_list,
pygame_gui.UI_SELECTION_LIST_NEW_SELECTION,
lambda e: self.file_name_text_line.set_text(e.text)
)
# text entry line to write file name
text_line_rect = pygame.Rect(10, -40, self.get_container().get_size()[0] - 110, 25)
self.file_name_text_line = UITextEntryLine(
relative_rect=text_line_rect,
manager=self.ui_manager,
container=self,
object_id='#file_path_text_line',
anchors=
{
'left': 'left',
'right': 'right',
'top': 'bottom',
'bottom': 'bottom'
}
)
if not save:
self.file_name_text_line.disable()
# confirm button
confirm_btn_rect = pygame.Rect(-90, -40, 80, 30)
self.confirm_btn = UIButton(
relative_rect=confirm_btn_rect,
text="OK",
manager=self.ui_manager,
container=self,
anchors=
{
'left': 'right',
'right': 'right',
'top': 'bottom',
'bottom': 'bottom'
}
)
register_ui_callback(
self.confirm_btn,
pygame_gui.UI_BUTTON_PRESSED,
lambda e: (
self.on_confirm_btn_click()
)
)
self.set_blocking(True)
class SaveLoadWindow(UIWindow):
def __init__(self, path, title, confirm_callback, save):
super().__init__(
pygame.Rect(SCREEN_WIDTH / 2 - 440 / 2, SCREEN_HEIGHT / 2 - 500 / 2, 440, 500),
ui_manager,
window_display_title=title,
resizable=True
)
# set initial path
self.path = path
self.current_file_list = []
self.confirm_callback = confirm_callback
self.save = save
# set minimum dimensions
minimum_dimensions = (300, 300)
self.set_minimum_dimensions(minimum_dimensions)
# file browser panel
file_selection_rect = pygame.Rect(
10,
20,
self.get_container().get_size()[0] - 20,
self.get_container().get_size()[1] - 70
)
self.update_file_list()
self.file_selection_list = UISelectionList(
relative_rect=file_selection_rect,
item_list=self.current_file_list,
manager=ui_manager,
container=self,
object_id='#file_display_list',
anchors=
{
'left': 'left',
'right': 'right',
'top': 'top',
'bottom': 'bottom'
}
)
register_ui_callback(
self.file_selection_list,
pygame_gui.UI_SELECTION_LIST_NEW_SELECTION,
lambda e: self.file_name_text_line.set_text(e.text)
)
# text entry line to write file name
text_line_rect = pygame.Rect(10, -40, self.get_container().get_size()[0] - 110, 25)
self.file_name_text_line = UITextEntryLine(
relative_rect=text_line_rect,
manager=self.ui_manager,
container=self,
object_id='#file_path_text_line',
anchors=
{
'left': 'left',
'right': 'right',
'top': 'bottom',
'bottom': 'bottom'
}
)
if not save:
self.file_name_text_line.disable()
# confirm button
confirm_btn_rect = pygame.Rect(-90, -40, 80, 30)
self.confirm_btn = UIButton(
relative_rect=confirm_btn_rect,
text="OK",
manager=self.ui_manager,
container=self,
anchors=
{
'left': 'right',
'right': 'right',
'top': 'bottom',
'bottom': 'bottom'
}
)
register_ui_callback(
self.confirm_btn,
pygame_gui.UI_BUTTON_PRESSED,
lambda e: (
self.on_confirm_btn_click()
)
)
self.set_blocking(True)
def on_confirm_btn_click(self):
target_file = self.file_name_text_line.get_text()
if not self.save:
files = self.get_files_in_path()
if target_file not in files:
show_message_box("<b><font face='verdana' color='#FF3333' size=3.5>"
"Invalid file name"
"</font></b>")
self.kill()
return
self.confirm_callback(target_file),
self.kill()
def update_file_list(self):
#files = [f.name for f in Path(self.path).iterdir() if f.is_file() ]
files = self.get_files_in_path()
files = sorted(files, key=str.casefold)
self.current_file_list = files
def get_files_in_path(self):
files = file_utils.get_all_files_in_path(self.path, MAPS_EXTENSION)
files = [f.split('/')[1] for f in files]
return files
def test_update_cursor_blink(self, _init_pygame,
_display_surface_return_none: None):
manager = UIManager(
(800, 600),
os.path.join("tests", "data", "themes",
"ui_text_entry_line_non_default.json"))
text_entry = UITextEntryLine(relative_rect=pygame.Rect(
100, 100, 200, 30),
manager=manager)
text_entry.select()
text_entry.cursor_blink_delay_after_moving_acc = 10.0
text_entry.update(0.01)
text_entry.blink_cursor_time_acc = 10.0
text_entry.update(0.01)
text_entry.blink_cursor_time_acc = 10.0
text_entry.update(0.01)
def test_enable(self, _init_pygame: None, default_ui_manager: UIManager,
_display_surface_return_none: None):
text_entry = UITextEntryLine(relative_rect=pygame.Rect(
100, 100, 200, 30),
manager=default_ui_manager)
text_entry.focus()
text_entry.enable()
assert text_entry.is_enabled is True
text_entry.focus()
# process a mouse button down event
processed_key_event = text_entry.process_event(
pygame.event.Event(pygame.KEYDOWN, {
'key': pygame.K_d,
'mod': 0,
'unicode': 'd'
}))
text_entry.process_event(
pygame.event.Event(pygame.KEYDOWN, {
'key': pygame.K_a,
'mod': 0,
'unicode': 'a'
}))
text_entry.process_event(
pygame.event.Event(pygame.KEYDOWN, {
'key': pygame.K_n,
'mod': 0,
'unicode': 'n'
}))
assert processed_key_event is True and text_entry.get_text() == 'dan'
def test_process_event_text_ctrl_v_select_range(
self, _init_pygame: None, default_ui_manager: UIManager,
_display_surface_return_none: None):
text_entry = UITextEntryLine(relative_rect=pygame.Rect(
100, 100, 200, 30),
manager=default_ui_manager)
text_entry.set_text('dan')
text_entry.select()
text_entry.select_range = [1, 3]
text_entry.process_event(
pygame.event.Event(pygame.KEYDOWN, {
'key': pygame.K_c,
'mod': pygame.KMOD_CTRL,
'unicode': 'c'
}))
text_entry.select_range = [0, 3]
processed_key_event = text_entry.process_event(
pygame.event.Event(pygame.KEYDOWN, {
'key': pygame.K_v,
'mod': pygame.KMOD_CTRL,
'unicode': 'v'
}))
assert processed_key_event and text_entry.get_text() == 'an'
def test_process_event_text_ctrl_c(self, _init_pygame: None,
_display_surface_return_none: None):
manager = UIManager(
(800, 600),
os.path.join("tests", "data", "themes",
"ui_text_entry_line_non_default_2.json"))
text_entry = UITextEntryLine(relative_rect=pygame.Rect(
100, 100, 200, 30),
manager=manager)
text_entry.set_text('dan')
text_entry.select()
text_entry.select_range = [0, 3]
processed_key_event = text_entry.process_event(
pygame.event.Event(pygame.KEYDOWN, {
'key': pygame.K_c,
'mod': pygame.KMOD_CTRL,
'unicode': 'c'
}))
text_entry.cursor_on = True
text_entry.redraw_cursor()
assert processed_key_event and clipboard_paste() == 'dan'
def test_process_event_text_entered_too_long(
self, _init_pygame: None, default_ui_manager: UIManager,
_display_surface_return_none: None):
text_entry = UITextEntryLine(relative_rect=pygame.Rect(
100, 100, 200, 30),
manager=default_ui_manager)
text_entry.set_text_length_limit(3)
text_entry.select()
text_entry.process_event(
pygame.event.Event(pygame.KEYDOWN, {
'key': pygame.K_t,
'mod': 0,
'unicode': 't'
}))
text_entry.process_event(
pygame.event.Event(pygame.KEYDOWN, {
'key': pygame.K_e,
'mod': 0,
'unicode': 'e'
}))
text_entry.process_event(
pygame.event.Event(pygame.KEYDOWN, {
'key': pygame.K_s,
'mod': 0,
'unicode': 's'
}))
processed_key_event = text_entry.process_event(
pygame.event.Event(pygame.KEYDOWN, {
'key': pygame.K_s,
'mod': 0,
'unicode': 't'
}))
assert processed_key_event is False and text_entry.get_text() == 'tes'
def test_creation(self, _init_pygame, default_ui_manager):
text_entry = UITextEntryLine(relative_rect=pygame.Rect(
100, 100, 200, 30),
manager=default_ui_manager)
assert text_entry.image is not None
def __init__(self, rect, ui_manager):
element_ids = ['everything_window']
super().__init__(rect, ui_manager, element_ids=element_ids)
# create shadow
shadow_padding = (2, 2)
self.image = self.ui_manager.get_shadow(self.rect.size)
self.image.fill(self.ui_manager.get_theme().get_colour(self.object_ids, self.element_ids, 'dark_bg'),
pygame.Rect(shadow_padding,
(self.rect.width - shadow_padding[0] * 2,
self.rect.height - shadow_padding[1] * 2)
))
self.get_container().relative_rect.width = self.rect.width - shadow_padding[0] * 2
self.get_container().relative_rect.height = self.rect.height - shadow_padding[1] * 2
self.get_container().relative_rect.x = self.get_container().relative_rect.x + shadow_padding[0]
self.get_container().relative_rect.y = self.get_container().relative_rect.y + shadow_padding[1]
self.get_container().update_containing_rect_position()
self.close_window_button = UIButton(relative_rect=pygame.Rect((self.get_container().rect.width-20, 0),
(20, 20)),
text='╳',
manager=ui_manager,
container=self.get_container(),
parent_element=self
)
self.menu_bar = UIButton(relative_rect=pygame.Rect((0, 0),
(self.get_container().rect.width-20, 20)),
text='Everything Container',
manager=ui_manager,
container=self.get_container(),
parent_element=self,
object_id='#message_window_title_bar'
)
self.menu_bar.set_hold_range((100, 100))
self.grabbed_window = False
self.starting_grab_difference = (0, 0)
self.test_slider = UIHorizontalSlider(pygame.Rect((int(self.rect.width / 2),
int(self.rect.height * 0.70)),
(240, 25)),
50.0,
(0.0, 100.0),
self.ui_manager,
container=self.get_container(),
parent_element=self)
self.slider_label = UILabel(pygame.Rect((int(self.rect.width / 2) + 250,
int(self.rect.height * 0.70)),
(27, 25)),
str(int(self.test_slider.get_current_value())),
self.ui_manager,
container=self.get_container(),
parent_element=self)
self.test_text_entry = UITextEntryLine(pygame.Rect((int(self.rect.width / 2),
int(self.rect.height * 0.50)),
(200, -1)),
self.ui_manager,
container=self.get_container(),
parent_element=self)
self.test_text_entry.set_forbidden_characters('numbers')
current_resolution_string = 'Item 1'
self.test_drop_down_menu = UIDropDownMenu(['Item 1',
'Item 2',
'Item 3',
'Item 4',
'Item 5',
'Item 6'],
current_resolution_string,
pygame.Rect((int(self.rect.width / 2),
int(self.rect.height * 0.3)),
(200, 25)),
self.ui_manager,
container=self.get_container(),
parent_element=self)
self.health_bar = UIScreenSpaceHealthBar(pygame.Rect((int(self.rect.width / 9),
int(self.rect.height * 0.7)),
(200, 20)),
self.ui_manager,
container=self.get_container(),
parent_element=self)
loaded_test_image = pygame.image.load('data/images/splat.png').convert_alpha()
self.test_image = UIImage(pygame.Rect((int(self.rect.width / 9),
int(self.rect.height * 0.3)),
loaded_test_image.get_rect().size),
loaded_test_image, self.ui_manager,
container=self.get_container(),
parent_element=self)
self.is_selected = False
def test_process_event_text_ctrl_x(self, _init_pygame: None,
default_ui_manager: UIManager,
_display_surface_return_none: None):
text_entry = UITextEntryLine(relative_rect=pygame.Rect(
100, 100, 200, 30),
manager=default_ui_manager)
text_entry.set_text('dan')
text_entry.select()
processed_key_event = text_entry.process_event(
pygame.event.Event(pygame.KEYDOWN, {
'key': pygame.K_a,
'mod': pygame.KMOD_CTRL,
'unicode': 'a'
}))
text_entry.process_event(
pygame.event.Event(pygame.KEYDOWN, {
'key': pygame.K_x,
'mod': pygame.KMOD_CTRL,
'unicode': 'x'
}))
text_entry.process_event(
pygame.event.Event(pygame.KEYDOWN, {
'key': pygame.K_v,
'mod': pygame.KMOD_CTRL,
'unicode': 'v'
}))
assert processed_key_event and clipboard_paste() == 'dan'
def move(self, squares: Squares, win: pygame.Surface, board):
if not isinstance(squares, list):
raise TypeError("The squares arguement must be a list(), not " +
str(type(squares))[8:-1] + "().")
limiting_pos = [[self.min_x, max_x], [self.min_y, self.max_y]]
max_length = 1
selected = False
direction = 0
max_direction = 8
direction_offset = 0
pygame.font.init()
while (self.x in limiting_pos[0] and self.y in limiting_pos[1]):
if len(self.pieces) > max_length:
font = pygame.font.SysFont("comicsans", 40)
text = font.render(
"You can't select that piece because you have already selected a piece. You must either move the already selected piece or unselect it."
)
win.blit(txt, ((self.max_x - txt.get_width()) / 2,
(self.max_y - txt.get_height()) / 2))
for event in pygame.event.get():
if event.type == pygame.K_SPACE or event.type == pygame.K_RETURN:
if (self.x, self.y, self.name) in pieces:
selected = False
self.pieces.pop()
else:
selected = True
self.pieces.append((self.x, self.y, self.name))
keys = pygame.key.get_pressed()
if ((keys[pygame.K_RALT] and keys[pygame.K_k]) or
(keys[pygame.K_LALT] and keys[pygame.K_k])) and not (
(keys[pygame.K_RALT] and keys[pygame.K_k]) and
(keys[pygame.K_LALT] and keys[pygame.K_k])):
active = False
text_input_line = UITextEntryLine(pygame.pygame.Rect(
self.x, self.y, self.square_width, self.square_height),
manager=MANAGER)
text_input_line.disable()
text_input_line.set_allowed_characters(
[d for d in string.digits[1:9]] +
[l for l in string.ascii_lowercase[:8]])
text_input_line.set_text_length_limit(2)
if active:
text_input_line.enable()
text_input_line.focus()
if keys[pygame.K_RETURN]:
text = text_input_line.get_text()
file = text[0]
rank = int(text[1])
move_set = self.get_possible_positions(
text[0] + str(text[1]), squares)
piece = self.find_piece_from_move_set(
move_set, squares)
if piece:
self.x, self.y = get_window_pos(
self.file, self.rank, self.possible_files)
original_x, original_y = self.x, self.y
else:
text = font.render(
"You can't move there. There is no knight nearby."
)
win.blit(text, (self.x, self.y))
else:
text_input_line.disable()
text_input_line.unfocus()
while direction < max_direction:
self.attacked_pieces = self._update_attacked_pieces(
self.x, self.y, self.square_width, self.square_height,
squares)
direction += 1
direction = 0
return self.attacked_pieces, (self.piece_x,
self.piece_y), (original_x,
original_y), self
class MapSettingsWindow(UIWindow):
def on_fall_add_btn_click(self):
map_settings.settings.falls.append(
EnemiesFall([
EnemiesGroup([0] * len(enemy.enemies_definitions), 1.0,
[0.5, 1.0])
], 100))
self.current_selected_group = 0
self.update_settings()
def on_fall_remove_btn_click(self):
if len(map_settings.settings.falls) > 1:
map_settings.settings.falls.remove(
map_settings.settings.falls[self.current_selected_fall])
self.current_selected_fall = 0
self.current_selected_group = 0
self.update_settings()
def on_fall_list_item_select(self):
for i in range(0, len(self.falls_ui_list.item_list)):
if self.falls_ui_list.item_list[i]['selected']:
self.current_selected_fall = i
self.current_selected_group = 0
self.update_groups_list()
self.update_fall_panel()
return
def on_group_add_btn_click(self):
map_settings.settings.falls[self.current_selected_fall].groups.append(
EnemiesGroup([0] * len(enemy.enemies_definitions), 1.0,
[0.5, 1.0]))
self.update_groups_list()
self.update_group_panel()
self.update_enemies_panel()
def on_group_remove_btn_click(self):
curr_fall = map_settings.settings.falls[self.current_selected_fall]
if len(curr_fall.groups) > 1:
curr_fall.groups.remove(
curr_fall.groups[self.current_selected_group])
self.current_selected_group = 0
self.update_groups_list()
def on_fall_gold_text_changed(self, e):
if len(map_settings.settings.falls) > 0:
if len(e.text) > 0 and e.text.isnumeric():
map_settings.settings.falls[
self.current_selected_fall].gold_reward = int(e.text)
else:
map_settings.settings.falls[
self.current_selected_fall].gold_reward = 0
self.update_fall_panel()
def on_start_gold_text_changed(self, e):
if len(e.text) > 0 and e.text.isnumeric():
map_settings.settings.start_gold = int(e.text)
else:
map_settings.settings.start_gold = 0
self.update_general_panel()
def on_start_mana_text_changed(self, e):
if len(e.text) > 0 and e.text.isnumeric():
map_settings.settings.start_mana = int(e.text)
else:
map_settings.settings.start_mana = 0
self.update_general_panel()
def on_group_list_item_select(self, e):
for i in range(0, len(self.groups_ui_list.item_list)):
if self.groups_ui_list.item_list[i]['selected']:
self.current_selected_group = i
self.update_group_panel()
self.update_enemies_panel()
return
def on_group_spawn_delay_changed(self, e):
if len(map_settings.settings.falls) > 0:
if len(map_settings.settings.falls[
self.current_selected_fall].groups) > 0:
curr_group = map_settings.settings.falls[
self.current_selected_fall].groups[
self.current_selected_group]
if len(e.text) > 0 and utils.is_float(e.text):
curr_group.spawn_delay = float(e.text)
else:
curr_group.spawn_delay = 0.0
self.update_group_panel()
def on_group_spawn_interval_left_changed(self, e):
if len(map_settings.settings.falls) > 0:
if len(map_settings.settings.falls[
self.current_selected_fall].groups) > 0:
curr_group = map_settings.settings.falls[
self.current_selected_fall].groups[
self.current_selected_group]
if len(e.text) > 0 and utils.is_float(e.text):
curr_group.interval[0] = float(e.text)
else:
curr_group.interval[0] = 0.0
self.update_group_panel()
def on_group_spawn_interval_right_changed(self, e):
if len(map_settings.settings.falls) > 0:
if len(map_settings.settings.falls[
self.current_selected_fall].groups) > 0:
curr_group = map_settings.settings.falls[
self.current_selected_fall].groups[
self.current_selected_group]
if len(e.text) > 0 and utils.is_float(e.text):
curr_group.interval[1] = float(e.text)
else:
curr_group.interval[1] = 0.0
self.update_group_panel()
def on_change_enemy_count(self, e, i):
if len(map_settings.settings.falls) > 0:
if len(map_settings.settings.falls[
self.current_selected_fall].groups) > 0:
curr_group = map_settings.settings.falls[
self.current_selected_fall].groups[
self.current_selected_group]
if len(e.text) > 0 and e.text.isnumeric():
curr_group.enemies_counts[i] = int(e.text)
else:
curr_group.enemies_counts[i] = 0
self.update_enemies_panel()
def on_max_tower_text_changed(self, e):
if len(e.text) > 0 and e.text.isnumeric():
map_settings.settings.max_tower = math_utils.clamp(
int(e.text), 0, len(tower.tower_definitions))
else:
map_settings.settings.max_tower = len(tower.tower_definitions)
self.update_general_panel()
def on_max_spell_text_changed(self, e):
if len(e.text) > 0 and e.text.isnumeric():
map_settings.settings.max_spell = math_utils.clamp(
int(e.text), 0, len(spell.spells_definitions))
else:
map_settings.settings.max_spell = len(spell.spells_definitions)
self.update_general_panel()
def __init__(self):
windowWidth = 1340
windowHeight = 600
super().__init__(pygame.Rect(
SCREEN_WIDTH * 0.5 - windowWidth * 0.5,
SCREEN_HEIGHT * 0.5 - windowHeight * 0.5,
windowWidth,
windowHeight,
),
ui_manager,
window_display_title="Settings",
resizable=False)
UILabel(pygame.Rect(0, 0, 80, 30),
"General",
ui_manager,
container=self)
general_panel = UIPanel(pygame.Rect(10, 30, 250, 600 - 100),
starting_layer_height=4,
manager=ui_manager,
container=self,
object_id="#thicker_panel")
UILabel(pygame.Rect(10, 10, 80, 30),
"Start Gold",
ui_manager,
container=general_panel)
self.start_gold_text_line = UITextEntryLine(
pygame.Rect(100, 10, 60, 20),
manager=ui_manager,
container=general_panel,
#object_id='#file_path_text_line',
anchors={
'left': 'left',
'right': 'left',
'top': 'top',
'bottom': 'bottom'
})
register_ui_callback(self.start_gold_text_line,
pygame_gui.UI_TEXT_ENTRY_CHANGED,
lambda e: self.on_start_gold_text_changed(e))
UILabel(pygame.Rect(10, 40, 80, 30),
"Start Mana",
ui_manager,
container=general_panel)
self.start_mana_text_line = UITextEntryLine(
pygame.Rect(100, 40, 60, 20),
manager=ui_manager,
container=general_panel,
#object_id='#file_path_text_line',
anchors={
'left': 'left',
'right': 'left',
'top': 'top',
'bottom': 'bottom'
})
register_ui_callback(self.start_mana_text_line,
pygame_gui.UI_TEXT_ENTRY_CHANGED,
lambda e: self.on_start_mana_text_changed(e))
UILabel(pygame.Rect(10, 70, 80, 30),
"Max Tower",
ui_manager,
container=general_panel)
self.max_tower_text_line = UITextEntryLine(
pygame.Rect(100, 70, 60, 20),
manager=ui_manager,
container=general_panel,
#object_id='#file_path_text_line',
anchors={
'left': 'left',
'right': 'left',
'top': 'top',
'bottom': 'bottom'
})
register_ui_callback(self.max_tower_text_line,
pygame_gui.UI_TEXT_ENTRY_CHANGED,
lambda e: self.on_max_tower_text_changed(e))
UILabel(pygame.Rect(10, 100, 80, 30),
"Max Spell",
ui_manager,
container=general_panel)
self.max_spell_text_line = UITextEntryLine(
pygame.Rect(100, 100, 60, 20),
manager=ui_manager,
container=general_panel,
#object_id='#file_path_text_line',
anchors={
'left': 'left',
'right': 'left',
'top': 'top',
'bottom': 'bottom'
})
register_ui_callback(self.max_spell_text_line,
pygame_gui.UI_TEXT_ENTRY_CHANGED,
lambda e: self.on_max_spell_text_changed(e))
# ---------------------------- falls
UILabel(pygame.Rect(250, 0, 80, 30),
"Falls",
ui_manager,
container=self)
self.falls_list = ["Dummy", "Dummy"]
self.current_selected_fall = 0
self.falls_ui_list = UISelectionList(
pygame.Rect(270, 30, 250, 220),
item_list=self.falls_list,
manager=ui_manager,
container=self,
object_id="#thicker_panel",
)
register_ui_callback(self.falls_ui_list,
pygame_gui.UI_SELECTION_LIST_NEW_SELECTION,
lambda e: self.on_fall_list_item_select())
self.fall_add_btn = UIButton(pygame.Rect(270, 250, 125, 30),
"Add Fall",
ui_manager,
container=self)
self.fall_remove_btn = UIButton(pygame.Rect(395, 250, 125, 30),
"Remove Fall",
ui_manager,
container=self)
register_ui_callback(self.fall_add_btn, pygame_gui.UI_BUTTON_PRESSED,
lambda e: self.on_fall_add_btn_click())
register_ui_callback(self.fall_remove_btn,
pygame_gui.UI_BUTTON_PRESSED,
lambda e: self.on_fall_remove_btn_click())
UILabel(pygame.Rect(262, 290, 120, 30),
"Fall Settings",
ui_manager,
container=self)
self.fall_settings_panel = UIPanel(pygame.Rect(270, 320, 250, 210),
starting_layer_height=4,
object_id="#thicker_panel",
manager=ui_manager,
container=self)
# gold reward
UILabel(pygame.Rect(5, 10, 100, 30),
"Gold Reward",
ui_manager,
container=self.fall_settings_panel)
self.fall_gold_reward = UITextEntryLine(
pygame.Rect(105, 10, 60, 20),
manager=ui_manager,
container=self.fall_settings_panel,
)
register_ui_callback(self.fall_gold_reward,
pygame_gui.UI_TEXT_ENTRY_CHANGED,
lambda e: self.on_fall_gold_text_changed(e))
# ---------------------------- groups
UILabel(pygame.Rect(515, 0, 80, 30),
"Groups",
ui_manager,
container=self)
self.groups_list = []
self.current_selected_group = 0
self.groups_ui_list = UISelectionList(
pygame.Rect(530, 30, 380, 220),
item_list=self.groups_list,
manager=ui_manager,
container=self,
object_id="#thicker_panel",
)
register_ui_callback(self.groups_ui_list,
pygame_gui.UI_SELECTION_LIST_NEW_SELECTION,
lambda e: self.on_group_list_item_select(e))
self.group_add_btn = UIButton(pygame.Rect(530, 250, 380 * 0.5, 30),
"Add Group",
ui_manager,
container=self)
self.group_remove_btn = UIButton(pygame.Rect(530 + 380 * 0.5, 250,
380 * 0.5, 30),
"Remove Group",
ui_manager,
container=self)
register_ui_callback(self.group_add_btn, pygame_gui.UI_BUTTON_PRESSED,
lambda e: self.on_group_add_btn_click())
register_ui_callback(self.group_remove_btn,
pygame_gui.UI_BUTTON_PRESSED,
lambda e: self.on_group_remove_btn_click())
UILabel(pygame.Rect(530, 290, 120, 30),
"Group Settings",
ui_manager,
container=self)
group_settings_panel = UIPanel(pygame.Rect(530, 320, 380, 210),
starting_layer_height=4,
object_id="#thicker_panel",
manager=ui_manager,
container=self)
UILabel(pygame.Rect(5, 10, 100, 30),
"Spawn After",
ui_manager,
container=group_settings_panel)
self.group_spawn_mode_dropdown = UIDropDownMenu(
["End Of Previous Group Spawn", "Previous Group Destruction"],
"End Of Previous Group Spawn",
pygame.Rect(105, 15, 250, 20),
ui_manager,
container=group_settings_panel)
# spawn delay
UILabel(pygame.Rect(5, 45, 100, 30),
"Spawn Delay",
ui_manager,
container=group_settings_panel)
self.spawn_delay_entry_line = UITextEntryLine(
pygame.Rect(105, 45, 40, 20),
manager=ui_manager,
container=group_settings_panel)
UILabel(pygame.Rect(150, 45, 60, 30),
"seconds",
ui_manager,
container=group_settings_panel)
register_ui_callback(self.spawn_delay_entry_line,
pygame_gui.UI_TEXT_ENTRY_CHANGED,
lambda e: self.on_group_spawn_delay_changed(e))
# interval
UILabel(pygame.Rect(-2, 80, 100, 30),
"Interval:",
ui_manager,
container=group_settings_panel)
UILabel(pygame.Rect(2, 115, 50, 30),
"From",
ui_manager,
container=group_settings_panel)
self.interval_from_entry_line = UITextEntryLine(
pygame.Rect(50, 115, 40, 20),
manager=ui_manager,
container=group_settings_panel)
UILabel(pygame.Rect(95, 115, 20, 30),
"To",
ui_manager,
container=group_settings_panel)
self.interval_to_entry_line = UITextEntryLine(
pygame.Rect(120, 115, 40, 20),
manager=ui_manager,
container=group_settings_panel)
UILabel(pygame.Rect(165, 115, 60, 30),
"seconds",
ui_manager,
container=group_settings_panel)
register_ui_callback(
self.interval_from_entry_line, pygame_gui.UI_TEXT_ENTRY_CHANGED,
lambda e: self.on_group_spawn_interval_left_changed(e))
register_ui_callback(
self.interval_to_entry_line, pygame_gui.UI_TEXT_ENTRY_CHANGED,
lambda e: self.on_group_spawn_interval_right_changed(e))
# ---------------------------- enemies
self.enemies_label = UILabel(pygame.Rect(910, 0, 80, 30),
"Enemies",
ui_manager,
container=self)
self.enemies_view_panel = UIPanel(relative_rect=pygame.Rect(
920, 30, 385, 505),
starting_layer_height=4,
object_id="#thicker_panel",
manager=ui_manager,
container=self)
#self.enemies_view_panel.hide()
#self.enemies_label.hide()
#250, 600 - 100
self.enemy_container = UIScrollingContainer(
pygame.Rect(0, 0, 380, 500),
ui_manager,
container=self.enemies_view_panel,
object_id="#enemy_scrolling_container",
starting_height=4)
item_height = 165
self.enemy_container.set_scrollable_area_dimensions(
(360, 5 + len(enemy.enemies_definitions) * item_height + 10))
"""
for n in range(0, 24):
UIButton(
pygame.Rect(5, 5 + 50 * n, 370, 45),
"hi",
ui_manager,
self.enemy_container
)
"""
self.enemies_counts_entry_lines = []
for n in range(0, len(enemy.enemies_definitions)):
enemy_panel = UIPanel(relative_rect=pygame.Rect(
5, 5 + item_height * n, 350, item_height),
starting_layer_height=4,
manager=ui_manager,
container=self.enemy_container,
object_id="#thicker_panel")
enemy_stats_panel = UIPanel(relative_rect=pygame.Rect(
10, 35, 325, 80),
starting_layer_height=4,
manager=ui_manager,
container=enemy_panel)
UITextBox(
"<b>" + enemy.enemies_definitions[n].name + "</b>",
pygame.Rect(5, 5, 340, 30),
ui_manager,
container=enemy_panel,
object_id="#no_border_textbox",
)
definition = enemy.enemies_definitions[n]
preview_sprite_path = ENEMIES_PATH + definition.sprites_directory + "/" + definition.preview_sprite + ".png"
image_size = (720 * 0.15, 480 * 0.15)
UIImage(relative_rect=pygame.Rect(5, 5, image_size[0],
image_size[1]),
image_surface=resource_cache.get_resource(
preview_sprite_path,
resource_cache.SurfaceType,
alpha=True),
manager=ui_manager,
container=enemy_stats_panel)
UITextBox("<font color=#00FF00><b>Health: </b></font>" +
str(definition.health) + "<br><br>"
"<font color=#BB0000><b>Damage: </b></font>" +
str(definition.damages) + "</br></br>" +
"<font color=#4488FF><b>Speed: </b></font>" +
str(definition.speed),
pygame.Rect(5 + image_size[0] + 5, 5, 120, 140),
ui_manager,
container=enemy_stats_panel,
object_id="#no_border_textbox")
UITextBox("Count: ",
pygame.Rect(5, item_height - 45, 80, 30),
ui_manager,
container=enemy_panel,
object_id="#no_border_textbox")
self.enemies_counts_entry_lines.append(
UITextEntryLine(
pygame.Rect(65, item_height - 45, 50, 25),
manager=ui_manager,
container=enemy_panel,
))
register_ui_callback(
self.enemies_counts_entry_lines[n],
pygame_gui.UI_TEXT_ENTRY_CHANGED,
lambda e, i=n: self.on_change_enemy_count(e, i))
self.set_blocking(True)
self.update_settings()
def update_falls_list(self):
self.falls_list = []
for i in range(0, len(map_settings.settings.falls)):
self.falls_list.append("Fall " + str(i + 1))
self.falls_ui_list.set_item_list(self.falls_list)
if len(self.falls_list) > 0:
# self.falls_ui_list.item_list[self.current_selected_fall]['selected'] = True
curr_fall = map_settings.settings.falls[self.current_selected_fall]
self.fall_gold_reward.set_text(str(curr_fall.gold_reward))
def update_groups_list(self):
if len(self.falls_list) > 0:
curr_fall = map_settings.settings.falls[self.current_selected_fall]
# there is always at least 1 group per fall
self.groups_list = []
for i in range(0, len(curr_fall.groups)):
self.groups_list.append("Group " + str(i + 1))
self.groups_ui_list.set_item_list(self.groups_list)
def update_group_panel(self):
curr_fall = map_settings.settings.falls[self.current_selected_fall]
if len(self.falls_list) > 0 and len(curr_fall.groups) > 0:
curr_group = curr_fall.groups[self.current_selected_group]
self.group_spawn_mode_dropdown.selected_option = curr_group.spawn_mode
self.spawn_delay_entry_line.set_text(str(curr_group.spawn_delay))
self.interval_from_entry_line.set_text(str(curr_group.interval[0]))
self.interval_to_entry_line.set_text(str(curr_group.interval[1]))
def update_fall_panel(self):
self.fall_gold_reward.set_text(
str(map_settings.settings.falls[
self.current_selected_fall].gold_reward))
def update_general_panel(self):
self.start_gold_text_line.set_text(
str(map_settings.settings.start_gold))
self.start_mana_text_line.set_text(
str(map_settings.settings.start_mana))
self.max_tower_text_line.set_text(str(map_settings.settings.max_tower))
self.max_spell_text_line.set_text(str(map_settings.settings.max_spell))
def update_enemies_panel(self):
curr_group = map_settings.settings.falls[
self.current_selected_fall].groups[self.current_selected_group]
for n in range(0, len(self.enemies_counts_entry_lines)):
self.enemies_counts_entry_lines[n].set_text(
str(curr_group.enemies_counts[n]))
def update_settings(self):
self.update_general_panel()
self.update_falls_list()
self.update_groups_list()
