def __init__(self,
text,
length,
limvals,
initial_value,
reblit=None,
type_=float,
order="ins"):
import thorpy
self.text = thorpy.make_button(text, self.focus)
self.slider = thorpy.SliderX.make(length, limvals, "", type_,
initial_value)
self.ins = thorpy.Inserter.make("", value=str(initial_value))
if order == "ins":
els = [self.text, self.ins, self.slider]
else:
els = [self.text, self.slider, self.ins]
self.e = thorpy.make_group(els)
reac_slide = thorpy.Reaction(
reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=self.at_slide,
event_args={"id": thorpy.constants.EVENT_SLIDE})
reac_ins = thorpy.Reaction(
reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=self.at_insert,
event_args={"id": thorpy.constants.EVENT_INSERT})
self.e.add_reactions([reac_slide, reac_ins])
self.e._manager = self
self.ins._manager = self
self.slider._manager = self
self.e.get_value = self.slider.get_value
self.reblit = reblit
if not self.reblit:
self.reblit = self.e.unblit_and_reblit
def first_render(self, location):
self.elements = []
self.elements.append(thorpy.make_text("Smelter"))
self.smelt_items = [thorpy.Clickable.make("None") for x in range(self.max_inv_size)]
self.button = thorpy.make_button("Smelt", func=self.smelt)
self.smelt_item_box = thorpy.Box.make(elements=self.smelt_items)
self.elements.append(self.smelt_item_box)
self.elements.append(self.button)
self.smelted_item = thorpy.Clickable.make("None")
self.smelted_item_box = thorpy.Box.make(elements=[self.smelted_item])
self.elements.append(self.smelted_item_box)
self.box = thorpy.Box.make(elements=self.elements)
self.drag = thorpy.Draggable.make(elements=[self.box])
reaction = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=self._pop_smelter,
params={"item": self.smelted_item},
event_args={"id":thorpy.constants.EVENT_PRESS})
for item in self.elements:
item.center(axis=(True, False), element=self.box)
self.drag.add_reaction(reaction)
self.drag.set_topleft(location)
self.sub_menu = thorpy.Menu(self.drag)
thorpy.functions.set_current_menu(self.sub_menu)
self.sub_menu.blit_and_update()
def first_render(self, location):
self.elements = []
self.elements.append(thorpy.make_text("Inventory"))
self.item_clickables = [thorpy.Clickable.make("None") for x in range(self.max_inv_size)]
self.item_box = thorpy.Box.make(elements=self.item_clickables)
self.elements.append(self.item_box)
self.button = thorpy.make_button("Inv", func=self._print_all)
self.elements.append(self.button)
self.inv_box = thorpy.Box.make(elements=self.elements)
self.inv_drag = thorpy.Draggable.make(elements=[self.inv_box])
for item in self.item_clickables:
item.center(axis=(True, False), element=self.inv_box)
# this reaction allows us to click the item we want to smelt
# and transfer it into the smelter
reaction = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=self._add_to_smelter,
params={"item": item},
event_args={"id":thorpy.constants.EVENT_PRESS})
self.inv_drag.add_reaction(reaction)
self.inv_drag.set_topleft(location)
self.inv_menu = thorpy.Menu(self.inv_drag)
thorpy.functions.set_current_menu(self.inv_menu)
self.inv_menu.blit_and_update()
def join_game(self):
self.playerJoiningEdit = thorpy.Inserter.make("Player name: ")
playerJoiningEnterReaction = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=self.get_games_list,
event_args={"id": thorpy.constants.EVENT_INSERT})
self.playerJoiningEdit.add_reaction(playerJoiningEnterReaction)
self.replace_elements([self.playerJoiningEdit])
def init_ui(screen):
slider = thorpy.SliderX(100, (5, 15), "Simulation speed")
slider.user_func = slider_reaction
button_stop = thorpy.make_button("Quit", func=stop_execution)
button_pause = thorpy.make_button("Pause", func=pause_execution)
button_play = thorpy.make_button("Play", func=start_execution)
timer = thorpy.OneLineText("Seconds passed")
button_load = thorpy.make_button(text="Load a file", func=open_file)
box = thorpy.Box(elements=[
slider, button_pause, button_stop, button_play, button_load, timer
])
reaction1 = thorpy.Reaction(
reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=slider_reaction,
event_args={"id": thorpy.constants.EVENT_SLIDE},
params={},
reac_name="slider reaction")
box.add_reaction(reaction1)
menu = thorpy.Menu(box)
for element in menu.get_population():
element.surface = screen
box.set_topleft((0, 0))
box.blit()
box.update()
return menu, box, timer
def _initialize(self):
self.reac_keydown = thorpy.Reaction(pygame.KEYDOWN, self.func_keydown)
self.e.add_reaction(self.reac_keydown)
#
self.reac_time = thorpy.ConstantReaction(
thorpy.constants.THORPY_EVENT, self.func_time,
{"id": thorpy.constants.EVENT_TIME})
self.e.add_reaction(self.reac_time)
def add_reactions(self):
reac_click = thorpy.Reaction(pygame.MOUSEBUTTONDOWN, self.lmb,
{"button": 1})
self.me.e_box.add_reaction(reac_click)
reac_click = thorpy.Reaction(pygame.MOUSEBUTTONDOWN, self.rmb,
{"button": 3})
self.me.e_box.add_reaction(reac_click)
reac_motion = thorpy.Reaction(pygame.MOUSEMOTION, self.mousemotion)
self.me.e_box.add_reaction(reac_motion)
## reac_escape = thorpy.ConstantReaction(pygame.KEYDOWN, self.esc_menu, {"key":pygame.K_ESCAPE})
## self.me.e_box.add_reaction(reac_escape)
shortcuts = [(pygame.K_l, self.toggle_show_life),
(pygame.K_ESCAPE, self.launch_map_menu),
(pygame.K_PERIOD, self.find_free_unit),
(pygame.K_BACKSPACE, self.cancel)]
reacs = []
for key, func in shortcuts:
reacs.append(
thorpy.ConstantReaction(pygame.KEYDOWN, func, {"key": key}))
self.me.e_box.add_reactions(reacs)
def __init__(self, size, cell_size, redraw, external_e):
self.unit = None
## self.cell = None probleme
self.e_img = thorpy.Image.make(pygame.Surface(cell_size))
## self.e_img = thorpy.Image.make(pygame.Surface((1,1)))
self.blank_img = pygame.Surface(cell_size)
self.e_name = guip.get_title("Unit infos (no unit)")
#
## self.e_group = thorpy.make_group([self.e_img, self.e_name])
ghost = thorpy.Ghost([self.e_img, self.e_name])
ghost.finish()
self.e_img.set_center_pos(ghost.get_fus_center())
self.e_name.set_center_pos(self.e_img.get_fus_center())
ghost.fit_children()
self.e_group = ghost
#
self.elements = [self.e_group]
self.e = thorpy.Box.make(self.elements)
self.e.set_size((size[0], None))
for e in self.e.get_elements():
e.recenter()
## #emap : to be displayed when a cell is clicked
self.em_title = guip.get_title("Unit informations")
## self.em_coord = guip.get_text("")
## self.em_altitude = guip.get_text("")
self.em_name = guip.get_small_text("")
self.em_rename = guip.get_small_button("Rename",
self.rename_current_unit)
self.em_name_rename = thorpy.make_group([self.em_name, self.em_rename])
#### self.em_name_rename = thorpy.Clickable.make(elements=[self.em_name, self.em_rename])
#### thorpy.store(self.em_name_rename)
self.em_name_rename.fit_children()
self.em_unit_img_img = thorpy.Image.make(pygame.Surface(cell_size))
self.em_unit_img = thorpy.Clickable.make(
elements=[self.em_unit_img_img])
self.em_unit_img.fit_children()
self.em_unit_name = guip.get_text("")
self.em_unit = thorpy.make_group([self.em_unit_img, self.em_unit_name])
self.em_elements = [
self.em_title,
thorpy.Line.make(100), self.em_unit, self.em_name_rename
]
self.em = thorpy.Box.make(self.em_elements)
self.em.set_main_color((200, 200, 200, 150))
self.launched = False
self.redraw = redraw
self.external_e = external_e
reac = thorpy.Reaction(thorpy.THORPY_EVENT, self.set_unlaunched,
{"id": thorpy.constants.EVENT_UNLAUNCH})
external_e.add_reaction(reac)
self.last_cell_clicked = None
self.e_img.visible = False
def run_application():
W, H = 300, 300
application = thorpy.Application(size=(W, H), caption="Real life example")
draggable = thorpy.Draggable("Drag me")
sx = thorpy.SliderX(length=100, limvals=(0, W), text="X:", type_=int)
sy = thorpy.SliderX(length=100, limvals=(0, H), text="Y:", type_=int)
background = thorpy.Background(color=(200, 255, 255),
elements=[draggable, sx, sy])
thorpy.store(background, [sx, sy])
reaction1 = thorpy.Reaction(
reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=refresh_drag,
event_args={"id": thorpy.constants.EVENT_SLIDE},
params={
"drag": draggable,
"sx": sx,
"sy": sy
},
reac_name="my reaction to slide event")
reaction2 = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=refresh_sliders,
event_args={"id": thorpy.constants.EVENT_DRAG},
params={
"drag": draggable,
"sx": sx,
"sy": sy
},
reac_name="my reaction to drag event")
background.add_reaction(reaction1)
background.add_reaction(reaction2)
menu = thorpy.Menu(background) #create a menu for auto events handling
menu.play() #launch the menu
application.quit()
def get_games_list(self, event):
player_name = event.el.get_value()
r = Api.getPlayerInfo(player_name)
games_list = [id for id in r["games"]] if r is not None else []
label = thorpy.OneLineText.make("Here's a list of games " + player_name + " is in:")
self.gamesListEdit = thorpy.DropDownList.make(games_list, size=(250,150), x=5)
self.gamesListEdit.finish()
gameSelectReaction = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=self.start_game_join,
event_args={"id": thorpy.constants.EVENT_DDL})
self.gamesListEdit.add_reaction(gameSelectReaction)
goBackButton = thorpy.make_button("Go Back", func=self.start_menu)
self.replace_elements([label, self.gamesListEdit, goBackButton])
def launch_blocking_choices_str(text,
choices,
parent=None,
title_fontsize=None,
title_fontcolor=None,
func=None,
store="v"):
"""choices are tuple (text,func)"""
if title_fontsize is None: title_fontsize = thorpy.style.FONT_SIZE
if title_fontcolor is None: title_fontcolor = thorpy.style.FONT_COLOR
class Choice:
value = None
def choice_func(value):
Choice.value = value
elements = []
for name in choices:
e = thorpy.make_button(name, choice_func, {"value": name})
elements.append(e)
ghost = thorpy.make_group(elements, mode=store)
e_text = thorpy.make_text(text, title_fontsize, title_fontcolor)
box = thorpy.Box.make([e_text, thorpy.Line(100, "h"), ghost])
box.center()
from thorpy.miscgui.reaction import ConstantReaction
for e in elements:
reac = ConstantReaction(thorpy.constants.THORPY_EVENT,
thorpy.functions.quit_menu_func, {
"id": thorpy.constants.EVENT_UNPRESS,
"el": e
})
box.add_reaction(reac)
def click_outside(e):
if not box.get_fus_rect().collidepoint(e.pos):
thorpy.functions.quit_menu_func()
reac = thorpy.Reaction(pygame.MOUSEBUTTONDOWN, click_outside)
box.add_reaction(reac)
from thorpy.menus.tickedmenu import TickedMenu
m = TickedMenu(box)
m.play()
box.unblit()
if parent:
parent.partial_blit(None, box.get_fus_rect())
box.update()
if func:
func()
return Choice.value
def Menu():
'''Создает окно запуска'''
button_play = thorpy.make_button("Play",start_execution)
timer = thorpy.OneLineText("Seconds passed")
box = thorpy.Box(elements=[
button_play,
timer])
my_reaction = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=start_execution)
menu = thorpy.Menu(box)
for element in menu.get_population():
element.surface = screen
box.set_topleft((0, 0))
box.blit()
box.update()
return menu,box,timer
def __init__(self, me, size, cell_size, redraw, external_e):
self.me = me
self.wline = int(0.75*size[0])
self.e_coordalt = thorpy.make_text("(?,?)", font_size=10, font_color=(200,200,200))
self.e_mat_img = thorpy.Image.make(pygame.Surface(cell_size))
self.e_mat_name = guip.get_text("")
self.e_obj_name = guip.get_text("")
self.e_mat_obj = thorpy.make_group([self.e_mat_name, self.e_obj_name], "v")
## self.e_mat = thorpy.make_group([self.e_mat_img, self.e_mat_obj])
self.e_mat = thorpy.Box(elements=[self.e_mat_img, self.e_mat_obj])
## self.e_mat.fit_children(axis=(False, True))
self.elements = [self.e_mat, self.e_coordalt]
self.e = thorpy.Box.make(self.elements)
self.e.set_main_color((20,20,20))
self.e.set_size((size[0],int(0.8*self.e.get_fus_size()[1])), margins=(2,2))
for e in self.e.get_elements():
e.recenter()
self.cell = None
#emap : to be displayed when a cell is clicked
self.em_title = guip.get_title("Cell informations")
self.em_coord = guip.get_text("")
self.em_altitude = guip.get_text("")
self.em_name = guip.get_small_text("")
self.em_rename = guip.get_small_button("Rename", self.rename_current_cell)
self.em_name_rename = thorpy.make_group([self.em_name, self.em_rename])
## self.em_name_rename = thorpy.Clickable.make(elements=[self.em_name, self.em_rename])
## thorpy.store(self.em_name_rename)
self.em_name_rename.fit_children()
self.em_mat_img_img = thorpy.Image.make(pygame.Surface(cell_size))
self.em_mat_img = thorpy.Clickable.make(elements=[self.em_mat_img_img])
self.em_mat_img.fit_children()
self.em_mat_name = guip.get_text("")
self.em_obj_name = guip.get_text("")
self.em_mat_obj = thorpy.make_group([self.em_mat_name, self.em_obj_name], "v")
self.em_mat = thorpy.make_group([self.em_mat_img, self.em_mat_obj])
## self.em_elements = [self.em_title, thorpy.Line.make(self.wline), self.em_mat, self.em_coord, self.em_altitude, self.em_name_rename]
self.em_elements = [self.em_title, thorpy.Line.make(self.wline), self.em_mat, self.em_coord, self.em_name_rename]
self.em = thorpy.Box.make(self.em_elements)
self.em.set_main_color((200,200,200,150))
self.launched = False
self.redraw = redraw
self.external_e = external_e
reac = thorpy.Reaction(thorpy.THORPY_EVENT, self.set_unlaunched,
{"id":thorpy.constants.EVENT_UNLAUNCH})
external_e.add_reaction(reac)
self.last_cell_clicked = None
def create_menu(self):
self.acceleration_button = thorpy.Checker.make(
"Computer Controlled Accel")
self.acceleration_slider = thorpy.SliderX.make(
length=80,
limvals=(0, self.slide_limit),
text="Acceleration:",
type_=int)
self.maxSpeed_slider = thorpy.SliderX.make(length=80,
limvals=(0,
self.slide_limit),
text="Speed Limit:",
type_=int)
self.quit_button = thorpy.make_button("Quit",
func=thorpy.functions.quit_func)
self.menu_content = thorpy.Box.make(elements=[
self.acceleration_button, self.acceleration_slider,
self.maxSpeed_slider, self.quit_button
])
self.menu_slide_reaction = thorpy.Reaction(
reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=self.react_slider,
event_args={"id": thorpy.constants.EVENT_SLIDE},
reac_name="slider reaction")
self.menu_content.add_reaction(self.menu_slide_reaction)
self.menu = thorpy.Menu(self.menu_content)
for element in self.menu.get_population():
element.surface = self.screen
self.menu_content.set_topleft((self.frame_width, 100))
self.menu_content.blit()
self.menu_content.update()
def launch_blocking_alert(title,
text,
parent=None,
font_size=None,
font_color=None,
ok_text="Ok",
transp=False,
alpha_dialog=200,
func=None,
outside_click_quit=False):
if font_size is None: font_size = thorpy.style.FONT_SIZE
if font_color is None: font_color = thorpy.style.FONT_COLOR
box_alert = make_textbox(title, text, font_size, font_color, ok_text)
box_alert.center()
if transp:
color_transp = tuple(list(thorpy.style.DEF_COLOR)[:3] + [alpha_dialog])
box_alert.set_main_color(color_transp)
def click_quit(e):
if not box_alert.get_fus_rect().collidepoint(e.pos):
thorpy.functions.quit_menu_func()
if outside_click_quit:
box_alert.add_reaction(
thorpy.Reaction(pygame.MOUSEBUTTONDOWN, click_quit))
from thorpy.menus.tickedmenu import TickedMenu
m = TickedMenu(box_alert)
box_alert.get_elements_by_text(
ok_text)[0].user_func = thorpy.functions.quit_menu_func
box_alert.get_elements_by_text(ok_text)[0].user_params = {}
m.play()
box_alert.unblit()
if parent:
parent.partial_blit(None, box_alert.get_fus_rect())
box_alert.update()
if func:
func()
def __init__(self, me, size, cell_size, redraw, external_e):
self.me = me
self.wline = int(0.75*size[0])
self.unit = None
## self.cell = None probleme
self.e_img = thorpy.Image.make(pygame.Surface(cell_size))
## self.e_img = thorpy.Image.make(pygame.Surface((1,1)))
self.blank_img = pygame.Surface(cell_size)
self.e_name = guip.get_text("")
self.e_race = guip.get_text("")
self.e_name_and_race = thorpy.Box([self.e_name, self.e_race])
self.e_name_and_race.fit_children()
ghost = thorpy.Ghost([self.e_img, self.e_name_and_race])
ghost.finish()
self.e_img.set_center_pos(ghost.get_fus_center())
self.e_name.set_center_pos(self.e_img.get_fus_center())
ghost.fit_children()
self.e_group = ghost
#
self.elements = [self.e_group]
self.e = thorpy.Box.make(self.elements)
self.e.set_main_color((20,20,20))
self.e.set_size((size[0],None))
for e in self.e.get_elements():
e.recenter()
## #emap : to be displayed when a cell is clicked
self.em_title = guip.get_title("Unit informations")
## self.em_coord = guip.get_text("")
## self.em_altitude = guip.get_text("")
## self.em_name = guip.get_small_text("")
self.em_rename = guip.get_small_button("Rename", self.rename_current_unit)
## self.em_rename.scale_to_title()
## self.em_name_rename = thorpy.make_group([self.em_name, self.em_rename])
#### self.em_name_rename = thorpy.Clickable.make(elements=[self.em_name, self.em_rename])
#### thorpy.store(self.em_name_rename)
## self.em_name_rename.fit_children()
self.em_unit_img_img = thorpy.Image.make(pygame.Surface(cell_size))
self.em_unit_img = thorpy.Clickable.make(elements=[self.em_unit_img_img])
self.em_unit_img.fit_children()
self.em_unit_name = guip.get_text("")
self.em_unit_race = guip.get_text("")
self.em_nameNrace = thorpy.make_group([self.em_unit_name, self.em_unit_race], "v")
self.em_unit = thorpy.make_group([self.em_unit_img, self.em_nameNrace])
self.em_elements = [self.em_title, thorpy.Line.make(self.wline), self.em_unit, self.em_rename]#self.em_name_rename]
#
self.em_mat_img_img = thorpy.Image.make(pygame.Surface(cell_size))
self.em_mat_img = thorpy.Clickable.make(elements=[self.em_mat_img_img])
self.em_mat_img.fit_children()
def show_terrain_infos():
cell = self.unit.cell
self.me.cell_info.last_cell_clicked = cell
pos = self.me.cam.get_rect_at_coord(cell.coord).center
self.me.cell_info.launch_em(cell, pos, self.me.cam.map_rect)
## self.em_button_cell = guip.get_button("Terrain infos", show_terrain_infos)
self.em_mat_img.user_func = show_terrain_infos
self.em_elements += [thorpy.Line.make(self.wline), self.em_mat_img]
self.em = thorpy.Box.make(self.em_elements)
self.em.set_main_color((200,200,200,150))
self.launched = False
self.redraw = redraw
self.external_e = external_e
reac = thorpy.Reaction(thorpy.THORPY_EVENT, self.set_unlaunched,
{"id":thorpy.constants.EVENT_UNLAUNCH})
external_e.add_reaction(reac)
self.last_cell_clicked = None
self.e_img.visible = False
def __init__(self):
self.level_objects = []
self.spawner_objects = []
self.render_queue = RenderQueue()
self.dragging_object = None
self.dragging_spawner = None
self.selected_object = None
self.selected_spawner = None
self.drag_offset = None
self.zoom = 1.0
self.camera_x = 0
self.camera_y = 0
# Game area
self.game_area = thorpy.Box.make([],
size=(SCREEN_WIDTH, SCREEN_HEIGHT))
self.game_area.set_main_color((220, 255, 220, 0))
# TODO: Add horizontal and vertical scroller to game area
# Level details area
self.level_details_title = thorpy.make_text('Level Details', 18,
(0, 0, 0))
self.level_name_box = thorpy.Inserter.make(name='Name: ',
value='new_level')
load_level_button = thorpy.make_button('Load level', self.load_level)
self.level_width_box = thorpy.Inserter.make(name='Width: ', value='')
self.level_height_box = thorpy.Inserter.make(name='Height: ', value='')
self.gravity_box = thorpy.Inserter.make(name='Gravity: ', value='')
self.jump_height_box = thorpy.Inserter.make(name='Jump height: ',
value='')
self.player_speed_box = thorpy.Inserter.make(name='Player speed: ',
value='')
save_level_button = thorpy.make_button('Save level', self.save_level)
self.level_details_area = thorpy.Box.make([
self.level_details_title, self.level_name_box, load_level_button,
self.level_width_box, self.level_height_box, self.gravity_box,
self.jump_height_box, self.player_speed_box, save_level_button
])
self.level_details_area.fit_children()
# Pattern details area
pattern_details_title = thorpy.make_text('Pattern Details', 18,
(0, 0, 0))
self.pattern_id_box = thorpy.Inserter.make(name='ID: ', value='')
self.image_file_box = thorpy.Inserter.make(name='Image file: ',
value='')
self.pattern_width_box = thorpy.Inserter.make(name='Width: ', value='')
self.pattern_height_box = thorpy.Inserter.make(name='Height: ',
value='')
self.block_data_box = thorpy.Inserter.make(name='Block data: ',
value='')
self.stand_data_box = thorpy.Inserter.make(name='Stand data: ',
value='')
self.climb_data_box = thorpy.Inserter.make(name='Climb data: ',
value='')
self.damage_data_box = thorpy.Inserter.make(name='Damage data: ',
value='')
self.pattern_details_area = thorpy.Box.make([
pattern_details_title, self.pattern_id_box, self.image_file_box,
self.pattern_width_box, self.pattern_height_box,
self.block_data_box, self.stand_data_box, self.climb_data_box,
self.damage_data_box
])
# Object details area
object_details_title = thorpy.make_text('Object Details', 18,
(0, 0, 0))
self.top_box = thorpy.Inserter.make(name='Top: ', value='')
self.left_box = thorpy.Inserter.make(name='Left: ', value='')
self.z_box = thorpy.Inserter.make(name='Z index: ', value='')
self.object_details_area = thorpy.Box.make(
[object_details_title, self.top_box, self.left_box, self.z_box])
def change_z_index(event):
self.selected_object.z_index = str_to_int(event.value)
z_index_reaction = thorpy.Reaction(
reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=change_z_index,
event_args={
'id': thorpy.constants.EVENT_INSERT,
'el': self.z_box
})
self.z_box.add_reaction(z_index_reaction)
self.details_area = thorpy.Box.make([
self.level_details_area, self.pattern_details_area,
self.object_details_area
],
size=(DETAILS_AREA_WIDTH,
SCREEN_HEIGHT))
self.details_area.set_main_color((255, 220, 255, 180))
self.details_area.set_topleft((SCREEN_WIDTH, 0))
self.debug_draw = False
# Patterns area
patterns_title = thorpy.make_text('Patterns', 18, (0, 0, 0))
def click_pattern(pattern_id, surfdata):
position = self.backwardMouseTransform(
(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2))
level_object = LevelObject(
objectDefinition={
'type': pattern_id,
'x': math.floor(position[0] / BLOCK_SIZE),
'y': math.floor(position[1] / BLOCK_SIZE),
'z': 0,
}) # TODO: Do we need to pass in surf data here?
self.level_objects.append(level_object)
# Load the already-created patterns
patterns = []
pattern_objects = []
LevelObjectPattern.init()
with open('patterns.json', 'r') as patterns_file:
patterns_descriptions = json.load(patterns_file)
patterns_temp = list(patterns_descriptions.items())
patterns_temp.sort(key=lambda x: x[0])
for pattern_id, pattern_definition in patterns_temp:
pattern = LevelObjectPattern(pattern_definition, pattern_id)
patterns.append(pattern)
# TODO: Add a small version of the image to this object
pattern_object = thorpy.make_button(
pattern_id,
func=click_pattern,
params={
'pattern_id': pattern_id,
'surfdata': pattern_definition['surfdata']
})
pattern_objects.append(pattern_object)
self.patterns_area = thorpy.Box.make(
[patterns_title, *pattern_objects],
size=(PATTERNS_AREA_WIDTH, SCREEN_HEIGHT))
self.patterns_area.set_main_color((220, 220, 255, 180))
self.patterns_area.set_topleft((SCREEN_WIDTH + DETAILS_AREA_WIDTH, 0))
thorpy.store(self.patterns_area, y=0)
self.patterns_area.refresh_lift()
# Spawners area
def click_add_spawner():
position = self.backwardMouseTransform(
(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2))
spawner_object = Spawner(x=math.floor(position[0] / BLOCK_SIZE),
y=math.floor(position[1] / BLOCK_SIZE),
entity_type='',
spawner_type='',
rate=0.3,
filter='')
self.spawner_objects.append(spawner_object)
spawners_title = thorpy.make_text('Spawners', 18, (0, 0, 0))
add_spawner_button = thorpy.make_button('Add spawner',
func=click_add_spawner,
params={})
# Spawner details area
spawner_details_title = thorpy.make_text('Spawner Details', 18,
(0, 0, 0))
self.spawner_x_box = thorpy.Inserter.make(name='X: ', value='')
self.spawner_y_box = thorpy.Inserter.make(name='Y: ', value='')
self.spawner_entity_type_box = thorpy.Inserter.make(
name='Entity type: ', value='')
self.spawner_filter_box = thorpy.Inserter.make(name='Filter: ',
value='')
self.spawner_spawner_type_box = thorpy.Inserter.make(
name='Spawner type: ', value='')
self.spawner_rate_box = thorpy.Inserter.make(name='Rate: ', value='')
def change_spawner_entity_type(event):
self.selected_spawner.entity_type = event.value
def change_spawner_filter(event):
self.selected_spawner.filter = event.value
def change_spawner_spawner_type(event):
self.selected_spawner.spawner_type = event.value
def change_spawner_rate(event):
self.selected_spawner.rate = str_to_float(event.value)
entity_type_reaction = thorpy.Reaction(
reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=change_spawner_entity_type,
event_args={
'id': thorpy.constants.EVENT_INSERT,
'el': self.spawner_entity_type_box
})
filter_reaction = thorpy.Reaction(
reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=change_spawner_filter,
event_args={
'id': thorpy.constants.EVENT_INSERT,
'el': self.spawner_filter_box
})
spawner_type_reaction = thorpy.Reaction(
reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=change_spawner_spawner_type,
event_args={
'id': thorpy.constants.EVENT_INSERT,
'el': self.spawner_spawner_type_box
})
rate_reaction = thorpy.Reaction(
reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=change_spawner_rate,
event_args={
'id': thorpy.constants.EVENT_INSERT,
'el': self.spawner_rate_box
})
self.spawner_entity_type_box.add_reaction(entity_type_reaction)
self.spawner_filter_box.add_reaction(filter_reaction)
self.spawner_spawner_type_box.add_reaction(spawner_type_reaction)
self.spawner_rate_box.add_reaction(rate_reaction)
spawner_details_area = thorpy.Box.make([
spawner_details_title,
self.spawner_x_box,
self.spawner_y_box,
self.spawner_spawner_type_box,
self.spawner_entity_type_box,
self.spawner_filter_box,
self.spawner_rate_box,
])
self.spawners_area = thorpy.Box.make(
[spawners_title, add_spawner_button, spawner_details_area],
size=(SPAWNERS_AREA_WIDTH, SCREEN_HEIGHT))
self.spawners_area.set_main_color((255, 255, 220, 180))
self.spawners_area.set_topleft(
(SCREEN_WIDTH + DETAILS_AREA_WIDTH + PATTERNS_AREA_WIDTH, 0))
thorpy.store(self.spawners_area, gap=30)
self.menu = thorpy.Menu([
self.game_area, self.patterns_area, self.details_area,
self.spawners_area
])
def build_gui_elements(self): #worst function ever
e_hmap = thorpy.Image.make(self.cam.img_hmap)
e_hmap.stick_to("screen", "right", "right", False)
e_hmap.add_reaction(thorpy.Reaction(pygame.MOUSEMOTION,
self.func_reac_mousemotion))
e_hmap.add_reaction(thorpy.Reaction(pygame.MOUSEBUTTONDOWN,
self.func_reac_click))
e_hmap.add_reaction(thorpy.Reaction(pygame.MOUSEBUTTONUP,
self.func_reac_unclick))
self.e_hmap = e_hmap
box_hmap = thorpy.Box.make([e_hmap])
box_hmap.fit_children((self.box_hmap_margin,)*2)
thorpy.makeup.add_basic_help(box_hmap,
"Click to move camera on miniature map")
## e_title_hmap = guip.get_text("Map")
## self.topbox = thorpy.make_group([e_title_hmap, box_hmap], "v")
self.topbox = box_hmap
self.box_hmap = box_hmap
########################################################################
self.cam.set_gui_elements(e_hmap, box_hmap)
########################################################################
if len(self.zoom_cell_sizes) > 1:
self.e_zoom = thorpy.SliderX.make(self.menu_width//4, (0, 100),
"Zoom (%)", int, initial_value=100)
def func_reac_zoom(e):
levels = len(self.zoom_cell_sizes) - 1
level = int(levels*self.e_zoom.get_value()/self.e_zoom.limvals[1])
self.set_zoom(levels-level,False)
########################################################################
self.cell_info = gui.CellInfo(self, self.menu_rect.inflate((-10,0)).size,
self.cell_rect.size, self.draw_no_update, e_hmap)
self.unit_info = gui.UnitInfo(self,self.menu_rect.inflate((-10,0)).size,
self.cell_rect.size, self.draw_no_update, e_hmap)
## self.misc_info = gui.MiscInfo(self.menu_rect.inflate((-10,0)).size)
self.menu_button = thorpy.make_menu_button(force_convert_alpha=True)
########################################################################
elements =[ self.topbox,
self.cell_info.e,
self.unit_info.e,
self.menu_button]
if len(self.zoom_cell_sizes) > 1:
elements.insert(0, self.e_zoom)
self.e_box = thorpy.Element.make(elements=elements,
size=self.menu_rect.size)
self.e_box.set_main_color((200,200,200,160))
thorpy.store(self.e_box)
self.e_box.stick_to("screen","right","right")
########################################################################
if len(self.zoom_cell_sizes) > 1:
reac_zoom = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=func_reac_zoom,
event_args={"id":thorpy.constants.EVENT_SLIDE,
"el":self.e_zoom},
reac_name="zoom slide")
self.e_box.add_reaction(reac_zoom)
########################################################################
thorpy.add_keydown_reaction(self.e_box, pygame.K_KP_PLUS,
self.increment_zoom, params={"value":-1},
reac_name="k plus")
thorpy.add_keydown_reaction(self.e_box, pygame.K_KP_MINUS,
self.increment_zoom, params={"value":1},
reac_name="k minus")
wheel_reac1 = thorpy.ConstantReaction(pygame.MOUSEBUTTONDOWN,
self.increment_zoom,
{"button":4},
{"value":1})
wheel_reac2 = thorpy.ConstantReaction(pygame.MOUSEBUTTONDOWN,
self.increment_zoom,
{"button":5},
{"value":-1})
self.e_box.add_reactions([wheel_reac1, wheel_reac2])
########################################################################
velocity = 0.2
thorpy.add_keydown_reaction(self.e_box, pygame.K_LEFT,
self.move_cam_and_refresh,
params={"delta":(-velocity,0)},
reac_name="k left")
thorpy.add_keydown_reaction(self.e_box, pygame.K_RIGHT,
self.move_cam_and_refresh,
params={"delta":(velocity,0)},
reac_name="k right")
thorpy.add_keydown_reaction(self.e_box, pygame.K_UP,
self.move_cam_and_refresh,
params={"delta":(0,-velocity)},
reac_name="k up")
thorpy.add_keydown_reaction(self.e_box, pygame.K_DOWN,
self.move_cam_and_refresh,
params={"delta":(0,velocity)},
reac_name="k down")
########################################################################
self.help_box = gui.HelpBox([
("Move camera",
[("To move the map, drag it with", "<LMB>",
"or hold", "<LEFT SHIFT>", "while moving mouse."),
("The minimap on the upper right can be clicked or hold with",
"<LMB>", "in order to move the camera."),
("The","<KEYBOARD ARROWS>",
"can also be used to scroll the map view.")]),
("Zoom",
[("Use the","zoom slider","or","<NUMPAD +/- >",
"to change zoom level."),
("You can also alternate zoom levels by pressing","<RMB>",".")]),
("Miscellaneous",
[("Press","<g>","to toggle grid lines display.")])
])
thorpy.add_keydown_reaction(self.e_box, pygame.K_g,
self.toggle_show_grid_lines,
reac_name="toggle grid")
Camtype=parameters.get_camera_type()
cam = Camtype(chunk=(0,0), pos=(0,0), seed=SEED,
world_size=parameters.WORLD_SIZE)
core.load_images()
core.compute_parameters()
wind = Wind((-1.,-1.),(1.,1.),(-1., -1.),(1.,1.),(10000,10000))
game = core.Game(cam, wind, climate, e_bckgr)
game.set_ship(Ship(mass=0.3, maxvel=3., life=1., captain=None))
game.refresh_controllables()
reac_time = thorpy.ConstantReaction(thorpy.constants.THORPY_EVENT, game.reac_time, {"id":thorpy.constants.EVENT_TIME})
reac_keydown = thorpy.Reaction(pygame.KEYDOWN, game.reac_keydown)
e_bckgr.add_reaction(reac_keydown)
e_bckgr.add_reaction(reac_time)
gu = gui.GUI(game)
if not savefile:
#configure new game
varset = gui.game_parameters_menu()
#
#difficulty : TREASURE_PROB, MAX_FLAG, FOOD_PER_TURN, MAX_CAMPS, OASIS_PROB
difficulties = {"easy":(1., 10, 1, 5, 1.),
"medium":(0.8, 5, 1, 3, 0.8),
"hard":(0.4, 3, 1, 1, 0.7)}
seed = varset.get_value("seed")
## seed = 42877
def __init__(self):
## if not parameters.canonic_vessels:
## get_all_parts()
self.vessel = parameters.player.vessel.get_copy()
self.ovessel = parameters.player.vessel
self.screen = thorpy.get_screen()
#
light_pos = V3(0,1000,-1000)
light_m = V3(20,20,20)
light_M = V3(200,200,200)
self.light = light.Light(light_pos, light_m, light_M)
#
self.e_bckgr = thorpy.Background.make((255,255,255))
self.vessel.set_pos(parameters.GARAGE_POS)
reaction = thorpy.ConstantReaction(thorpy.THORPY_EVENT,
self.refresh_display,
{"id":thorpy.constants.EVENT_TIME})
self.e_bckgr.add_reaction(reaction)
reaction = thorpy.Reaction(pygame.MOUSEMOTION, self.mousemotion)
self.e_bckgr.add_reaction(reaction)
#
self.viewport = pygame.Surface((400,400))
self.viewport_color = (200,200,200)
self.viewport_rect = pygame.Rect((0,0),self.viewport.get_size())
self.viewport_rect.right = parameters.W - 20
self.viewport_rect.centery = parameters.H//2
self.cam = camera.Camera(self.viewport, fov=512, d=2, objs=[])
#
#
#
self.e_ok = thorpy.make_button("Go to next race", func=thorpy.functions.quit_menu_func)
self.e_ok.set_main_color((0,255,0))
self.e_ok.set_font_size(thorpy.style.FONT_SIZE+3)
self.e_ok.scale_to_title()
#
#
def refresh_repair():
damages = str(round(100.*(1. - self.ovessel.life/self.ovessel.max_life)))
self.e_damage.set_text("Vessel damages: " + damages + "%")
self.e_money.set_text("Money: "+str(parameters.player.money)+" $")
def choice_repair():
cost = (self.ovessel.max_life - self.ovessel.life)*300
if cost <= parameters.player.money:
if thorpy.launch_binary_choice("Are you sure? This will cost "+\
str(cost)+"$"):
self.ovessel.life = self.ovessel.max_life
parameters.player.money -= cost
refresh_repair()
elif thorpy.launch_binary_choice("Repairing costs "+str(cost)+\
" $. You don't have enough money.\n"+\
"Do you want to use all your money for"+\
" repairing as much as possible?"):
#(after_repair - self.ovessel.life)*300 = money
#==> after_repair = money/300 + self.ovessel.life
repaired = int(parameters.player.money/300. + self.ovessel.life)
parameters.player.money -= (repaired - self.ovessel.life)*300
self.ovessel.life = repaired
refresh_repair()
self.e_bckgr.blit()
self.refresh_display()
pygame.display.flip()
self.e_repair = thorpy.make_button("Repair vessel",choice_repair)
#
damages = str(round(100.*(1. - self.ovessel.life/self.ovessel.max_life)))
self.e_damage = thorpy.make_text("Vessel damages: " + damages + "%")
self.e_ranking = thorpy.make_button("See rankings", launch_rankings, {"garage":self})
## self.e_ranking = get_rankings_box()
def quit_forever():
if thorpy.launch_binary_choice("Are you sure ?"):
thorpy.functions.quit_func()
else:
self.e_bckgr.unblit_and_reblit()
self.e_menu = thorpy.make_button("Stop career and die (forever)",
func=quit_forever)
self.e_menu.set_main_color((255,0,0))
self.e_menu.set_font_size(thorpy.style.FONT_SIZE-2)
self.e_menu.scale_to_title()
#
vw,vh = self.viewport_rect.size
self.e_viewport_frame = thorpy.Element()
painter = thorpy.painterstyle.ClassicFrame((vw+3,vh+3),
color=self.viewport_color,
pressed=True)
self.e_viewport_frame.set_painter(painter)
self.e_viewport_frame.finish()
self.e_viewport_frame.set_center(self.viewport_rect.center)
#
import hud
fuel = str(round(100*self.ovessel.engine.fuel/self.ovessel.engine.max_fuel))
self.e_fuel = hud.LifeBar("Fuel: "+fuel+" %",text_color=(255,0,0),size=(100,30))
self.e_fuel.set_life(self.ovessel.engine.fuel/self.ovessel.engine.max_fuel)
def refresh_refuel():
life = self.ovessel.engine.fuel / self.ovessel.engine.max_fuel
self.e_fuel.set_life(life)
self.e_fuel.set_text("Fuel: "+str(round(life*100))+" %")
self.e_money.set_text("Money: "+str(parameters.player.money)+" $")
def choice_refuel():
cost = (self.ovessel.engine.max_fuel - self.ovessel.engine.fuel)//2
if cost <= parameters.player.money:
if thorpy.launch_binary_choice("Are you sure? This will cost "+\
str(cost)+"$"):
self.ovessel.engine.fuel = self.ovessel.engine.max_fuel
parameters.player.money -= cost
refresh_refuel()
## self.e_fuel.set_life(1.)
## self.e_fuel.set_life_text("Fuel: 100 %")
## parameters.player.money -= cost
## self.e_money.set_text("Money: "+str(parameters.player.money)+" $")
## self.ovessel.engine.fuel = self.ovessel.engine.max_fuel
elif thorpy.launch_binary_choice("Refueling costs "+str(cost)+" $. You don't have enough money.\n"+\
"Do you want to spend all your money to refuel as much as possible?"):
#cost = (newfuel - fuel)//2 ==> 2*cost + fuel = newfuel
self.ovessel.engine.fuel += 2*parameters.player.money
parameters.player.money = 0
refresh_refuel()
## thorpy.launch_blocking_alert("Refueling costs "+str(cost)+" $. You don't have enough money.")
self.e_bckgr.blit()
self.refresh_display()
pygame.display.flip()
self.e_refuel = thorpy.make_button("Refuel",choice_refuel)
self.e_money = thorpy.make_text("Money: "+str(parameters.player.money)+" $",
thorpy.style.TITLE_FONT_SIZE,(255,0,0))
self.e_money.stick_to("screen","top","top")
self.e_money.move((0,30))
#
self.e_box = thorpy.Box.make([self.e_damage,self.e_repair,
thorpy.Line.make(100,"h"),self.e_fuel,
self.e_refuel,
thorpy.Line.make(100,"h"),
self.e_ranking,self.e_ok])
self.e_bckgr.add_elements([self.e_box,self.e_menu])
thorpy.store(self.e_bckgr, x = 200)
self.e_skills = get_vessel_element(parameters.player.vessel)
self.e_bckgr.add_elements([self.e_viewport_frame,self.e_money,
self.e_skills])
self.e_menu.move((0,30))
self.e_skills.stick_to(self.e_viewport_frame, "left", "right")
self.i = 0
#Quit button
quit = thorpy.make_button("QUIT", func=thorpy.functions.quit_menu_func)
quit.set_font_size(40)
quit.set_font("Bahnschrift SemiBold")
quit.set_main_color((0,148,0))
quit.set_font_color((255,255,255))
quit.set_size((200,100))
quit.center()
def start_game(event):
b = boardGUI.GUI()
b.board()
game_reaction = thorpy.Reaction(reacts_to=pygame.MOUSEBUTTONDOWN, reac_func=start_game)
start.add_reaction(game_reaction)
#Setting background and adding elements to background
background = thorpy.Background(color=(0, 102, 204),
elements=[pic_button, title, start, quit])
thorpy.store(background)
#Adding background to menu and launching menu.
menu = thorpy.Menu(background)
menu.play()
def create_menu(self):
self.lane1_button = thorpy.make_button("Lane 1 Color Choice",
func=self.lane1_update)
self.lane2_button = thorpy.make_button("Lane 2 Color Choice",
func=self.lane2_update)
self.object_button = thorpy.make_button("Object Color Choice",
func=self.object_update)
self.finish_button = thorpy.make_button("Finish Line Color Choice",
func=self.finish_update)
self.disable_obstacle_button = thorpy.make_button(
("Disable Obstacle Detection"), func=self.obstacle_update)
self.stop_button = thorpy.make_button("STOP!!", func=self.stop_update)
self.quit_button = thorpy.make_button("Quit",
func=thorpy.functions.quit_func)
self.Upper_Hue_Inserter = thorpy.Inserter.make(name="Upper Hue:",
value="0")
self.Upper_Saturation_Inserter = thorpy.Inserter.make(
name="Upper Sat:", value="0")
self.Upper_Value_Inserter = thorpy.Inserter.make(name="Upper Value: ",
value="0")
self.Lower_Hue_Inserter = thorpy.Inserter.make(name="Lower Hue: ",
value="0")
self.Lower_Saturation_Inserter = thorpy.Inserter.make(
name="Lower Sat:", value="0")
self.Lower_Value_Inserter = thorpy.Inserter.make(name="Lower Value: ",
value="0")
self.Upper_Canny_Inserter = thorpy.Inserter.make(name="Upper Canny:",
value="0")
self.Lower_Canny_Inserter = thorpy.Inserter.make(name="Lower Canny: ",
value="0")
self.Upper_Hue_Slider = thorpy.SliderX.make(length=100,
limvals=(0,
self.slide_limit),
text="Upper Hue:",
type_=int)
self.Upper_Saturation_Slider = thorpy.SliderX.make(
length=100,
limvals=(0, self.slide_limit),
text="Upper Sat:",
type_=int)
self.Upper_Value_Slider = thorpy.SliderX.make(
length=100,
limvals=(0, self.slide_limit),
text="Upper Value:",
type_=int)
self.Lower_Hue_Slider = thorpy.SliderX.make(length=100,
limvals=(0,
self.slide_limit),
text="Lower Hue:",
type_=int)
self.Lower_Saturation_Slider = thorpy.SliderX.make(
length=100,
limvals=(0, self.slide_limit),
text="Lower Sat:",
type_=int)
self.Lower_Value_Slider = thorpy.SliderX.make(
length=100,
limvals=(0, self.slide_limit),
text="Lower Value:",
type_=int)
self.menu_content = thorpy.Box.make(elements=[
self.lane1_button, self.lane2_button, self.object_button,
self.finish_button, self.disable_obstacle_button, self.stop_button,
self.Upper_Hue_Slider, self.Upper_Saturation_Slider,
self.Upper_Value_Slider, self.Lower_Hue_Slider,
self.Lower_Saturation_Slider, self.Lower_Value_Slider,
self.Upper_Hue_Inserter, self.Upper_Saturation_Inserter,
self.Upper_Value_Inserter, self.Lower_Hue_Inserter,
self.Lower_Saturation_Inserter, self.Lower_Value_Inserter, self.
Upper_Canny_Inserter, self.Lower_Canny_Inserter, self.quit_button
])
self.menu_slide_reaction = thorpy.Reaction(
reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=self.react_slider,
event_args={"id": thorpy.constants.EVENT_SLIDE},
reac_name="slider reaction")
self.menu_content.add_reaction(self.menu_slide_reaction)
self.menu_inserter_reaction = thorpy.Reaction(
reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=self.react_inserter,
event_args={"id": thorpy.constants.EVENT_INSERT},
reac_name="inserter reaction")
self.menu_content.add_reaction(self.menu_inserter_reaction)
self.menu = thorpy.Menu(self.menu_content)
for element in self.menu.get_population():
element.surface = self.screen
self.lane1_update()
self.menu_content.set_topleft((self.frame_width, 100))
self.menu_content.blit()
self.menu_content.update()
def manage_stocks(stock1, stock2):
c = stock1.food + stock2.food #remains constant
class Os1:
v = stock1.food
class Os2:
v = stock2.food
title = thorpy.make_text("Food stock management",
font_size=thorpy.style.FONT_SIZE + 3,
font_color=TCOLOR)
line = thorpy.Line.make(300, "h")
def take_all():
stock1.refood_from(stock2)
thorpy.functions.quit_menu_func()
## print(stock1,stock2)
e_take = thorpy.make_button("Take all", func=take_all)
s1 = thorpy.SliderX.make(length=350,
limvals=(0, stock1.max_food),
text=stock1.name,
type_=int,
initial_value=int(stock1.food))
s2 = thorpy.SliderX.make(length=350,
limvals=(0, stock2.max_food),
text=stock2.name,
type_=int,
initial_value=int(stock2.food))
e1 = thorpy.Box.make(elements=[s1])
e2 = thorpy.Box.make(elements=[s2])
arrow = thorpy.Image.make("doublearrow32.bmp", colorkey=(255, 255, 255))
#
box = thorpy.make_ok_cancel_box([title, line, e_take, e1, arrow, e2])
box.set_main_color((200, 200, 255, 150))
box.center()
#
def refresh_sliders(e):
ns1 = s1.get_value()
ns2 = s2.get_value()
if ns1 + ns2 > c:
s1.unblit_and_reblit_func(s1.set_value, value=Os1.v)
s2.unblit_and_reblit_func(s2.set_value, value=Os2.v)
return
if e.el is s1:
new_value = c - ns1
if new_value > s2.limvals[1]:
new_value = s2.limvals[1]
elif new_value < s2.limvals[0]:
new_value = s2.limvals[0]
s2.unblit_and_reblit_func(s2.set_value, value=new_value)
elif e.el is s2:
new_value = c - ns2
if new_value > s1.limvals[1]:
new_value = s1.limvals[1]
elif new_value < s1.limvals[0]:
new_value = s1.limvals[0]
s1.unblit_and_reblit_func(s1.set_value, value=new_value)
Os1.v, Os2.v = s1.get_value(), s2.get_value()
reaction = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=refresh_sliders,
event_args={"id": thorpy.constants.EVENT_SLIDE})
box.add_reaction(reaction)
def func_ok():
stock1.food = s1.get_value()
stock2.food = s2.get_value()
thorpy.functions.quit_menu_func()
box.e_cancel.user_func = thorpy.functions.quit_menu_func
box.e_cancel.user_params = {}
box.e_ok.user_func = func_ok
box.e_ok.user_params = {}
menu = thorpy.Menu(box)
menu.play()
botao_iniciar_cr = thorpy.make_button("Iniciar", func=iniciar_cr)
botao_iniciar_cr.set_font('Helvetica')
botao_iniciar_cr.set_font_size(18)
botao_iniciar_cr.set_size((100, 50))
botao_iniciar_cr.set_main_color((100, 255, 100))
botao_parar_cr = thorpy.make_button("Parar", func=parar_cr)
botao_parar_cr.set_font('Helvetica')
botao_parar_cr.set_font_size(18)
botao_parar_cr.set_size((100, 50))
botao_parar_cr.set_main_color((255, 100, 100))
pasta_cr = thorpy.Inserter(name="Nome da pasta de destino:")
#Reacoes Controle Remoto
reacao_pasta_cr = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=pasta_destino_cr,
event_args={
"id": thorpy.constants.EVENT_INSERT,
"el": pasta_cr
})
#Launcher do modo controle remoto
caixa_cr = thorpy.make_ok_box([
titulo_cr, inv4, texto_cr, inv5, botao_iniciar_cr, inv6, botao_parar_cr,
inv7, pasta_cr, inv8
])
caixa_cr.set_main_color((200, 220, 230))
caixa_cr.fit_children(margins=(20, 20))
caixa_cr.add_reaction(reacao_pasta_cr)
botao_cr = thorpy.make_button("Controle Remoto")
botao_cr.set_font_size(17)
botao_cr.set_font_color((40, 40, 40))
botao_cr.set_size((200, 50))
def __init__(self,
title,
ok_text,
ranking,
results=False,
choosevessel=False):
refresh_ranking()
#
light_pos = V3(0, 1000, -1000)
light_m = V3(20, 20, 20)
light_M = V3(200, 200, 200)
self.light = light.Light(light_pos, light_m, light_M)
self.viewport = pygame.Surface((400, int(parameters.H * 0.6)))
self.viewport_color = (200, 200, 200)
self.viewport.fill(self.viewport_color)
self.viewport_rect = pygame.Rect((0, 0), self.viewport.get_size())
self.viewport_rect.centerx = parameters.W // 2 + 100
self.viewport_rect.centery = parameters.H // 2
self.cam = camera.Camera(self.viewport, fov=512, d=2, objs=[])
self.screen = thorpy.get_screen()
self.displayed_vessel = None
self.i = 0
#
if results:
ranking[0].points += 1
ranking[0].money += 300 + (parameters.NPLAYERS -
ranking[0].ranking) * 100
ranking[2].points -= 1
ranking[2].money += 100
ranking[1].money += 200
if ranking[2].points < 0: ranking[2].points = 0
#
self.trophy = None
if choosevessel:
self.e_players = []
def other_vessel():
self.vessels[0] = create_vessel(parameters.HERO_COLOR)
self.vessels[0].set_pos(V3(0, -1 * 4.5, 20))
self.vessels[0].move(V3(0, 4, 0))
self.displayed_vessel = self.vessels[0]
#replace self.ve
new_ve = get_vessel_element(self.vessels[0])
self.e_bckgr.replace_element(self.ve, new_ve)
thorpy.functions.refresh_current_menu()
self.ve = new_ve
self.e_bckgr.unblit_and_reblit()
b = thorpy.make_button("Generate another vessel", other_vessel)
c = thorpy.make_button("Done", thorpy.functions.quit_menu_func)
self.e_players.append(b)
self.e_players.append(c)
from main import create_vessel
self.vessels = [create_vessel(parameters.HERO_COLOR)]
self.displayed_vessel = self.vessels[0].get_copy()
self.ve = get_vessel_element(self.vessels[0])
self.e_players.append(self.ve)
else:
if results:
self.e_players = [
p.get_element(str(i + 1) + ") ")
for i, p in enumerate(ranking)
]
else:
self.e_players = [
p.get_element() for i, p in enumerate(ranking)
]
self.vessels = [p.vessel.get_copy() for p in ranking]
if results:
import core3d
from light import Material
self.trophy = core3d.Object3D("trophy1.stl")
self.trophy.set_color(Material((255, 215, 0)))
## self.trophy.set_color((255,255,0))
self.trophy.set_pos(V3(5., -0 * 4.5 - 0.2, 15))
self.trophy.rotate_around_center_z(90.)
self.trophy.rotate_around_center_x(-65.)
self.trophy.move(V3(0, 4, 0))
self.background = thorpy.load_image("background1.jpg")
self.background = thorpy.get_resized_image(
self.background, (parameters.W, parameters.H // 2), type_=max)
self.e_bckgr = thorpy.Background.make(image=self.background,
elements=self.e_players)
#
vw, vh = self.viewport_rect.size
self.e_viewport_frame = thorpy.Element()
painter = thorpy.painterstyle.ClassicFrame((vw + 3, vh + 3),
color=self.viewport_color,
pressed=True)
self.e_viewport_frame.set_painter(painter)
self.e_viewport_frame.finish()
self.e_viewport_frame.set_center(self.viewport_rect.center)
#
reaction = thorpy.ConstantReaction(thorpy.THORPY_EVENT,
self.refresh_display,
{"id": thorpy.constants.EVENT_TIME})
self.e_bckgr.add_reaction(reaction)
if not choosevessel:
for i, v in enumerate(self.vessels):
pos = self.e_players[i].get_fus_rect().center
v.set_pos(V3(0, -i * 4.5, 20))
v.move(V3(0, 4, 0))
else:
self.vessels[0].set_pos(V3(0, -1 * 4.5, 20))
self.vessels[0].move(V3(0, 4, 0))
#
self.displayed_vessel.set_pos(V3(0, -1 * 4.5, 20))
self.displayed_vessel.move(V3(0, 4, 0))
#
thorpy.store(self.e_bckgr, gap=40)
for e in self.e_players:
e.stick_to(self.viewport_rect, "left", "right", align=False)
e.move((-5, 0))
self.e_title = get_etitle(title)
if not choosevessel:
self.e_ok = get_eok(ok_text)
self.e_bckgr.add_elements(
[self.e_viewport_frame, self.e_title, self.e_ok])
else:
self.e_bckgr.add_elements([self.e_viewport_frame, self.e_title])
self.goback = False
def return_garage():
self.derotate()
self.goback = True
thorpy.functions.quit_menu_func()
if not results and not choosevessel:
self.e_back = thorpy.make_button("Return to garage", return_garage)
self.e_back.stick_to(self.e_ok, "left", "right")
self.e_back.move((-20, 0))
self.e_bckgr.add_elements([self.e_back])
if not results:
reaction = thorpy.Reaction(pygame.MOUSEMOTION, self.mousemotion)
self.e_bckgr.add_reaction(reaction)
m = thorpy.Menu(self.e_bckgr)
m.play()
def apploop(DISPLAY):
global display_height, display_width
#main app loo
pygame.display.set_caption('Planetbox')
pygame.display.set_icon(ico)
display_width, display_height = DISPLAY.get_size()
DISPLAY.fill(RICHBLUE)
#display background
Bg = Background('../imgs/bg.jpg', [0, 0])
DISPLAY.blit(
pygame.transform.scale(Bg.image, (display_width, display_height)),
Bg.rect)
#display sky preview
Skyprev = SkyPrev(DISPLAY)
#update
pygame.display.update()
#thorpy elements
#logo
logo = pygame.image.load('../imgs/logo300.png')
def radius_check(radius, type):
if (type == "terrestrial"):
if (radius < 300):
return 0
else:
return 1
elif (type == "ice" or type == "gas"):
if (radius < 200):
return 0
else:
return 1
# checks if the density is ok
def density_check(ptype, pmass, prad):
# pmass: 10^22 kg, prad: km
rad = prad * 100000 # radius in cm
vol = (4 / 3) * math.pi * rad * rad * rad # cm3
mass = pmass * pow(10, 25) # g
g = mass / vol # g/cm3
if ptype == "terrestrial":
if (g < 3.6): # not sure about this one
return 0
elif (g > 28):
return 1
else:
return 2
elif ptype == "gas" or ptype == "ice":
if (g < 0.2): # not sure about this one
return 0
elif (g > 17):
return 1
else:
return 2
#Reading inputs functions
def read_inserter_func(
event): #Reactions functions must take an event as first arg
global prad, pmass, pname, pdist
try:
if (event.el == p_rad):
prad = event.el.get_value()
prad = int(prad)
elif (event.el == p_dist):
pdist = event.el.get_value()
pdist = float(pdist)
elif (event.el == p_mass):
pmass = event.el.get_value()
pmass = int(pmass)
elif (event.el == p_name):
pname = event.el.get_value()
elif (event.el == p_kind):
ptype = event.el.get_value()
except: # handling errors
AlertBox.AlertBox(1, "valueError")
p_rad.set_value("")
p_dist.set_value("")
p_mass.set_value("")
p_rad.unblit_and_reblit()
p_dist.unblit_and_reblit()
p_mass.unblit_and_reblit()
def reset_simulation():
simulation.Planets = []
simulation.PlanetsCord = []
SkyPrev(DISPLAY)
# pressing add planet btn reaction
def readPlanet():
global prad, pmass, pname, ptype, simulation, pdist
ptype = p_kind.get_selected().get_text()
den_val = density_check(ptype, pmass, prad)
rad_val = radius_check(prad, ptype)
if den_val == 0 or den_val == 1: # wrong density
AlertBox.AlertBox(den_val, "density")
elif rad_val == 0: # radius too small
AlertBox.AlertBox(rad_val, "radius")
else:
#print(ptype)
# create a new planet
# clean the inserters
p_rad.set_value("")
p_rad.unblit_and_reblit()
p_dist.set_value("")
p_dist.unblit_and_reblit()
p_mass.set_value("")
p_mass.unblit_and_reblit()
p_name.set_value("")
p_name.unblit_and_reblit()
planet = Planet.Planet(prad, pmass, ptype, pdist, pname)
simulation.AddPlanet(planet)
# update preview
SkyPrev(DISPLAY)
def startExplorer():
#print("Starting explorer...")
planetExp.pe_main()
def startSimulation():
#simulation.CreateMoons()
#print("Starting simulation...")
print(simulation.PrintPlanets())
simulation_gui.create(simulation)
# add button: adds planet to a list and updates prev
addBtn = thorpy.make_button("Add planet", func=readPlanet)
addBtn.set_size((120, 20))
addBtn.set_main_color(RICHBLUE)
addBtn.set_font_color(WHITE)
# new window: starts simulation
startBtn = thorpy.make_button("Start simulation", func=startSimulation)
startBtn.set_size((120, 20))
startBtn.set_main_color(RICHBLUE)
startBtn.set_font_color(WHITE)
# explore planets: lets u choose a planet and prints info about it and moons simulation
prevBtn = thorpy.make_button("Explore the planets", func=startExplorer)
prevBtn.set_size((120, 20))
prevBtn.set_main_color(RICHBLUE)
prevBtn.set_font_color(WHITE)
# reset simulation
resBtn = thorpy.make_button("Reset simulation", func=reset_simulation)
resBtn.set_size((120, 20))
resBtn.set_main_color(RICHBLUE)
resBtn.set_font_color(WHITE)
# radius input
p_rad_txt = thorpy.OneLineText(text="Radius of the planet(km):")
p_rad = thorpy.Inserter(name="", value="", size=(100, 20))
radReact = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=read_inserter_func,
event_args={
"id": thorpy.constants.EVENT_INSERT,
"el": p_rad
})
p_rad.add_reaction(radReact)
# distance to the sun input
p_dist_txt = thorpy.OneLineText(text="Distance to the sun (AU):")
p_dist = thorpy.Inserter(name="", value="", size=(100, 20))
distReact = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=read_inserter_func,
event_args={
"id": thorpy.constants.EVENT_INSERT,
"el": p_dist
})
p_dist.add_reaction(distReact)
# name input
p_name_txt = thorpy.OneLineText(text="Name of the planet: ")
p_name = thorpy.Inserter(name="", value="", size=(100, 20))
nameReact = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=read_inserter_func,
event_args={
"id": thorpy.constants.EVENT_INSERT,
"el": p_name
})
p_name.add_reaction(nameReact)
# mass input
p_mass_txt = thorpy.OneLineText(text="Mass of the planet (10^22 kg):")
p_mass = thorpy.Inserter(name="", value="", size=(100, 20))
massReact = thorpy.Reaction(reacts_to=thorpy.constants.THORPY_EVENT,
reac_func=read_inserter_func,
event_args={
"id": thorpy.constants.EVENT_INSERT,
"el": p_mass
})
p_mass.add_reaction(massReact)
# type of planet input
radio_txt = thorpy.make_text("Type of the planet: ")
radios = [
thorpy.Checker("gas", type_="radio"),
thorpy.Checker("ice", type_="radio"),
thorpy.Checker("terrestrial", type_="radio")
]
p_kind = thorpy.RadioPool(radios, first_value=radios[1], always_value=True)
# title above the preview
prev_txt = thorpy.make_text("Preview of the planetary system: ", 24, WHITE)
prev_txt.set_font("Ubuntu.ttf")
prev_txt.set_topleft((420, 200))
# blit thingies
entries = [
p_rad_txt, p_rad, p_mass_txt, p_mass, p_dist_txt, p_dist, p_name_txt,
p_name
]
txts = [radio_txt]
buttons = [addBtn, prevBtn, startBtn, resBtn]
elements = entries + txts + radios + buttons
boxBtn = thorpy.Box.make(elements=elements)
boxBtn.set_main_color(WHITE)
boxBtn.set_size((260, 500))
thorpy.store(boxBtn, elements, align="center")
menu = thorpy.Menu(elements=[prev_txt, boxBtn])
for element in menu.get_population():
element.surface = DISPLAY
boxBtn.set_topleft((40, 50))
boxBtn.blit()
boxBtn.update()
prev_txt.blit()
prev_txt.update()
DISPLAY.blit(logo, (390, 20))
pygame.display.flip()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
quit()
if event.type == pygame.VIDEORESIZE:
DISPLAY = pygame.display.set_mode(
event.dict['size'],
pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.RESIZABLE)
DISPLAY.blit(
pygame.transform.scale(Bg.image, event.dict['size']),
(0, 0))
display_width, display_height = event.dict['size']
apploop(DISPLAY)
pygame.display.flip()
menu.react(event)
p.append((int(x),int(y)))
if USE_LIGHT:
color = light.get_color(t)
else:
color = t.color
## print(color)
## color = t.color
## print(p)
gfx.filled_trigon(screen, p[0][0], p[0][1], p[1][0], p[1][1], p[2][0], p[2][1], color)
gfx.aatrigon(screen, p[0][0], p[0][1], p[1][0], p[1][1], p[2][0], p[2][1], color)
i+=1
pygame.display.flip()
##thorpy.application.SHOW_FPS = True
reac = thorpy.Reaction(pygame.KEYDOWN,func)
##reac = thorpy.Reaction(thorpy.THORPY_EVENT,func,{"id":thorpy.constants.EVENT_TIME})
app = thorpy.Application((800,600))
screen = thorpy.get_screen()
cam = Camera(screen, fov=512, d=2)
g = thorpy.Ghost.make()
g.add_reaction(reac)
m = thorpy.Menu(g,fps=100)
m.play()
app.quit()
