def on_start(self):
self.widgets = set()
self.rows.clear()
self.data.clear()
self.left = core.dppr((800 - self.columnlens[-1]) / 2)
self.top = core.dpp(40)
self.table_row_width = core.dpp(self.columnlens[-1] + 1)
self.table_row_height = round(core.Var.SCREEN_HEIGHT - 2 * self.top - core.widgets.Button.height)
self.table_row_height /= self.number_rows
self.table_row_height = round(self.table_row_height)
menu_x, menu_y = core.Var.SCREEN_WIDTH / 2, core.Var.SCREEN_HEIGHT
self.widgets.add(
core.widgets.Button(core.Var.str_back[core.Var.language_id], menu_x - core.widgets.Button.width / 2,
menu_y - core.widgets.Button.height - core.dpp(22), self.back))
for i in range(self.number_rows):
self.rows.append(core.p.Rect((self.left, self.top + i * self.table_row_height),
(self.table_row_width, self.table_row_height)))
data = [core.Var.str_scoreboard[core.Var.language_id]]
for i in core.Var.scoreboard_data:
data.append(i)
item = []
for i in data:
for j in range(len(i)):
item.clear()
item.append(core.Var.font_tiny.render(i[j], True, core.Var.BLACK))
item.append(item[0].get_rect())
item[1].left = self.left + core.dppr(5 + self.columnlens[j])
item[1].centery = self.rows[data.index(i)].centery
self.data.append(item.copy())
def __init__(self, x, y, command, text=""):
Widget.__init__(self, x, y, core.dpp(Widget.def_height), core.dpp(Widget.def_height), command, text)
self.ticked = False
self.frame_text.left -= core.dpp(150 - Widget.def_height)
self.__line_thickness = round(self.width / 9)
self.__check_pointlist = [(self.x + self.width - self.width / 7, self.y + self.height / 8),
(self.x + self.width / 4, self.y + self.height - self.height / 9),
(self.x + self.width / 9, self.y + self.height / 2.5)]
self.__color_main = core.Var.THEME_DEFAULT
def __init__(self, message):
Message.__init__(self, message)
self.ok_button = Button("Ok", self.frame.centerx,
self.frame.bottom - core.dpp(41), self.set_value, big=False)
self.ok_button.frame.width = self.ok_button.frame_text.width + core.dpp(15)
self.ok_button.frame.centerx = self.frame.centerx
self.ok_button.frame_text.center = self.ok_button.frame.center
self.textfield = Textfield(self.frame.left + core.dpp(30), self.frame.centery + core.dpp(5), core.dpp(150),
self.set_value, "", 18)
self.value = None
def __init__(self):
core.Screen.__init__(self, 5)
self.widgets = set()
self.table_row_width = 0
self.table_row_height = 0
self.number_rows = 16
self.columnlens = (0, 30, 170, 240, 300, 360, 405, 450)
self.number_columns = len(self.columnlens)
self.left = core.dpp(45)
self.top = core.dpp(40)
self.rows = []
self.data = []
def on_start(self):
core.widgets.Button.load_resources()
Menu.img_background = core.load_image(core.Var.path_background)
self.img_title = core.Var.font_title.render(core.Var.CAPTION[core.Var.language_id].upper(), True,
core.Var.BLACK)
self.frame_title = self.img_title.get_rect()
self.frame_title.center = (core.Var.SCREEN_WIDTH / 3, core.dpp(130))
Menu.menu_items.clear()
for i in range(len(core.Var.str_mainmenu)):
Menu.menu_items.append(core.widgets.Button(core.Var.str_mainmenu[i][core.Var.language_id],
core.Var.SCREEN_WIDTH / 3 - core.widgets.Button.width / 2,
core.dpp(220) + i * core.widgets.Button.height,
self.menu_commands[i]))
def __init__(self, x, y, width, command, text=""):
Widget.__init__(self, x, y, width - core.dpp(40), core.dpp(Widget.def_height), command, text)
self.frame_text.left -= core.dpp(40)
self.__circle_radius = core.dppr(8)
self.__line_width = core.dppr(5)
self.__anotherpoint = (0, 0)
self.value = 0
self.__color_hover = core.Var.THEME_DEFAULT
self.__change_value = False
self.__img_value = core.Var.font_tiny.render(": {:3d}".format(self.value), True, core.Var.BLACK)
self.__frame_value = self.__img_value.get_rect()
self.__frame_value_back = core.p.Rect((0, 0), (width - self.width - core.dpp(13), self.height - core.dpp(4)))
self.__frame_value_back.midleft = self.frame.midright
self.__frame_value_back.left += core.dpp(13)
self.__frame1 = core.p.Rect((self.x-self.__circle_radius*2, self.y), (self.width+self.__circle_radius*4,
self.height))
def on_start(self):
self.widgets.clear()
x, y = core.dpp(20), core.dpp(18)
self.subscreen_surface = core.p.Surface(
(core.Var.SCREEN_WIDTH - 2*x,
core.Var.SCREEN_HEIGHT - 2*y))
self.subscreen_surface.set_alpha(115)
self.subscreen_surface.fill(core.Var.WHITE)
self.subscreen_frame = self.subscreen_surface.get_rect()
self.subscreen_frame.topleft = x, y
self.widgets.append(core.widgets.WallofText(x, 2*y, self.subscreen_frame.width, self.subscreen_frame.height,
core.Var.str_wallofhelp[core.Var.language_id]))
self.widgets.append(core.widgets.Label(core.Var.SCREEN_WIDTH/2.05, x + core.dpp(10), core.dpp(150), core.Var.str_mainmenu[4][core.Var.language_id], 33))
self.widgets.append(
core.widgets.Button(core.Var.str_back[core.Var.language_id], core.Var.SCREEN_WIDTH/2 - core.widgets.Button.width / 2,
core.Var.SCREEN_HEIGHT - core.widgets.Button.height - y - core.dpp(4), self.back))
def render(self, s):
self.angle = self.vect_mouse.angle_to(core.Var.unit_vector)
rotated_body = core.p.transform.rotate(self.img_hero_body, self.angle)
center = core.p.math.Vector2(core.dpp(17), 0)
center.rotate_ip(-self.angle)
if self.current_gun == 0:
if not self.hit_animation:
rotated_weapon = core.p.transform.rotate(self.img_saber[core.Gameobj.guns[0].lefthand], self.angle)
else:
if core.Gameobj.guns[0].frame >= core.Gameobj.guns[0].animation_len:
core.Gameobj.guns[0].frame -= 1
elif core.Gameobj.guns[0].frame < 0:
core.Gameobj.guns[0].frame = 0
if core.Gameobj.guns[0].lefthand:
rotated_weapon = core.p.transform.rotate(self.img_saber[3][core.Gameobj.guns[0].frame], self.angle)
else:
rotated_weapon = core.p.transform.rotate(self.img_saber[2][core.Gameobj.guns[0].frame], self.angle)
center_w = core.p.math.Vector2(core.dpp(42), 0)
center_w.rotate_ip(-self.angle)
else:
rotated_hands = core.p.transform.rotate(self.img_hero_hands[core.Gameobj.guns[self.current_gun].reload_bool],
self.angle)
rotated_weapon = core.p.transform.rotate(self.img_weapons[self.current_gun-1], self.angle)
center_w = core.p.math.Vector2(core.dpp(50-7*core.Gameobj.guns[self.current_gun].delta_shot), 0)
center_w.rotate_ip(-self.angle)
frame_hands = rotated_hands.get_rect()
frame_hands.center = round(self.x+center.x-core.Var.offset_x), round(self.y+center.y-core.Var.offset_y)
if core.Gameobj.guns[self.current_gun].delta_shot != 0:
rotated_flash = core.p.transform.rotate(self.img_flash, self.angle)
frame_flash = rotated_flash.get_rect()
center_flh = core.p.math.Vector2(center_w.x, center_w.y)
center_flh.scale_to_length(core.dpp(30)+core.Gameobj.guns[self.current_gun].length)
frame_flash.center = round(self.x+center_flh.x-core.Var.offset_x), round(self.y+center_flh.y-core.Var.offset_y)
s.blit(rotated_flash, frame_flash)
s.blit(rotated_hands, frame_hands)
self.frame = rotated_body.get_rect()
self.frame.center = round(self.x-core.Var.offset_x), round(self.y-core.Var.offset_y)
frame_weapon = rotated_weapon.get_rect()
frame_weapon.center = round(self.x+center_w.x-core.Var.offset_x), round(self.y+center_w.y-core.Var.offset_y)
s.blit(rotated_weapon, frame_weapon)
s.blit(rotated_body, self.frame)
def __init__(self, text, x, y, command, big=True, disabled=False):
Widget.__init__(self, x, y, Button.width, Button.height - core.dpp(2), command, text)
if big:
self.img_text = core.Var.font_button.render(text, True, core.Var.BLACK)
else:
self.img_text = core.Var.font_tiny.render(text, True, core.Var.BLACK)
self.frame_text = self.img_text.get_rect()
self.frame_text.center = self.frame.center
self.disabled = disabled
self.__color_main = core.Var.THEME_DEFAULT
def set_value(self, v):
if v < 0:
v = 0
elif v > 100:
v = 100
self.value = round(v)
self.__img_value = core.Var.font_tiny.render(str(self.value), True, core.Var.BLACK)
self.__frame_value = self.__img_value.get_rect()
self.__frame_value.midright = self.frame.midright
self.__frame_value.left += core.dpp(39)
self.__anotherpoint = (round(self.x + v / 100 * self.width), round(self.frame.centery))
def __init__(self, message):
self.img_message = []
self.frame_message = []
self.message = message
self.frame = None
self.linesize = core.Var.font_tiny.get_linesize()
self.linesize = core.Var.font_tiny.get_linesize() + core.dpp(2)
longest_line = 0
for i in self.message:
img = core.Var.font_tiny.render(i, True, core.Var.BLACK)
self.img_message.append(img)
self.frame_message.append(img.get_rect())
if img.get_width() > longest_line:
longest_line = img.get_width()
box_width = longest_line + core.dpp(90)
box_height = len(self.message) * self.linesize + core.dpp(80)
self.frame = core.p.Rect((core.Var.SCREEN_WIDTH - box_width) / 2, (core.Var.SCREEN_HEIGHT - box_height) / 2,
box_width, box_height)
for i in range(len(self.frame_message)):
self.frame_message[i].x = self.frame.x + core.dpp(40)
self.frame_message[i].y = self.frame.y + core.dpp(22) + i * self.linesize
def __init__(self, x, y, width, command, text, maxlen):
Widget.__init__(self, x, y, width, core.dpp(Widget.def_height), command, text)
self.value = ""
self.__img_value = core.Var.font_tiny.render(self.value, True, core.Var.BLACK)
self.__frame_value = self.__img_value.get_rect()
self.__frame_value.midleft = self.frame.midleft
self.__color_main = core.Var.THEME_DEFAULT
self.__blink_time = 0.8
self.__previous_blink = core.time()
self.__blink = False
self.__change_value = False
self.__c = 0
self.maxlen = maxlen
def __init__(self, x, y, width, command, action, value, text=""):
Widget.__init__(self, x, y, width, core.dpp(Widget.def_height), command, text)
self.action = action
self.value = value
self.__color_main = core.Var.THEME_DEFAULT
self.__change_value = False
if value != -1:
self.__value_text = core.p.key.name(value).upper()
else:
self.__value_text = " "
self.__img_value = core.Var.font_tiny.render(self.__value_text, True, core.Var.BLACK)
self.__frame_value = self.__img_value.get_rect()
self.__frame_value.center = self.frame.center
self.__c = 0
def __init__(self, x, y, width, height, text, fontsize=14):
Widget.__init__(self, x, y, width, height, None, text)
self.__textsurface = core.p.Surface((width, height), flags=core.p.SRCALPHA)
font = core.p.font.SysFont("Verdana", core.dppr(fontsize))
line_spacing = font.size("A")[1]+core.dpp(4)
data = text.split("\\n")
line = ""
y = self.y
for paragraph in data:
wordlist = paragraph.split()
for nr in range(len(wordlist)):
if font.size(wordlist[nr]+line)[0] < self.width - font.size(wordlist[nr])[0]*3 and nr+1 < len(wordlist):
line += " "+wordlist[nr]
else:
line += " "+wordlist[nr]
self.__textsurface.blit(font.render(line, True, core.Var.BLACK), (self.x, y))
y += line_spacing
line = ""
y += line_spacing
def render(self, s):
animation_max = 30
modifier = 0
if not self.attack_bool:
something = time() - self.time_attacked
attack_peak_time = self.attacktimer / 4
if something <= attack_peak_time:
modifier = something / attack_peak_time * animation_max
elif something <= attack_peak_time * 2:
modifier = animation_max - something / (attack_peak_time * 2) * animation_max
self.vect.x = core.Gameobj.hero.x - self.x
self.vect.y = core.Gameobj.hero.y - self.y
angle = self.vect.angle_to(core.Var.unit_vector) + modifier
rotated = core.p.transform.rotate(self.image, angle)
center = core.p.math.Vector2(core.dpp(12), 0)
center.rotate_ip(-angle)
self.frame = rotated.get_rect()
self.frame.center = round(self.x + center.x - core.Var.offset_x), round(self.y + center.y - core.Var.offset_y)
s.blit(rotated, self.frame)
def __init__(self, message, buttonstext):
Message.__init__(self, message)
self.buttonstext = buttonstext
self.ok_button = Button(self.buttonstext[0], self.frame.left + core.dpp(15),
self.frame.bottom - core.dpp(41), self.accepted, big=False)
self.ok_button.frame.width = self.ok_button.frame_text.width + core.dpp(15)
self.ok_button.frame_text.center = self.ok_button.frame.center
self.cancel_button = Button(self.buttonstext[1], 0,
self.frame.bottom - core.dpp(41), self.canceled, big=False)
self.cancel_button.frame.width = self.cancel_button.frame_text.width + core.dpp(15)
self.cancel_button.frame.x = self.frame.right - core.dpp(15) - self.cancel_button.frame.width
self.cancel_button.frame_text.center = self.cancel_button.frame.center
self.value = None
def render(self, s):
s.blit(core.Var.level_background, (-core.Var.offset_x, -core.Var.offset_y))
# DRAW BULLETS
for i in core.Gameobj.bullets:
if time() - i[4] > core.Var.bullet_timeout:
core.Gameobj.bullets.remove(i)
continue
core.p.draw.line(s, core.Var.YELLOW_BULLET, (i[0], i[1]), (i[2], i[3]), core.Var.bullet_line_thickness)
# DRAW ITEMS
for i in core.Gameobj.items:
i.render(s)
# DRAW PARTICLES
for i in core.Gameobj.particles_below:
i.render(s)
# DRAW MONSTERS
for i in core.Gameobj.monsters:
i.render(s)
# DRAW HERO
core.Gameobj.hero.render(s)
# DRAW PARTICLES
for i in core.Gameobj.particles_over:
i.render(s)
# DRAW HUD
if self.next_wave_started: # TODO
img_text_wave = core.Var.font_title.render(
core.Var.str_wave[core.Var.language_id] + " " + str(core.Var.survival_wave), True, core.Var.WHITE)
frame_text_wave = img_text_wave.get_rect()
frame_text_wave.center = (core.Var.SCREEN_WIDTH / 2, core.Var.SCREEN_HEIGHT / 2)
s.blit(img_text_wave, frame_text_wave)
ui.draw_healthbar(s, 25, core.udpp(core.Var.SCREEN_HEIGHT) - 42, 150, 24, core.Gameobj.hero.health,
core.Gameobj.hero.maxhealth)
ui.draw_ammo(s, core.udpp(core.Var.SCREEN_WIDTH)-103, core.udpp(core.Var.SCREEN_HEIGHT) - 42,
core.Gameobj.guns[core.Gameobj.hero.current_gun].clip,
core.Gameobj.hero.ammo[
core.Gameobj.guns[core.Gameobj.hero.current_gun].bullet_type])
ui.draw_score(s, core.Var.SCREEN_WIDTH/2-core.dpp(38), core.Var.SCREEN_HEIGHT-core.dpp(42))
if self.end_message is not None:
self.end_message.render(s)
def __init__(self, x, y, name, maxhealth, speed, damage, image, attacktimer, mass, attack_range):
self.x = x
self.y = y
self.name = name
self.maxhealth = maxhealth
self.speed = speed
self.damage = damage
self.image = image
self.attacktimer = attacktimer
self.mass = mass
self.uuid = core.Var.uuid_gen
core.Var.uuid_gen += 1
self.health = self.maxhealth
self.frame = self.image.get_rect()
self.size = (self.image.get_width() / 2) ** 2
self.vect = core.p.math.Vector2(core.Gameobj.hero.x - self.x, core.Gameobj.hero.y - self.y)
self.vect_long = core.p.math.Vector2(core.Gameobj.hero.x - self.x, core.Gameobj.hero.y - self.y)
self.time_attacked = 0
self.attack_bool = False
self.kickback = 0
self.collision_with_other = [False, 1, 1]
self.kick_direction = [0, 0]
self.attack_range = (core.dpp(attack_range) + core.sqrt(self.size) + core.sqrt(core.Gameobj.hero.size)) ** 2
def __init__(self, x, y, width, command, items, text=""):
if width < core.dpp(45):
width = core.dpp(45)
Widget.__init__(self, x, y, width, core.dpp(Widget.def_height), command, text)
self.items = items
self.selected_item = 0
self.__frame_left = core.p.Rect((self.x, self.y), (core.dpp(Widget.def_height), self.height))
self.__frame_right = core.p.Rect((self.frame.right - core.dpp(Widget.def_height), self.y),
(core.dpp(Widget.def_height) + 1, self.height))
self.__frame_mid = core.p.Rect(self.__frame_left.topright, (
self.frame.width - self.__frame_left.width - self.__frame_right.width, self.height))
self.__img_text_selected = core.Var.font_tiny.render(self.items[self.selected_item], True, core.Var.BLACK)
self.__frame_text_selected = self.__img_text_selected.get_rect()
self.__frame_text_selected.center = self.frame.center
self.__arrow_size = core.dpp(5.3) # bigger the number, smaller the arrow
self.__left_arrow = [(self.__frame_left.left + self.__arrow_size * 1.1, self.__frame_left.centery),
(self.__frame_left.right - self.__arrow_size, self.__frame_left.top + self.__arrow_size),
(
self.__frame_left.right - self.__arrow_size,
self.__frame_left.bottom - self.__arrow_size)]
self.__right_arrow = [(self.__frame_right.right - self.__arrow_size * 1.1, self.__frame_right.centery),
(self.__frame_right.left + self.__arrow_size, self.__frame_right.top + self.__arrow_size),
(self.__frame_right.left + self.__arrow_size,
self.__frame_right.bottom - self.__arrow_size)]
def __init__(self, x, y):
rng = randint(0, len(Zombie.img) - 1)
Monster.__init__(self, x, y, "zombie_common", 100, core.dpp(55 / 1000), 8, Zombie.img[rng], 1, 10, 4.5)
def move_hero(self, delta):
move_x = self.x + core.Inputhandler.move_buttons[3] - core.Inputhandler.move_buttons[2]
move_y = self.y + core.Inputhandler.move_buttons[1] - core.Inputhandler.move_buttons[0]
self.vect_mouse.x = core.Inputhandler.x_mouse+core.Var.offset_x - self.x
self.vect_mouse.y = core.Inputhandler.y_mouse+core.Var.offset_y - self.y
self.vect_move.x = move_x - self.x
self.vect_move.y = move_y - self.y
speed = self.speed / core.Gameobj.guns[self.current_gun].weight * delta
if self.vect_move.length_squared() != 0:
self.vect_move.scale_to_length(speed)
speed_x, speed_y = self.vect_move.x, self.vect_move.y
new_x = self.x + speed_x
new_y = self.y + speed_y
if new_x < core.Var.level_boundries[0]+self.sizenotsq or new_x > core.Var.level_boundries[1]-self.sizenotsq:
new_x = self.x
if new_y < core.Var.level_boundries[2]+self.sizenotsq or new_y > core.Var.level_boundries[3]-self.sizenotsq:
new_y = self.y
self.moved_since_step += (self.x-new_x)**2 + (self.y-new_y)**2
if core.Var.channel_misc1.get_sound() is None and self.moved_since_step > core.dpp(2.4)**2*delta:
self.step = not self.step
self.moved_since_step = 0
core.Var.channel_misc1.play(core.Var.sound_steps[self.step])
self.x = new_x
self.y = new_y
def on_start(self):
menu_x, menu_y = core.dpp(self.menu_button_x), core.dpp(self.menu_button_y)
self.widgets = set()
self.widgets_game = set()
self.widgets_controls = set()
self.show_game = True
self.show_controls = False
self.subscreen_surface = core.p.Surface(
(core.Var.SCREEN_WIDTH - (menu_x + core.widgets.Button.width + core.dpp(20 + 15)),
core.Var.SCREEN_HEIGHT - core.dpp(15 * 2)))
self.subscreen_surface.set_alpha(115)
self.subscreen_surface.fill(core.Var.WHITE)
self.subscreen_frame = self.subscreen_surface.get_rect()
self.subscreen_frame.topleft = menu_x + core.widgets.Button.width + core.dpp(20), core.dpp(15)
self.widgets.add(core.widgets.Button(core.Var.str_videoaudio[core.Var.language_id], menu_x,
menu_y, self.show_video_settings))
self.widgets.add(core.widgets.Button(core.Var.str_controls[core.Var.language_id], menu_x,
menu_y + core.widgets.Button.height, self.show_control_settings))
self.widgets.add(core.widgets.Button(core.Var.str_back[core.Var.language_id], menu_x,
menu_y + core.widgets.Button.height * 2 + core.dpp(10), self.back))
item_width = core.dpp(150)
space_between_items = core.dpp(40)
space_from_top = core.dpp(85)
space_from_bottom = space_from_top / 5
items_per_column = round(
(self.subscreen_frame.height - space_from_top - space_from_bottom) / space_between_items)
item_line_x = (
self.subscreen_frame.left + item_width + core.dpp(20),
self.subscreen_frame.left + item_width * 3 + core.dpp(44))
item_line_y = (self.subscreen_frame.top + space_from_top,
self.subscreen_frame.top + space_from_top - items_per_column * space_between_items)
# Add items to Game settings screen
self.widgets_game.add(core.widgets.Label(item_line_x[len(self.widgets_game) // items_per_column],
item_line_y[len(self.widgets_game) // items_per_column] + len(
self.widgets_game) * space_between_items, item_width,
core.Var.str_video[core.Var.language_id], 16))
resolutions = []
for i in core.Var.resolutions:
if i[0] > core.Var.display_info.current_w or i[1] > core.Var.display_info.current_h:
continue
str_res = str(i[0]) + "x" + str(i[1])
resolutions.append(str_res)
resolution_button = core.widgets.Cyclebutton(item_line_x[len(self.widgets_game) // items_per_column],
item_line_y[len(self.widgets_game) // items_per_column] + len(
self.widgets_game) * space_between_items, item_width,
self.select_resolution,
resolutions, core.Var.str_resolution[core.Var.language_id])
resolution_button.set_item(core.Var.resolution_id)
self.widgets_game.add(resolution_button)
fpslimits = []
for i in core.Var.fps:
if i != 0:
fpslimits.append(str(i))
else:
fpslimits.append(core.Var.str_fpslimit[1][core.Var.language_id])
fpslimit_button = core.widgets.Cyclebutton(item_line_x[len(self.widgets_game) // items_per_column],
item_line_y[len(self.widgets_game) // items_per_column] + len(
self.widgets_game) * space_between_items, item_width,
self.select_fpslimit,
fpslimits, core.Var.str_fpslimit[0][core.Var.language_id])
fpslimit_button.set_item(core.Var.fps_id)
self.widgets_game.add(fpslimit_button)
check_box_fullscreen = core.widgets.Checkbox(item_line_x[len(self.widgets_game) // items_per_column],
item_line_y[len(self.widgets_game) // items_per_column] + len(
self.widgets_game) * space_between_items,
self.change_fullscreen,
core.Var.str_fullscreen[core.Var.language_id])
check_box_fullscreen.ticked = core.Var.is_fullscreen
self.widgets_game.add(check_box_fullscreen)
self.widgets_game.add(core.widgets.Label(item_line_x[len(self.widgets_game) // items_per_column],
item_line_y[len(self.widgets_game) // items_per_column] + len(
self.widgets_game) * space_between_items, item_width,
core.Var.str_game[core.Var.language_id], 16))
language_button = core.widgets.Cyclebutton(item_line_x[len(self.widgets_game) // items_per_column],
item_line_y[len(self.widgets_game) // items_per_column] + len(
self.widgets_game) * space_between_items,
item_width, self.select_language, core.Var.languages,
core.Var.str_language[core.Var.language_id])
language_button.set_item(core.Var.language_id)
self.widgets_game.add(language_button)
color_slider = core.widgets.Slider(item_line_x[len(self.widgets_game) // items_per_column],
item_line_y[len(self.widgets_game) // items_per_column] + len(
self.widgets_game) * space_between_items,
item_width, self.color_slider, core.Var.str_color[core.Var.language_id])
color_slider.set_value(round(core.Var.default_hue / 3.6))
self.widgets_game.add(color_slider)
check_box_showfps = core.widgets.Checkbox(item_line_x[len(self.widgets_game) // items_per_column],
item_line_y[len(self.widgets_game) // items_per_column] + len(
self.widgets_game) * space_between_items,
self.change_showfps,
core.Var.str_showfps[core.Var.language_id])
check_box_showfps.ticked = core.Var.show_fps
self.widgets_game.add(check_box_showfps)
self.widgets_game.add(core.widgets.Label(item_line_x[1],
item_line_y[0] + 0 * space_between_items, item_width,
core.Var.str_sound[core.Var.language_id], 16))
master_slider = core.widgets.Slider(item_line_x[1],
item_line_y[0] + 1 * space_between_items,
item_width, self.master_slider,
core.Var.str_volume[0][core.Var.language_id])
master_slider.set_value(core.Var.volume[0])
self.widgets_game.add(master_slider)
music_slider = core.widgets.Slider(item_line_x[1],
item_line_y[0] + 2 * space_between_items,
item_width, self.music_slider, core.Var.str_volume[1][core.Var.language_id])
music_slider.set_value(core.Var.volume[1])
self.widgets_game.add(music_slider)
sound_slider = core.widgets.Slider(item_line_x[1],
item_line_y[0] + 3 * space_between_items,
item_width, self.sound_slider, core.Var.str_volume[2][core.Var.language_id])
sound_slider.set_value(core.Var.volume[2])
self.widgets_game.add(sound_slider)
self.widgets_game.add(
core.widgets.Label(self.subscreen_frame.centerx, self.subscreen_frame.top + core.dpp(24), item_width,
core.Var.str_videoaudio[core.Var.language_id], 24))
# Add items to Controls screen
for i in range(len(core.Var.key_binds)):
self.widgets_controls.add(core.widgets.Keybind(item_line_x[len(self.widgets_controls) // items_per_column],
item_line_y[
len(self.widgets_controls) // items_per_column] + len(
self.widgets_controls) * space_between_items,
item_width,
self.keybind, i, core.Var.key_binds[i],
core.Var.str_keybinds[i][core.Var.language_id]))
self.widgets_controls.add(
core.widgets.Label(self.subscreen_frame.centerx, self.subscreen_frame.top + core.dpp(24), item_width,
core.Var.str_controls[core.Var.language_id], 24))
def kick_back(self, kick, pos):
self.kickback += core.dpp(kick) / self.mass * 100
self.kick_direction[0] = self.x - pos[0]
self.kick_direction[1] = self.y - pos[1]
def __init__(self, x, y, width, text, fontsize):
Widget.__init__(self, x, y, width, core.dpp(fontsize), None, text)
font = core.p.font.SysFont("Verdana", core.dppr(fontsize))
self.img_text = font.render(text, True, core.Var.BLACK)
self.frame_text.center = x, y
def change_value(self):
self.__img_value = core.Var.font_tiny.render(self.value, True, core.Var.BLACK)
self.__frame_value = self.__img_value.get_rect()
self.__frame_value.midleft = self.frame.midleft
self.__frame_value.left = self.frame.left + core.dpp(3)
def __init__(self, x, y):
Monster.__init__(self, x, y, "devil", 265, core.dpp(34 / 1000), 24, Devil.img, 2.15, 30, 240)
def load_resources():
Button.width = core.dpp(160)
Button.height = core.dpp(32)
