def setup(self):
"""
initiates this screens attributes\n
:return: None
"""
Screen.setup(self)
self._get_background().fill(resource.get_color("startmenu_background").rgb())
self.__btns["START"] = TextButton(resource.get_string("btn_start_text"))
self.__btns["INFO"] = TextButton(resource.get_string("btn_info_text"))
self.__btns["EXIT"] = TextButton(resource.get_string("btn_exit_text"))
screen_mid_w = (self.get_width() / 2)
# game title
dimen_title = resource.get_dimen("startscreen_title")
game_title = resource.get_string("game_title")
font_res = resource.get_font("startscreen_title")
col = resource.get_color("startmenu_gametitle").rgb()
font = pygame.font.SysFont(font_res.name, font_res.size)
self.__text = font.render(game_title, 0, col)
self.__text_dimen = resource.get_dimen("startscreen_title")
self.__text_dimen.x = screen_mid_w - dimen_title.width
# set buttons position
button_marg = resource.get_dimen("button_marg")
for i, btn in enumerate(self.get_btns().itervalues()):
x = screen_mid_w - (btn.get_width() / 2)
y = button_marg.top + ((i + 1) * button_marg.dist)
btn.set_pos(x, y)
def __init__(self):
"""
"""
ViewScreen.__init__(self)
self._font_res = resource.get_font("info")
self._font = pygame.font.SysFont(self._font_res.name,
self._font_res.size)
self._font_header = pygame.font.SysFont(self._font_res.name,
self._font_res.size, True)
self._dimen_article_padd = resource.get_dimen("info_article_padd")
self.get_btns()["BACK"] = TextButton(
resource.get_string("btn_back_text"),
resource.get_dimen("info_btn_back"))
def __create_gameinfo_view(self):
"""
creates a Surface containing gameinfo\n
:return:
"""
text_content = resource.get_string("info_gameinfo_text")
rows = tools.divide_to_rows(
resource.get_value("info_gameinfo_maxwidth"), text_content)
header = self.__gameinfo_header_value.upper()
article_dimen_wh = self._get_article_size(header, rows)
surf = pygame.Surface(article_dimen_wh)
surf.fill(self.__article_background_color)
self._blit_rows(surf, header, self.__text_color, rows)
return surf
class GameController(Controller):
"""
controller for use-case: game\n
:author: Mikael Holmbom
:version: 1.0
"""
__game_title = resource.get_string("game_title")
__gamefield_dimen = resource.get_dimen("gamefield")
## GAMELOGIC
####################
__timespan_add_packet = resource.get_value("timespan_add_packet_start")
__timespan_add_packet_factor_decr_factor = resource.get_value("timespan_add_packet_factor_decr_factor")
## GAMEOBJECTS
###################
# users gameobject
__player = None
__points_to_next_level = resource.get_value("points_exp_level_up_start")
__points_exp_needed_factor = resource.get_value("points_exp_needed_factor")
# contain current games CPUs
__cpus = None
# current packets not contained in buffer
__pending_packet = None
__buffer = None
__trash = None
"""
memento object of this instance
"""
__memento = None
__endstate = None
def __init__(self):
"""
initialize gameengine\n
defines screen and init pygame
"""
Controller.__init__(self)
self.__player = Player()
self.__buffer = Buffer(resource.get_value("buffer_capacity"))
self.__cpus = []
self.__pending_packet = []
self.__endstate = EndState()
def setup(self):
"""
setup the attributes of this gameengine\n
:return:
"""
Controller.setup(self)
self.__create_memento()
n_cpus = resource.get_value("n_cpus")
packet_val_min = resource.get_value("packet_val_min")
packet_val_max = resource.get_value("packet_val_max")
self.__trash = Trash()
trash_dimen = resource.get_dimen("trash")
self.__trash.set_pos(trash_dimen.x, trash_dimen.y)
# generates cpus with unique values
vals = tools.unique_vals(n_cpus, packet_val_min, packet_val_max)
for val in vals:
self.__cpus.append(CPU(val))
for i in range(0, resource.get_value("buffer_size_start")):
self.add_packet()
player_dimen = resource.get_dimen("player")
self.__player.set_pos(player_dimen.x, player_dimen.y)
def __collide_detection(self, obj, (x, y)):
"""
detect if movement will result in a collision with wall, if so the movements will be modified to not collide\n
:param obj: object to determine collision
:type obj: src.game.gameobjects.GameObject
:param (x, y): the relative movement direction
:type (x, y): (int, int)
:return: the
"""
o_rect = obj.get_rect()
## COLLISION WITH WALL
gf_w, gf_h = self.get_gamefield_dimen().wh()
if x < 0: # left movement
dist = o_rect.left
if dist + x < 0:
x = dist * -1 # -1 because of negative direction
elif x > 0: # right movement
dist = gf_w - o_rect.right
if x > dist:
x = dist
if y < 0: # up movement
dist = o_rect.top
if dist + y < 0:
y = dist * -1 # -1 because of negative direction
elif y > 0: # down movement
dist = gf_h - o_rect.bottom
if y > dist:
y = dist
return x, y
class ResultScreen(ViewScreen):
"""
Screen used for use-case: result\n
:author: Mikael Holmbom
:version: 1.0
"""
__endstate = None
__article_player= None
__article_player_pos = None
__article_player_color = resource.get_color("result_article_player").rgb()
__background_color = resource.get_color("resultscreen_background").rgb()
__text_color = resource.get_color("resultscreen_text").rgb()
__header_result = resource.get_string("result_header_player")
def __init__(self):
ViewScreen.__init__(self)
self._dimen_article_padd = resource.get_dimen("result_article_padd")
def set_endstate(self, endstate):
"""
set this endstate to display as result\n
:param endstate:
:return:
"""
self.__endstate = endstate
def setup(self):
ViewScreen.setup(self)
self._get_background().fill(self.__background_color)
self._font_res = resource.get_font("result_playerinfo")
self._font = pygame.font.SysFont(self._font_res.name, self._font_res.size, self._font_res.style_bold, self._font_res.style_italic)
self._font_res_header = resource.get_font("result_header")
self._font_header = pygame.font.SysFont(self._font_res_header.name, self._font_res_header.size, self._font_res_header.style_bold,self._font_res_header.style_italic)
self.__article_player = self.__create_playerinfo_view()
def __create_playerinfo_view(self):
"""
create article displaying player result\n
:return:
"""
es = self.__endstate
rows = []
rows.append("score : " + str(es.score))
rows.append("level : " + str(es.level))
header = self.__header_result.upper()
width, height = self._get_article_size(header, rows)
surf = pygame.Surface((width, height))
surf.fill(self.__article_player_color)
main_surf = self._get_main_surface()
mid_x = (main_surf.get_width() / 2) - (width / 2)
mid_y = (main_surf.get_height() / 2) - (height / 2)
self.__article_player_pos = mid_x, mid_y
self._blit_rows(surf, header, self.__text_color, rows)
return surf
def render(self):
ViewScreen.render(self)
mainsurf = self._get_main_surface()
mainsurf.blit(self.__article_player, self.__article_player_pos)
def start_game():
i = StartMenuInterface()
pygame.display.set_caption(resource.get_string("game_title"))
i.maindisplay()
class InfoScreen(ViewScreen):
"""
screen used for use-case info\n
:author: Mikael Holmbom
:version: 1.0
"""
__text_color = resource.get_color("info_text").rgb()
__article_background_color = resource.get_color(
"info_article_background").rgb()
__controls_view = None
__controls_dimen = resource.get_dimen("info_article_controls")
__gameinfo_view = None
__gameinfo_dimen = resource.get_dimen("info_article_gameinfo")
__gameinfo_header_value = resource.get_string("info_header_gameinfo")
__controls_header_value = resource.get_string("info_header_controls")
def __init__(self):
"""
"""
ViewScreen.__init__(self)
self._font_res = resource.get_font("info")
self._font = pygame.font.SysFont(self._font_res.name,
self._font_res.size)
self._font_header = pygame.font.SysFont(self._font_res.name,
self._font_res.size, True)
self._dimen_article_padd = resource.get_dimen("info_article_padd")
self.get_btns()["BACK"] = TextButton(
resource.get_string("btn_back_text"),
resource.get_dimen("info_btn_back"))
def setup(self):
"""
:return:
"""
ViewScreen.setup(self)
self._get_background().fill(
resource.get_color("infoscreen_background").rgb())
# set back button position
btn_back = self.get_btns()["BACK"]
btn_y = self.get_height() - btn_back.get_height() - btn_back.get_dimen(
).bottom
btn_back.set_pos(btn_back.get_dimen().left, btn_y)
self.update()
def update(self):
"""
:return:
"""
self.__controls_view = self.__create_controls_view()
self.__gameinfo_view = self.__create_gameinfo_view()
def render(self):
"""
:return:
"""
main_surf = self._get_main_surface()
main_surf.blit(self._get_background(), (0, 0))
main_surf.blit(self.__controls_view, self.__controls_dimen.pos())
main_surf.blit(self.__gameinfo_view, self.__gameinfo_dimen.pos())
for btn in self.get_btns().itervalues():
self._blit(btn)
def __create_controls_view(self):
"""
creates a Surface containing controls information\n
:return:
"""
rows = []
rows.append("__GAME__")
rows.append("left: '" + pygame.key.name(game_controls.key_mov_left) +
"'")
rows.append("up: '" + pygame.key.name(game_controls.key_mov_up) + "'")
rows.append("right: '" + pygame.key.name(game_controls.key_mov_right) +
"'")
rows.append("down: '" + pygame.key.name(game_controls.key_mov_down) +
"'")
rows.append("grab/release packets: '" +
pygame.key.name(game_controls.key_pickup) + "'")
rows.append("enabled/disable sound effects: '" +
pygame.key.name(game_controls.key_switch_sound_enabled) +
"'")
rows.append("")
rows.append("__NAVIGATION__")
rows.append("back: '" + pygame.key.name(nav_controls.key_back) + "'")
rows.append("exit: '" + pygame.key.name(nav_controls.key_quit) + "'")
header = self.__controls_header_value.upper()
width, height = self._get_article_size(header, rows)
surf = pygame.Surface((width, height))
surf.fill(self.__article_background_color)
self._blit_rows(surf, header, self.__text_color, rows)
return surf
def __create_gameinfo_view(self):
"""
creates a Surface containing gameinfo\n
:return:
"""
text_content = resource.get_string("info_gameinfo_text")
rows = tools.divide_to_rows(
resource.get_value("info_gameinfo_maxwidth"), text_content)
header = self.__gameinfo_header_value.upper()
article_dimen_wh = self._get_article_size(header, rows)
surf = pygame.Surface(article_dimen_wh)
surf.fill(self.__article_background_color)
self._blit_rows(surf, header, self.__text_color, rows)
return surf