def __init__(self, num_shots, success_first, success_remain, overheat):
QWidget.__init__(self)
self.setWindowTitle(translate("ui_outcome_widget_name"))
layout = QVBoxLayout()
values_layout = QVBoxLayout()
ok_button_layout = QVBoxLayout()
layout.addLayout(values_layout)
layout.addLayout(ok_button_layout)
shots = "{}: {}".format(translate("ui_num_shots_fired"), num_shots)
label = QLabel(shots)
values_layout.addWidget(label)
success_first_shot = "{}: {}".format(
translate("ui_num_successes_first"), success_first)
label_hit_1 = QLabel(success_first_shot)
values_layout.addWidget(label_hit_1)
if num_shots > 1:
success_remaining_shots = "{}: {}".format(
translate("ui_num_successes_remaining"), success_remain)
label_hit_rem = QLabel(success_remaining_shots)
values_layout.addWidget(label_hit_rem)
if overheat:
overheat = "{}: {}".format(translate("ui_overheated_on"), overheat)
label_overheat = QLabel(overheat)
values_layout.addWidget(label_overheat)
ok_button = QPushButton("OK")
ok_button_layout.addWidget(ok_button)
ok_button.clicked.connect(self.close_popup)
self.setLayout(layout)
self.show()
def __init__(self, parent):
super(QWidget, self).__init__(parent)
p = self.palette()
p.setColor(self.backgroundRole(), Qt.white)
self.setPalette(p)
self.setAutoFillBackground(True)
# Create character sheet layout
self.main_layout = QHBoxLayout(self)
self.main_sheet_layout = QVBoxLayout()
self.main_layout.addLayout(self.main_sheet_layout, 6)
# self.actions_panel_layout = QVBoxLayout()
# self.main_layout.addLayout(self.actions_panel_layout, 1)
# self.actions_panel_layout.setSizeConstraint(3)
# self.character = None
self.tabs = QTabWidget()
self.main_sheet_layout.addWidget(self.tabs, 9)
# Define target field holders
self.params_dict = {}
self.skills_dict = {}
self.attribute_dict = {}
self.scrolls = {}
self.notes_dict = {}
self.equipment_tables = None
self.tab1 = QWidget()
self.tab2 = QWidget()
self.tab3 = QWidget()
self.tabs.addTab(self.tab1, translate("ui_character_tab"))
self.tabs.addTab(self.tab2, translate("ui_equipment_tab"))
self.tabs.addTab(self.tab3, translate("ui_misc_tab"))
def __init__(self, armor):
View.__init__(self)
self.name = armor.ID
self.item = armor
layout = QVBoxLayout()
line1_layout = QHBoxLayout()
line1_layout.setContentsMargins(0, 0, 0, 0)
p = self.palette()
p.setColor(self.backgroundRole(), QColor(240, 240, 240))
self.setPalette(p)
self.setAutoFillBackground(True)
self.equipped_checkbox = EquippedCheckbox()
self.equipped_checkbox.setChecked(self.item.equipped_quantity > 0)
self.equipped_checkbox.stateChanged.connect(self.equip)
line1_layout.addWidget(self.equipped_checkbox)
self.armor_name = LabelledLabel(label=translate("ui_item_name"))
self.armor_name.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
line1_layout.addWidget(self.armor_name)
self.armor_parts = {}
for armor_name in armor_names:
armor_piece = LabelledLabel(label=translate(armor_name))
self.armor_parts[armor_name] = armor_piece
line1_layout.addWidget(armor_piece)
self.weight = LabelledLabel(label=translate("ui_item_weight"))
line1_layout.addWidget(self.weight)
self.value = LabelledLabel(label=translate("ui_item_price"))
line1_layout.addWidget(self.value)
layout.addLayout(line1_layout)
self.add_header_option("Edit", self.edit)
layout.setContentsMargins(0, 0, 0, 0)
self.fill_values()
self.setLayout(layout)
def __init__(self, name, button_text, content_widget, popup=None, label=None, **kwargs):
QWidget.__init__(self)
# self.parent = parent
self.name = name
self.kwargs = kwargs
self.layout = QVBoxLayout()
self.label = QLabel(translate(name))
if label is not None:
self.label = QLabel(translate(label))
self.label.setStyleSheet("font: bold 14px")
self.layout.addWidget(self.label)
self.scroll = QScrollArea()
self.scroll.setWidgetResizable(True)
self.layout.addWidget(self.scroll)
if button_text is not None:
self.button = QPushButton(button_text)
self.button.clicked.connect(lambda: self.open_popup())
self.layout.addWidget(self.button)
self.setLayout(self.layout)
self.popup = popup
self.current_popup = None
self.content_widget = content_widget
self.scroll_widget = QWidget()
self.scroll_layout = QVBoxLayout()
self.scroll_widget.setLayout(self.scroll_layout)
self.scroll_layout.setContentsMargins(0, 0, 0, 0)
self.scroll.setWidget(self.scroll_widget)
self.scroll_layout.addSpacerItem(QSpacerItem(20, 20, QSizePolicy.Minimum, QSizePolicy.Expanding))
def fill_values(self):
self.weapon_name.set_text(translate(self.item.display) if self.item.display else self.item.name)
self.weapon_damage.set_text(str(self.item.damage))
self.weapon_damage_type.set_text(self.item.damage_type)
self.weapon_pp.set_text(str(self.item.ap))
if is_type(self.item, "ranged_weapon"):
self.weapon_ammo_cost.set_text(str(self.item.shot_cost))
self.weapon_current_power.link_value(self.item.power_magazine)
self.weapon_value.set_text(str(self.item.price))
self.weapon_weight.set_text(str(self.item.weight))
self.equipped_checkbox.setChecked(self.item.equipped_quantity > 0)
self.weapon_type.set_text(translate(self.item.weapon_type))
def __init__(self, weapon):
View.__init__(self)
self.item = weapon
self.name = weapon.ID
p = self.palette()
p.setColor(self.backgroundRole(), QColor(240, 240, 240))
self.setPalette(p)
self.setAutoFillBackground(True)
layout = QVBoxLayout()
layout.setSpacing(1)
line1_layout = QHBoxLayout()
line1_layout.setSpacing(4)
line2_layout = QHBoxLayout()
line1_layout.setSpacing(4)
self.equipped_checkbox = EquippedCheckbox()
self.equipped_checkbox.setChecked(self.item.equipped_quantity > 0)
self.equipped_checkbox.stateChanged.connect(self.equip)
line1_layout.addWidget(self.equipped_checkbox)
self.weapon_name = LabelledLabel(label=translate("ui_item_name"))
# self.weapon_name.setFixedWidth(120
self.weapon_name.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
line1_layout.addWidget(self.weapon_name, stretch=0)
self.weapon_type = LabelledLabel(label=translate("ui_weapon_type"), align_flag=Qt.AlignCenter)
line1_layout.addWidget(self.weapon_type, stretch=0)
self.weapon_damage = LabelledLabel(label=translate("ui_weapon_damage"), align_flag=Qt.AlignCenter)
line1_layout.addWidget(self.weapon_damage, stretch=0)
self.weapon_pp = LabelledLabel(label=translate("ui_weapon_ap"), align_flag=Qt.AlignCenter)
line1_layout.addWidget(self.weapon_pp, stretch=0)
self.weapon_damage_type = LabelledLabel(label=translate("ui_weapon_damage_type"), align_flag=Qt.AlignCenter)
line1_layout.addWidget(self.weapon_damage_type, stretch=0)
if is_type(self.item, "ranged_weapon"):
self.weapon_ammo_cost = LabelledLabel(label=translate("ui_weapon_shotcost"), align_flag=Qt.AlignCenter)
line1_layout.addWidget(self.weapon_ammo_cost, stretch=0)
self.weapon_current_power = InputLine(name="power_magazine", label=translate("ui_weapon_magazine"),
dtype="int", maxwidth=60, align_flag=Qt.AlignCenter)
line1_layout.addWidget(self.weapon_current_power, stretch=0)
self.weapon_current_power.value_changed.connect(self.modify_item)
self.weapon_weight = LabelledLabel(label=translate("ui_item_weight"), align_flag=Qt.AlignCenter)
line2_layout.addWidget(self.weapon_weight, stretch=0)
self.weapon_value = LabelledLabel(label=translate("ui_item_price"), align_flag=Qt.AlignCenter)
line2_layout.addWidget(self.weapon_value, stretch=0)
self.weapon_traits = LabelledLabel(label=translate("ui_item_traits")) # TODO!
self.weapon_traits.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
line2_layout.addWidget(self.weapon_traits, stretch=0)
layout.addLayout(line1_layout, stretch=0)
layout.addLayout(line2_layout, stretch=0)
# layout.addSpacerItem(QSpacerItem(20, 20, QSizePolicy.Minimum, QSizePolicy.Expanding))
layout.setContentsMargins(1, 1, 1, 1)
self.fill_values()
self.add_header_option("Edit", self.edit)
self.setLayout(layout)
def __init__(self, popup=None, transfer_popup=None):
QWidget.__init__(self)
layout = QVBoxLayout()
self.popup = popup
self.items = None
self.current_popup = None
self.transfer_popup = transfer_popup
self.equipped_table = ItemTable(equipped=True)
self.equipped_table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.equipped_table.item_qty_changed.connect(self.signal_forward)
self.equipped_table.delete_item.connect(self.signal_delete)
self.equipped_table.edit_item.connect(self.item_edit)
equipped_table_layout = QVBoxLayout()
label = QLabel(translate("ui_equipped_items"))
label.setStyleSheet("font: bold 12px")
label.setAlignment(Qt.AlignCenter)
equipped_table_layout.addWidget(label)
equipped_table_layout.addWidget(self.equipped_table)
self.stash_table = ItemTable(equipped=False)
self.stash_table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.stash_table.item_qty_changed.connect(self.signal_forward)
self.stash_table.delete_item.connect(self.signal_delete)
self.stash_table.edit_item.connect(self.item_edit)
stash_table_layout = QVBoxLayout()
label = QLabel(translate("ui_stashed_items"))
label.setStyleSheet("font: bold 12px")
label.setAlignment(Qt.AlignCenter)
stash_table_layout.addWidget(label)
stash_table_layout.addWidget(self.stash_table)
button_left = QToolButton()
button_left.setArrowType(Qt.UpArrow)
button_left.clicked.connect(lambda: self.open_transfer_popup(True))
button_left.setFixedWidth(40)
button_right = QToolButton()
button_right.setArrowType(Qt.DownArrow)
button_right.clicked.connect(lambda: self.open_transfer_popup(False))
button_right.setFixedWidth(40)
button_add = QPushButton(translate("ui_add_item_button"))
button_add.clicked.connect(self.open_popup)
button_add.setFixedWidth(60)
buttons_layout = QHBoxLayout()
# buttons_layout.addSpacerItem(QSpacerItem(20, 20, QSizePolicy.Minimum, QSizePolicy.Expanding))
buttons_layout.addWidget(button_left)
buttons_layout.addWidget(button_add)
buttons_layout.addWidget(button_right)
# buttons_layout.addSpacerItem(QSpacerItem(20, 20, QSizePolicy.Minimum, QSizePolicy.Expanding))
layout.addLayout(equipped_table_layout, 10)
layout.addLayout(buttons_layout, 1)
layout.addLayout(stash_table_layout, 10)
self.setLayout(layout)
def __init__(self, equipped=True):
QWidget.__init__(self)
self.equipped = equipped
self.table = QTableWidget(self)
self.table.setMinimumWidth(500)
self.table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.get_table()
self.menu = QMenu(self)
self.menu_actions = {translate("remove_item"): self.remove_item}
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.menu.addAction(QAction(translate("remove_item"), self))
self.customContextMenuRequested.connect(self.show_header_menu)
self.item = None
self.add_header_option(translate("edit_item"), self.item_edit)
def __init__(self):
super().__init__()
self.title = translate("ui_window_name")
self.setWindowTitle(self.title)
self.current_file_path = None
self.popup = None
# Add menu bar
bar = self.menuBar()
file = bar.addMenu(translate("ui_menu_file"))
new_sheet = QAction(translate("ui_new_sheet"), self)
new_sheet.setShortcut("Ctrl+N")
file.addAction(new_sheet)
open_file = QAction(translate("ui_menu_load_sheet"), self)
open_file.setShortcut("Ctrl+O")
file.addAction(open_file)
save = QAction(translate("ui_menu_save_sheet"), self)
save.setShortcut("Ctrl+S")
file.addAction(save)
file.addSeparator()
calc = QAction(translate("ui_menu_open_calculator"), self)
calc.setShortcut("Ctrl+K")
file.addAction(calc)
file.addSeparator()
save_as = QAction(translate("ui_menu_save_sheet_as"), self)
save_as.setShortcut("Ctrl+Shift+S")
file.addAction(save_as)
exit_action = QAction(translate("ui_menu_quit"), self)
file.addAction(exit_action)
file.triggered[QAction].connect(self.process_trigger)
# Add main widget
self.window_widget = None
self.show()
def __init__(self, bonuses):
QWidget.__init__(self)
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
# bonuses
if bonuses:
self.label = QLabel(translate(bonuses[0].name))
self.value = QLabel(str([bonuses[0].value]))
self.cont = QLabel("...")
layout.addWidget(self.label)
layout.addWidget(self.value)
if len(bonuses) > 1:
layout.addWidget(self.cont)
self.setToolTip("\n".join([translate(bonus.name)+": "+str(bonus.value) for bonus in bonuses]))
self.setLayout(layout)
def fill_tab3(self, notes_names):
page3 = QVBoxLayout()
for name in notes_names:
field = LabelledTextEdit(name, label=translate("ui_{}".format(name)))
self.notes_dict[name] = field
page3.addWidget(field)
self.tab3.setLayout(page3)
def fill_table(self, data):
data = sorted([item for item in data if item.type == "item"], key=lambda x: translate(x.display))
data_len = len([item for item in data if item.equipped_quantity > 0]) if self.equipped else \
len([item for item in data if (item.total_quantity != item.equipped_quantity) or item.total_quantity == 0])
self.table.setRowCount(data_len)
index = 0
for item in data:
value = item.equipped_quantity if self.equipped else item.total_quantity - item.equipped_quantity
if self.equipped and value == 0:
continue
if not self.equipped and value == 0 and item.total_quantity != 0:
continue
self.table.setCellWidget(index, 0, QLabel(item.ID))
counter_widget = ItemCounter(item.ID)
counter_widget.set_value(str(value))
counter_widget.value_changed.connect(self.item_changed)
self.table.setCellWidget(index, 1, counter_widget)
name_label = QLabel(item.name)
name_label.setAlignment(Qt.AlignCenter)
name_label.setToolTip(item.description)
self.table.setCellWidget(index, 2, name_label)
weight_label = QLabel(str(item.weight))
weight_label.setAlignment(Qt.AlignCenter)
self.table.setCellWidget(index, 3, weight_label)
total_weight_label = QLabel("{:.1f}".format(float(item.weight) * value))
total_weight_label.setAlignment(Qt.AlignCenter)
self.table.setCellWidget(index, 4, total_weight_label)
index += 1
self.table.resizeRowsToContents()
self.table.show()
def __init__(self, equipment_item):
View.__init__(self)
layout = QHBoxLayout()
layout.setContentsMargins(5, 1, 1, 1)
self.item = equipment_item
self.name = equipment_item.ID
name_layout = QVBoxLayout()
name = QLabel(translate(equipment_item.name))
name_layout.addWidget(name)
self.values_layout = QVBoxLayout()
cost_layout = QVBoxLayout()
cost = QLabel("TODO COST") # TODO
cost_layout.addWidget(cost)
layout.addLayout(name_layout)
layout.addSpacerItem(QSpacerItem(10, 10, QSizePolicy.Expanding, QSizePolicy.Minimum))
layout.addLayout(self.values_layout)
layout.addLayout(cost_layout)
checkbox_layout = QVBoxLayout()
self.equipped_checkbox = QCheckBox()
self.equipped_checkbox.setChecked(self.item.equipped_quantity > 0)
self.equipped_checkbox.stateChanged.connect(lambda x: self.update_parameters("equipped", x))
checkbox_layout.addWidget(self.equipped_checkbox)
layout.addLayout(checkbox_layout)
self.setLayout(layout)
view = PropertyView(self.item.bonuses)
self.values_layout.addWidget(view)
# for bonus in :
#
self.add_header_option("Edit", self.edit)
self.setLayout(layout)
def __init__(self, ability):
View.__init__(self)
self.item = ability
self.name = ability.name
layout = QVBoxLayout()
self.display_name = translate(ability.name) # TODO
self.description = translate(ability.description)
self.setToolTip(translate(ability.description))
self.display = QLineEdit()
layout.addWidget(self.display)
self.display_name += " {}".format(ability.value) \
if not is_types(ability, ["ability", "trait", "fire_mode"]) else ""
self.display.setText(self.display_name)
self.display.setEnabled(False)
self.setLayout(layout)
self.layout().setContentsMargins(0, 0, 0, 0)
def get_table(self):
self.table.setColumnCount(5)
self.table.setSelectionBehavior(1)
self.table.setHorizontalScrollBarPolicy(1)
self.table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.table.setColumnHidden(0, True)
self.table.verticalHeader().setVisible(False)
self.table.setHorizontalHeaderLabels([translate("ui_item_name"), translate("ui_item_quantity"),
translate("ui_item_name"),
translate("ui_item_weight"),
translate("ui_item_total_weight")])
header = self.table.horizontalHeader()
header.setSectionResizeMode(0, QHeaderView.ResizeToContents)
header.setSectionResizeMode(1, QHeaderView.ResizeToContents)
header.setSectionResizeMode(2, QHeaderView.Stretch)
header.setSectionResizeMode(3, QHeaderView.ResizeToContents)
header.setSectionResizeMode(4, QHeaderView.ResizeToContents)
def open_file_name_dialog(self, pop_type):
self.popup = QFileDialog()
options = QFileDialog.Options()
filepath = ""
if pop_type == "open":
filepath = self.popup.getOpenFileName(self, translate("ui_load_sheet_window_title"), os.getcwd(),
"Character files (*.cht)", options=options)
if pop_type == "save":
filepath = self.popup.getSaveFileName(self, translate("ui_save_sheet_window_title"), os.getcwd(),
"Character files (*.cht)", options=options)
self.popup = None
if not filepath[0]:
return
self.current_file_path = filepath[0]
self.directory_signal.emit(filepath[0], pop_type)
def fill_armor(self, armor_names, alternative=False):
inner_armor_layout = QVBoxLayout()
head = QHBoxLayout()
# head.setContentsMargins(0, 0, 0, 0)
arms = QHBoxLayout()
# arms.setContentsMargins(0, 0, 0, 0)
legs = QHBoxLayout()
# legs.setContentsMargins(0, 0, 0, 0)
life = QHBoxLayout()
# life.setContentsMargins(0, 0, 0, 0)
label_layout = QHBoxLayout()
label = QLabel(translate("ui_armor"))
label.setStyleSheet("font: bold 14px")
# label.setContentsMargins(0, 0, 0, 0)
label.setAlignment(Qt.AlignCenter)
label_layout.addWidget(label)
# label_layout.setContentsMargins(0, 0, 0, 0)
inner_armor_layout.addLayout(label_layout)
inner_armor_layout.setSpacing(0)
inner_armor_layout.addLayout(head, 1)
inner_armor_layout.addLayout(arms, 2)
inner_armor_layout.addLayout(legs, 1)
inner_armor_layout.addLayout(life, 1)
total_hp = InputLine("param_hp_max", val_dict=self.params_dict,
label=translate("param_hp_max"), maxwidth=35, spacer="upper")
current_hp = InputLine("param_hp_current", val_dict=self.params_dict,
label=translate("param_hp_current"), maxwidth=35, spacer="upper")
total_pp = InputLine("param_pp_total", val_dict=self.params_dict,
label=translate("param_pp_total"), maxwidth=35, spacer="upper")
current_pp = InputLine("param_pp_curr", val_dict=self.params_dict,
label=translate("param_pp_curr"), maxwidth=35, spacer="upper")
fatigue = InputLine("param_fatigue", val_dict=self.params_dict,
label=translate("param_fatigue") if not alternative else translate("param_battery"),
maxwidth=35, spacer="upper")
life.addWidget(total_hp)
life.addWidget(current_hp)
life.addWidget(total_pp)
life.addWidget(current_pp)
life.addWidget(fatigue)
for index, name in enumerate(armor_names):
na = InputLine(name=name, val_dict=self.params_dict, enabled=False,
label=translate(name), maxwidth=30, spacer="lower")
na.setContentsMargins(0, 0, 0, 0)
if index < 1:
head.addWidget(na)
elif index < 4:
arms.addWidget(na)
else:
legs.addWidget(na)
inner_armor_layout.setContentsMargins(0, 0, 0, 0)
return inner_armor_layout
def fill_names(self, character_names):
inner_names_layout = QHBoxLayout()
layout_1 = QVBoxLayout()
layout_2 = QVBoxLayout()
layout_3 = QVBoxLayout()
inner_names_layout.addLayout(layout_1, 2)
inner_names_layout.addLayout(layout_2, 4)
inner_names_layout.addLayout(layout_3, 1)
for index, name in enumerate(character_names):
na = NameView(name=name, display_name=translate(name), val_dict=self.params_dict)
if index < 3:
layout_1.addWidget(na)
else:
layout_2.addWidget(na)
total_xp = InputLine("param_xp_total", dtype="int", val_dict=self.params_dict,
label=translate("param_xp_total"), maxwidth=60)
free_xp = InputLine("param_xp_free", dtype="int", val_dict=self.params_dict,
label=translate("param_xp_free"), maxwidth=60)
layout_3.addWidget(total_xp)
layout_3.addWidget(free_xp)
return inner_names_layout
def fill_skills(self, skill_names, alternative):
skills1_layout = QVBoxLayout()
skills2_layout = QVBoxLayout()
label = QLabel(translate("ui_skills"))
label.setStyleSheet("font: bold 14px")
skills1_layout.addWidget(label)
skills1_layout.setSpacing(1)
label = QLabel(" ")
label.setStyleSheet("font: bold 14px")
skills2_layout.addWidget(label)
skills2_layout.setSpacing(1)
max_per_column = 15 if alternative else 25
skill_names = sorted(skill_names, key=lambda x: translate(x))
for index, skill in enumerate(skill_names):
ski = SkillView(name=skill, display_name=translate(skill),
val_dict=self.skills_dict, alternative=alternative)
if index < max_per_column:
skills1_layout.addWidget(ski)
else:
skills2_layout.addWidget(ski, stretch=0)
skills1_layout.addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Minimum, QSizePolicy.Expanding))
skills2_layout.addSpacerItem(QSpacerItem(1, 1, QSizePolicy.Minimum, QSizePolicy.Expanding))
return skills1_layout, skills2_layout
def update_size(self, warmup=False):
sizes = [-20, -10, 0, 10, 30, 50]
size_names = [
translate(a) for a in [
"param_size_tiny", "param_size_small", "param_size_normal",
"param_size_large", "param_size_giant", "param_size_enormous"
]
]
slider_value = self.size_slider.value()
self.size_name.setText(size_names[slider_value])
self.size_modifier.setText(
(str(sizes[slider_value]) if sizes[slider_value] <= 0 else "+" +
str(sizes[slider_value])))
if not warmup:
self.update_chance()
def __init__(self):
QWidget.__init__(self)
self.layout = QVBoxLayout()
self.label = QLabel(translate("ui_item_equipped"))
self.label.setStyleSheet("font: 8px")
self.label.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.label)
self.layout.setSpacing(0)
self.checkbox = QCheckBox()
self.checkbox.setContentsMargins(0, 0, 0, 0)
self.layout.addWidget(self.checkbox)
# self.layout.addItem(QSpacerItem(10, 10, QSizePolicy.Minimum, QSizePolicy.Expanding))
self.layout.setContentsMargins(0, 0, 0, 0)
self.checkbox.stateChanged.connect(lambda: self.stateChanged.emit(self.checkbox.isChecked()))
self.setLayout(self.layout)
def update_distances(self, warmup=False):
slider_value = self.distance_slider.value()
if slider_value % 10 != 0:
slider_value = round(slider_value / 10) * 10
self.distance_slider.setValue(slider_value)
index = modifier_ranges.index(slider_value)
self.current_distance.setText(distances[index])
self.current_distance_mod.setText(
(str(slider_value) if slider_value <= 0 else "+" +
str(slider_value)))
distance_type = [
key for key in distance_types
if distances[index] in distance_types[key]
][0]
self.current_distance_type.setText(translate(distance_type))
self.icon.update_to_size(int(150 / (len(distances) - index)))
if not warmup:
self.update_chance()
def fill_tab1(self, character_names, attribute_names, skill_names, armor_names, validator, alternative=False):
page1 = QVBoxLayout()
self.tab1.setLayout(page1)
# Parameters layout
names_layout = QHBoxLayout()
page1.addLayout(names_layout)
attributes_layout = QHBoxLayout()
attributes_layout.setContentsMargins(0, 0, 0, 0)
page1.addLayout(attributes_layout)
parameters_layout = self.fill_parameters()
page1.addLayout(parameters_layout)
character_layout = QHBoxLayout()
page1.addLayout(character_layout)
# page1.addSpacerItem(QSpacerItem(40, 200, QSizePolicy.Minimum, QSizePolicy.Expanding))
column2_layout = QVBoxLayout()
skills_hitbox_layout = QHBoxLayout()
skills1_layout, skills2_layout = self.fill_skills(skill_names, alternative=alternative)
character_layout.addLayout(skills1_layout)
skills_hitbox_layout.addLayout(skills2_layout)
character_layout.addLayout(column2_layout)
column2_layout.addLayout(skills_hitbox_layout)
abilities_layout = QVBoxLayout()
column2_layout.addLayout(abilities_layout)
names_inner_layout = self.fill_names(character_names)
inner_armor_layout = self.fill_armor(armor_names, alternative)
names_layout.addLayout(names_inner_layout)
hitbox_widget = QWidget()
hitbox_widget.setMinimumWidth(250)
# hitbox_widget.setMinimumHeight(450)
skills_hitbox_layout.addWidget(hitbox_widget)
hitbox_widget.setLayout(inner_armor_layout)
# Set Attributes
self.fill_attributes(attributes_layout, attribute_names, alternative)
# Set skills
abilities = ScrollContainer("ui_abilities", translate("ui_ability_add_button"), AbilityView,
validator=validator, alternative=alternative, popup=AbilityPopup)
self.scrolls["abilities"] = abilities
abilities_layout.addWidget(abilities)
current_weapon_layout = QVBoxLayout()
self.current_weapon_widget = ActiveWeaponView()
current_weapon_layout.addWidget(self.current_weapon_widget)
page1.addLayout(current_weapon_layout)
def __init__(self):
QWidget.__init__(self)
layout = QHBoxLayout()
button_left_layout = QVBoxLayout()
weapon_layout = QVBoxLayout()
button_right_layout = QVBoxLayout()
layout.addLayout(button_left_layout)
layout.addLayout(weapon_layout)
layout.addLayout(button_right_layout)
self.setLayout(layout)
button_left = QToolButton()
button_left.setArrowType(Qt.LeftArrow)
button_left.clicked.connect(lambda: self.emit_swap(-1))
button_left_layout.addWidget(button_left)
button_right = QToolButton()
button_right.setArrowType(Qt.RightArrow)
button_right.clicked.connect(lambda: self.emit_swap(1))
button_right_layout.addWidget(button_right)
weapon_line1 = QHBoxLayout()
weapon_line2 = QHBoxLayout()
weapon_layout.addLayout(weapon_line1)
weapon_layout.addLayout(weapon_line2)
self.weapon = None
self.weapon_name = LabelledLabel("", align_flag=Qt.AlignCenter, label=translate("ui_item_name"))
self.weapon_damage = LabelledLabel("", align_flag=Qt.AlignCenter, label=translate("damage"))
self.weapon_ap = LabelledLabel("", align_flag=Qt.AlignCenter, label=translate("ap"))
self.weapon_damage_type = LabelledLabel("", align_flag=Qt.AlignCenter, label=translate("damage_type"))
weapon_line1.addWidget(self.weapon_name)
weapon_line1.addWidget(self.weapon_damage)
weapon_line1.addWidget(self.weapon_ap)
weapon_line1.addWidget(self.weapon_damage_type)
self.traits = LabelledLabel("", align_flag=Qt.AlignCenter, label=translate("name"))
self.shoot_button = QPushButton(translate("shoot"))
self.shoot_button.clicked.connect(self.emit_shoot)
self.reload_button = QPushButton(translate("reload"))
self.reload_button.clicked.connect(self.reload)
weapon_line2.addWidget(self.traits, stretch=4)
weapon_line2.addWidget(self.shoot_button, stretch=1)
weapon_line2.addWidget(self.reload_button, stretch=1)
self.update_fields()
def process_trigger(self, q):
if q.text() == translate("ui_menu_load_sheet"):
self.open_file_name_dialog("open")
if q.text() == translate("ui_menu_save_sheet"):
if self.current_file_path is None:
self.open_file_name_dialog("save")
else:
self.directory_signal.emit(self.current_file_path, "save")
if q.text() == translate("ui_menu_save_sheet_as"):
self.open_file_name_dialog("save")
if q.text() == translate("ui_new_sheet"):
self.open_new_sheet_popup()
if q.text() == translate("ui_menu_quit"):
self.exit.emit()
if q.text() == translate("ui_menu_open_calculator"):
self.open_calculator()
def __init__(self, parent=None, character=None, weapon=None):
QWidget.__init__(self)
self.setWindowTitle(translate("ui_shooting_app"))
if parent is not None:
self.setParent(parent)
self.popup = None
window_layout = QVBoxLayout()
main_layout = QHBoxLayout()
buttons_layout = QHBoxLayout()
window_layout.addLayout(main_layout)
window_layout.addLayout(buttons_layout)
shoot_layout = QVBoxLayout()
cover_layout = QVBoxLayout()
main_layout.addLayout(shoot_layout)
main_layout.addLayout(cover_layout)
self.setLayout(window_layout)
parameters_layout = QHBoxLayout()
distance_view_layout = QVBoxLayout()
distance_slider_layout = QVBoxLayout()
shoot_layout.addLayout(parameters_layout)
shoot_layout.addLayout(distance_view_layout)
shoot_layout.addLayout(distance_slider_layout)
# Left side
# Params
self.skill_value = InputLine("skill",
enabled=True,
maxwidth=80,
dtype="int",
spacer="upper",
label=translate("ui_ranged_skill_value"))
self.skill_value.setText("0")
self.skill_value.value_changed.connect(lambda: self.update_distances())
self.gm_modifier = InputLine("gm_mod",
enabled=True,
dtype="int",
maxwidth=80,
spacer="upper",
label=translate("ui_gm_modifier"))
self.gm_modifier.setText("0")
self.gm_modifier.value_changed.connect(lambda: self.update_distances())
self.break_chance = InputLine("break_chance",
enabled=True,
dtype="int",
maxwidth=80,
spacer="upper",
label=translate("ui_break_chance"))
self.break_chance.setText("0")
self.break_increment = InputLine("break_increment",
enabled=True,
dtype="int",
spacer="upper",
maxwidth=80,
label=translate("ui_break_increment"))
self.break_increment.setText("0")
self.num_shots = InputLine("num_shots",
enabled=True,
dtype="int",
spacer="upper",
maxwidth=80,
label=translate("ui_num_shots"))
self.num_shots.setText("10")
if weapon is not None:
skill = weapon.base_skill
if character is not None:
print(skill)
skill_value = character.calculate_skill(skill)
skill_value = max(map(int, skill_value))
self.skill_value.setText(skill_value)
parameters_layout.addSpacerItem(
QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
parameters_layout.addWidget(self.skill_value)
parameters_layout.addWidget(self.gm_modifier)
parameters_layout.addWidget(self.break_chance)
parameters_layout.addWidget(self.break_increment)
parameters_layout.addWidget(self.num_shots)
parameters_layout.addSpacerItem(
QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
# Icon
internal_widget = QWidget()
internal_widget.setFixedHeight(300)
distance_view_internal_layout = QHBoxLayout()
internal_widget.setLayout(distance_view_internal_layout)
distance_view_internal_layout.addSpacerItem(
QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
self.icon = IconWidget(QPixmap(path.join("Images", "Silhouette.png")))
distance_view_internal_layout.addWidget(self.icon)
distance_view_internal_layout.addSpacerItem(
QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
distance_view_layout.addWidget(internal_widget)
# Slider
distance_values_layout = QHBoxLayout()
slider_layout = QVBoxLayout()
distance_slider_layout.addLayout(distance_values_layout)
distance_slider_layout.addLayout(slider_layout)
distance_values_layout.addSpacerItem(
QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
self.current_distance = InputLine("distance",
enabled=False,
label=translate("ui_distance_value"))
distance_values_layout.addWidget(self.current_distance)
self.current_distance_type = InputLine(
"distance_type",
enabled=False,
label=translate("ui_distance_type"))
distance_values_layout.addWidget(self.current_distance_type)
self.current_distance_mod = InputLine(
"distance_modifier",
enabled=False,
label=translate("ui_distance_modifier"))
distance_values_layout.addWidget(self.current_distance_mod)
distance_values_layout.addSpacerItem(
QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
self.distance_slider = QSlider(Qt.Horizontal)
self.distance_slider.setMinimum(-50)
self.distance_slider.setMaximum(40)
self.distance_slider.setTickPosition(QSlider.TicksBelow)
self.distance_slider.setTickInterval(10)
self.distance_slider.setSingleStep(10)
self.distance_slider.setValue(0)
self.distance_slider.valueChanged.connect(
lambda: self.update_distances())
slider_layout.addWidget(self.distance_slider)
# Right side
target_layout = QVBoxLayout()
size_slider_layout = QVBoxLayout()
target_layout.addLayout(size_slider_layout)
icon_layout = QVBoxLayout()
target_layout.addLayout(icon_layout)
cover_slider_layout = QVBoxLayout()
target_layout.addLayout(cover_slider_layout)
main_layout.addLayout(target_layout)
# Size slider
size_slider_values_layout = QHBoxLayout()
size_slider_slider_layout = QVBoxLayout()
size_slider_layout.addLayout(size_slider_values_layout)
size_slider_values_layout.addSpacerItem(
QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
self.size_name = InputLine("size_name",
label=translate("ui_size_name"),
enabled=False)
size_slider_values_layout.addWidget(self.size_name)
self.size_modifier = InputLine("size_modifier",
label=translate("ui_size_mod"),
enabled=False)
size_slider_values_layout.addWidget(self.size_modifier)
size_slider_values_layout.addSpacerItem(
QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
size_slider_layout.addLayout(size_slider_slider_layout)
self.size_slider = QSlider(Qt.Horizontal)
self.size_slider.setMinimum(0)
self.size_slider.setMaximum(5)
self.size_slider.setTickPosition(QSlider.TicksBelow)
self.size_slider.setTickInterval(1)
self.size_slider.setSingleStep(1)
self.size_slider.setValue(2)
self.size_slider.valueChanged.connect(lambda: self.update_size())
size_slider_slider_layout.addWidget(self.size_slider)
# Icon
cover_internal_widget = QWidget()
cover_internal_widget.setFixedHeight(300)
cover_view_internal_layout = QHBoxLayout()
cover_internal_widget.setLayout(cover_view_internal_layout)
cover_view_internal_layout.addSpacerItem(
QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
self.trooper_icon = CoverIconWidget(
QPixmap(path.join("Images", "Stormtrooper.png")))
cover_view_internal_layout.addWidget(self.trooper_icon)
cover_view_internal_layout.addSpacerItem(
QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
icon_layout.addWidget(cover_internal_widget)
# Cover slider
cover_slider_values_layout = QHBoxLayout()
cover_slider_slider_layout = QVBoxLayout()
cover_slider_layout.addLayout(cover_slider_values_layout)
cover_slider_values_layout.addSpacerItem(
QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
self.cover_name = InputLine("cover_name",
label=translate("ui_cover_name"),
enabled=False)
cover_slider_values_layout.addWidget(self.cover_name)
self.cover_modifier = InputLine("cover_modifier",
label=translate("ui_cover_mod"),
enabled=False)
cover_slider_values_layout.addWidget(self.cover_modifier)
cover_slider_values_layout.addSpacerItem(
QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
cover_slider_layout.addLayout(cover_slider_slider_layout)
self.cover_slider = QSlider(Qt.Horizontal)
self.cover_slider.setMinimum(0)
self.cover_slider.setMaximum(75)
self.cover_slider.setTickPosition(QSlider.TicksBelow)
self.cover_slider.setTickInterval(25)
self.cover_slider.setSingleStep(25)
self.cover_slider.setValue(0)
self.cover_slider.valueChanged.connect(lambda: self.update_cover())
cover_slider_slider_layout.addWidget(self.cover_slider)
# Buttons
self.current_hit_chance = InputLine("hit_chance",
enabled=False,
dtype="int",
label=translate("ui_hit_chance"))
shoot_one_button = QPushButton(translate("ui_shoot_once"))
shoot_one_button.clicked.connect(self.shoot_one)
shoot_series_button = QPushButton(translate("ui_shoot_series"))
shoot_series_button.clicked.connect(self.shoot_series)
cancel_button = QPushButton(translate("ui_cancel"))
cancel_button.clicked.connect(self.close_self)
buttons_layout.addSpacerItem(
QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum))
buttons_layout.addWidget(self.current_hit_chance)
buttons_layout.addWidget(shoot_one_button)
buttons_layout.addWidget(shoot_series_button)
buttons_layout.addWidget(cancel_button)
self.update_distances(True)
self.update_size(True)
self.update_cover(True)
self.update_chance()
def fill_attributes(self, attributes_layout, attribute_names, alternative):
for attribute in attribute_names:
att = AttributeView(name=attribute, display_name=translate(attribute),
val_dict=self.attribute_dict, alternative=alternative)
attributes_layout.addWidget(att, stretch=0)
def fill_parameters(self):
parameters_layout = QHBoxLayout()
encumbrance_layout = QVBoxLayout()
label = QLabel(translate("ui_encumbrance"))
label.setStyleSheet("font: bold 12px")
label.setAlignment(Qt.AlignCenter)
encumbrance_layout.addWidget(label)
encumbrance_values_layout = QHBoxLayout()
encumbrance_current = InputLine("param_encumbrance_current", enabled=False, val_dict=self.params_dict,
dtype="float", label=translate("param_encumbrance_current"), maxwidth=50)
encumbrance_low = InputLine("param_encumbrance_low", enabled=False, val_dict=self.params_dict, dtype="int",
label=translate("param_encumbrance_low"), maxwidth=50)
encumbrance_med = InputLine("param_encumbrance_med", enabled=False, val_dict=self.params_dict, dtype="int",
label=translate("param_encumbrance_med"), maxwidth=50)
encumbrance_high = InputLine("param_encumbrance_high", enabled=False, val_dict=self.params_dict, dtype="int",
label=translate("param_encumbrance_high"), maxwidth=50)
encumbrance_values_layout.addWidget(encumbrance_current)
encumbrance_values_layout.addWidget(encumbrance_low)
encumbrance_values_layout.addWidget(encumbrance_med)
encumbrance_values_layout.addWidget(encumbrance_high)
encumbrance_layout.addLayout(encumbrance_values_layout)
reputation_layout = QVBoxLayout()
label = QLabel(translate("ui_reputation"))
label.setStyleSheet("font: bold 12px")
label.setAlignment(Qt.AlignCenter)
reputation_layout.addWidget(label)
reputation_values_layout = QHBoxLayout()
reputation_bad = InputLine("param_reputation_bad", val_dict=self.params_dict, dtype="int",
label=translate("param_reputation_bad"), maxwidth=50)
reputation_good = InputLine("param_reputation_good", val_dict=self.params_dict, dtype="int",
label=translate("param_reputation_good"), maxwidth=50)
reputation_total = InputLine("param_reputation_total", val_dict=self.params_dict, dtype="int", enabled=False,
label=translate("param_reputation_total"), maxwidth=50)
reputation_values_layout.addWidget(reputation_bad)
reputation_values_layout.addWidget(reputation_total)
reputation_values_layout.addWidget(reputation_good)
reputation_layout.addLayout(reputation_values_layout)
speed_layout = QVBoxLayout()
label = QLabel(translate("ui_speed"))
label.setStyleSheet("font: bold 12px")
label.setAlignment(Qt.AlignCenter)
speed_layout.addWidget(label)
speed_values_layout = QHBoxLayout()
speed_low = InputLine("param_speed_low", enabled=False, val_dict=self.params_dict, dtype="int",
label=translate("param_speed_low"), maxwidth=50)
speed_med = InputLine("param_speed_med", enabled=False, val_dict=self.params_dict, dtype="int",
label=translate("param_speed_med"), maxwidth=50)
speed_high = InputLine("param_speed_high", enabled=False, val_dict=self.params_dict, dtype="int",
label=translate("param_speed_high"), maxwidth=50)
speed_values_layout.addWidget(speed_low)
speed_values_layout.addWidget(speed_med)
speed_values_layout.addWidget(speed_high)
speed_layout.addLayout(speed_values_layout)
parameters_layout.addLayout(encumbrance_layout)
parameters_layout.addLayout(reputation_layout)
parameters_layout.addLayout(speed_layout)
return parameters_layout
def fill_tab2(self, alternative=False):
page2 = QVBoxLayout()
# Equipment panel
equipment_tabs = QTabWidget()
page2.addWidget(equipment_tabs, 1)
tab1 = QWidget()
tab2 = QWidget()
tab3 = QWidget()
equipment_tabs.addTab(tab1, translate("ui_weapons"))
equipment_tabs.addTab(tab2, translate("ui_armors"))
equipment_tabs.addTab(tab3, translate("ui_modifiers"))
tab1_layout = QVBoxLayout()
tab2_layout = QVBoxLayout()
tab3_layout = QVBoxLayout()
tab1.setLayout(tab1_layout)
tab2.setLayout(tab2_layout)
tab3.setLayout(tab3_layout)
weapons_scroll = ConditionalScrollContainer("ui_weapons", translate("ui_weapons_add_button"), WeaponView,
popup=ItemListPopup, conditions=["weapon"])
self.scrolls["weapons"] = weapons_scroll
tab1_layout.addWidget(weapons_scroll)
armor_scroll = ConditionalScrollContainer("ui_armors", translate("ui_armor_add_button"), ArmorView,
popup=ItemListPopup, conditions=["armor"])
self.scrolls["armor"] = armor_scroll
tab2_layout.addWidget(armor_scroll)
modifier_scroll = ConditionalScrollContainer("ui_modifiers", translate("ui_modifier_add_button"),
ModifierItemView, conditions=["implant", "modifier", "bionic"],
popup=ItemListPopup, alternative=alternative)
self.scrolls["modifiers"] = modifier_scroll
tab3_layout.addWidget(modifier_scroll)
if alternative:
tab4 = QWidget()
tab5 = QWidget()
equipment_tabs.addTab(tab4, translate("ui_modules"))
equipment_tabs.addTab(tab5, translate("ui_parts"))
tab4_layout = QVBoxLayout()
tab5_layout = QVBoxLayout()
tab4.setLayout(tab4_layout)
tab5.setLayout(tab5_layout)
modules_scroll = ConditionalScrollContainer("ui_modules", translate("ui_module_add_button"),
ModifierItemView, conditions=["droid_module"],
popup=ItemListPopup, alternative=alternative)
self.scrolls["modules"] = modules_scroll
tab4_layout.addWidget(modules_scroll)
parts_scroll = ConditionalScrollContainer("ui_parts", translate("ui_part_add_button"),
ModifierItemView, conditions=["droid_part"],
popup=ItemListPopup, alternative=alternative)
self.scrolls["parts"] = parts_scroll
tab5_layout.addWidget(parts_scroll)
# items
equipment_and_money = QHBoxLayout()
name = "notes_money"
money = LabelledTextEdit(name, label=translate("ui_{}".format(name)))
self.notes_dict[name] = money
self.equipment_tables = EquipmentWidget(ItemPopup, ItemMovePopup)
equipment_and_money.addWidget(self.equipment_tables, 3)
equipment_and_money.addWidget(money, 1)
page2.addLayout(equipment_and_money, 2)
self.tab2.setLayout(page2)
