def new_game(self) -> None:
"""Start a new game."""
from controllers.map_controller import MapController
game = Game()
game.game_state = GameStateModel()
game.game_state.player.pokemons.append(
PokemonModel(pokemons["PIKACHU"], pokemons["PIKACHU"].name, 50, [
LearnedMoveModel(moves["TAIL_WHIP"]),
LearnedMoveModel(moves["TAIL_WHIP"]),
LearnedMoveModel(moves["TAIL_WHIP"]),
LearnedMoveModel(moves["THUNDER_SHOCK"]),
]))
game.game_state.player.pokemons.append(
PokemonModel(pokemons["IVYSAUR"], pokemons["IVYSAUR"].name, 1, [
LearnedMoveModel(moves["TACKLE"]),
LearnedMoveModel(moves["GROWL"]),
LearnedMoveModel(moves["VINE_WHIP"]),
]))
game.game_state.player.pokemons.append(
PokemonModel(
pokemons["BULBASAUR"], pokemons["BULBASAUR"].name, 5, [
LearnedMoveModel(moves["TACKLE"],
moves["TACKLE"].default_pp,
moves["TACKLE"].default_pp),
LearnedMoveModel(moves["GROWL"], moves["GROWL"].default_pp,
moves["GROWL"].default_pp),
LearnedMoveModel(moves["VINE_WHIP"],
moves["VINE_WHIP"].default_pp,
moves["VINE_WHIP"].default_pp),
]))
MapController().load_map(game.game_state.map,
game.game_state.map_players_position)
def player_lost_battle(self) -> None:
"""The player lost the battle. Display a message."""
self._dialog.set_text([
I18n().get("BATTLE.OUT_OF_POKEMON").format(
Game().game_state.player.name),
I18n().get("BATTLE.WHITED_OUT").format(
Game().game_state.player.name)
], self._battle_controller.lost_battle)
def load_map(self, map_file: str, players_position: typing.Tuple[int, int],
players_direction: PlayerDirectionEnum = PlayerDirectionEnum.DOWN):
"""Load the map file.
:param: map_file: The name of the map.
:param: players_position: The tile coordinates of the player's position.
:param players_direction: The direction the player is facing.
"""
Game().game_state.map = map_file
Game().game_state.map_players_position = players_position
self._map = cocos.tiles.load(Game().game_state.map_path())
self._map_scene = MapScene(self, self._map, Game().game_state.map_players_position, players_direction)
def next_previous_pokemon(self, selected_action: ActionEnum) -> None:
"""Show the previous or next pokemon."""
pokemon_index = Game().game_state.player.pokemons.index(
self.
_pokemon) - 1 if selected_action == ActionEnum.PREVIOUS else Game(
).game_state.player.pokemons.index(self._pokemon) + 1
self._pkmn_infos_controller.show_pkmn_infos(
pkmn_infos_type=self._pkmn_infos_type,
pokemon=Game().game_state.player.pokemons[pokemon_index],
selected_action=selected_action,
replace=True,
battle=self._battle,
new_move=None,
cancel_callback=self._cancel_callback)
def step(self, dt: int) -> None:
super().step(dt)
if self.target.parent.is_event_handler:
if PlayerLayer.keyboard[Game().settings.controls[
ControlsEnum.CANCEL]]:
self.target.parent.players_walk = PlayerLayer.PLAYER_RUNNING
else:
self.target.parent.players_walk = PlayerLayer.PLAYER_WALKING
if self.target.parent.time_left_moving == 0:
if PlayerLayer.keyboard[Game().settings.controls[
ControlsEnum.RIGHT]] or PlayerLayer.keyboard[Game(
).settings.controls[
ControlsEnum.LEFT]] or PlayerLayer.keyboard[Game(
).settings.controls[
ControlsEnum.UP]] or PlayerLayer.keyboard[Game(
).settings.controls[ControlsEnum.DOWN]]:
if PlayerLayer.keyboard[Game().settings.controls[
ControlsEnum.UP]]:
direction = PlayerDirectionEnum.UP
elif PlayerLayer.keyboard[Game().settings.controls[
ControlsEnum.LEFT]]:
direction = PlayerDirectionEnum.LEFT
elif PlayerLayer.keyboard[Game().settings.controls[
ControlsEnum.RIGHT]]:
direction = PlayerDirectionEnum.RIGHT
else:
direction = PlayerDirectionEnum.DOWN
self.target.parent.map_controller.action(
self.target.position,
self.target.parent.direction,
PlayerActionEnum.PLAYER_WANT_MOVE,
new_direction=direction)
elif PlayerLayer.keyboard[Game().settings.controls[
ControlsEnum.ACTION]]:
self.target.parent.map_controller.action(
self.target.position,
self.target.parent.direction,
PlayerActionEnum.ACTION_BUTTON,
)
else:
self.target.parent.time_left_moving -= dt
if self.target.parent.time_left_moving <= 0:
self.target.parent.time_left_moving = 0
self.target.velocity = (0, 0)
self.target.position = self.target.parent.final_position
self.target.parent.map_controller.action(
self.target.position, self.target.parent.direction,
PlayerActionEnum.PLAYER_END_MOVE)
self.target.parent.parent.set_focus(self.target.x, self.target.y)
def is_key_left(key: int) -> bool:
"""Get whether the pressed key is ``ControlsEnum.LEFT``.
:param key: The pressed key.
:return: True if the pressed key is ``ControlsEnum.LEFT``.
"""
return key == Game().settings.controls[ControlsEnum.LEFT]
def is_key_cancel(key: int) -> bool:
"""Get whether the pressed key is ControlsEnum.CANCEL.
:param key: The pressed key.
:return: True if the pressed key is ControlsEnum.CANCEL.
"""
return key == Game().settings.controls[ControlsEnum.CANCEL]
def __init__(self, opponent_pokemons: typing.List[PokemonModel], place: str) -> None:
"""Create a new battle.
:param opponent_pokemons: The list of opponent fighting pokemon.
:param place: The place where the battle takes place (i.e. the background).
"""
self._players_pokemon = self._first_players_pokemon_available(Game().game_state.player.pokemons)
self._opponent_pokemon = self._first_players_pokemon_available(opponent_pokemons)
self._place = place
def load_translations(self) -> None:
"""Load the translations file based on the settings."""
from toolbox.game import Game
self._config_parser.read_file(
codecs.open(
PATH +
"/conf/i18n_{0}.conf".format(Game().settings.language.code),
"r", "utf-8"))
def continue_game(self) -> None:
"""Load the game state and continue the saved game."""
from controllers.battle_controller import BattleController
Game().game_state.start_time()
opponent_pokemons = [
PokemonModel(
pokemons["BULBASAUR"], pokemons["BULBASAUR"].name, 1, [
LearnedMoveModel(moves["VINE_WHIP"],
moves["VINE_WHIP"].default_pp,
moves["VINE_WHIP"].default_pp),
LearnedMoveModel(moves["GROWL"], moves["GROWL"].default_pp,
moves["GROWL"].default_pp)
])
]
BattleController().battle(BattleModel(opponent_pokemons, "meadow"))
def pokemon_ko(self, pokemon_ko: PokemonModel) -> None:
"""A pokemon got defeated.
The player's pokemon gains some XP if he is the one who won.
:param pokemon_ko: The pokemon who is KO.
"""
if pokemon_ko == self._battle.players_pokemon:
if Game().game_state.player.has_conscious_pokemon():
self._battle_scene.ask_player_shift_pokemon()
else:
self._battle_scene.player_lost_battle()
else:
wild_pokemon = 1 if self._battle.is_wild_pokemon else 1.5
experience_gained = (wild_pokemon * pokemon_ko.species.base_experience * pokemon_ko.level) // 7
gained_levels = self._battle.players_pokemon.gain_experience(experience_gained)
self._battle_scene.player_won_fight(experience_gained, gained_levels)
def __init__(self,
pkmn_infos_type: PkmnInfosTypeEnum,
pokemon: PokemonModel,
selected_action: ActionEnum = None,
battle: BattleModel = None,
new_move: MoveModel = None) -> None:
"""Create a layer with the list of actions and manage their interaction.
:param pkmn_infos_type: The type of scene. Affects the information
displayed and the interactions.
:param pokemon: The pokemon whose infos is shown.
:param selected_action: The selected action by default.
:param battle: The battle model if it is for a shift.
:param new_move: The new move to learn if any.
"""
super().__init__()
self._pokemon = pokemon
self._pkmn_infos_type = pkmn_infos_type
self._new_move = new_move
self._available_actions = pkmn_infos_type.actions.copy()
if ActionEnum.SHIFT in self._available_actions and (
(battle is not None and battle.players_pokemon == pokemon)
or pokemon.hp <= 0):
self._available_actions.remove(ActionEnum.SHIFT)
if ActionEnum.PREVIOUS in self._available_actions and Game(
).game_state.player.pokemons.index(pokemon) == 0:
self._available_actions.remove(ActionEnum.PREVIOUS)
if ActionEnum.NEXT and Game().game_state.player.pokemons.index(
pokemon) == len(Game().game_state.player.pokemons) - 1:
self._available_actions.remove(ActionEnum.NEXT)
self._selected_action = self._available_actions.index(
selected_action
) if selected_action and selected_action in self._available_actions else self._available_actions.index(
pkmn_infos_type.default_action)
self._actions = {}
if ActionEnum.PREVIOUS in self._available_actions:
previous = cocos.sprite.Sprite(
pyglet.image.load(PATH +
'/assets/img/common/buttons/small_left.png'),
anchor=(0, 0))
selected_previous = cocos.sprite.Sprite(pyglet.image.load(
PATH + '/assets/img/common/buttons/selected_small_left.png'),
anchor=(0, 0))
previous.add(selected_previous, name=ActionsLayer.SELECTED_SPRITE)
previous_text = cocos.text.Label(
I18n().get("POKEMON_INFOS.PREVIOUS"), font_size=20)
previous_text.position = (
previous.width / 2 - previous_text.element.content_width / 1.5,
previous.height / 2 - previous_text.element.content_height / 4)
previous.add(previous_text)
self.add(previous)
self._actions[ActionEnum.PREVIOUS] = previous
if ActionEnum.SHIFT in self._available_actions:
shift = cocos.sprite.Sprite(pyglet.image.load(
PATH + '/assets/img/common/buttons/small_center_red.png'),
anchor=(0, 0))
shift.position = (
cocos.director.director.get_window_size()[0] / 2 -
shift.width - 5, 0)
selected_shift = cocos.sprite.Sprite(pyglet.image.load(
PATH +
'/assets/img/common/buttons/selected_small_center_red.png'),
anchor=(0, 0))
shift.add(selected_shift, name=ActionsLayer.SELECTED_SPRITE)
shift_text = cocos.text.Label(I18n().get("POKEMON_INFOS.SHIFT"),
font_size=14)
shift_text.position = (shift.width / 2 -
shift_text.element.content_width / 2,
shift.height / 2 -
shift_text.element.content_height / 4)
shift.add(shift_text)
self.add(shift)
self._actions[ActionEnum.SHIFT] = shift
if ActionEnum.CANCEL in self._available_actions:
cancel = cocos.sprite.Sprite(pyglet.image.load(
PATH + '/assets/img/common/buttons/small_center.png'),
anchor=(0, 0))
cancel_position_x = cocos.director.director.get_window_size(
)[0] / 2
if ActionEnum.SHIFT not in self._available_actions:
cancel_position_x -= cancel.width / 2
cancel.position = (cancel_position_x, 0)
selected_cancel = cocos.sprite.Sprite(pyglet.image.load(
PATH + '/assets/img/common/buttons/selected_small_center.png'),
anchor=(0, 0))
cancel.add(selected_cancel, name=ActionsLayer.SELECTED_SPRITE)
cancel_text = cocos.text.Label(I18n().get("POKEMON_INFOS.CANCEL"),
font_size=14)
cancel_text.position = (cancel.width / 2 -
cancel_text.element.content_width / 2,
cancel.height / 2 -
cancel_text.element.content_height / 4)
cancel.add(cancel_text)
self.add(cancel)
self._actions[ActionEnum.CANCEL] = cancel
if ActionEnum.NEXT in self._available_actions:
next = cocos.sprite.Sprite(pyglet.image.load(
PATH + '/assets/img/common/buttons/small_right.png'),
anchor=(0, 0))
next.position = (cocos.director.director.get_window_size()[0] -
next.width, -2)
selected_next = cocos.sprite.Sprite(pyglet.image.load(
PATH + '/assets/img/common/buttons/selected_small_right.png'),
anchor=(0, 0))
next.add(selected_next, name=ActionsLayer.SELECTED_SPRITE)
next_text = cocos.text.Label(I18n().get("POKEMON_INFOS.NEXT"),
font_size=20)
next_text.position = (next.width / 2 -
next_text.element.content_width / 4,
next.height / 2 -
next_text.element.content_height / 4)
next.add(next_text)
self.add(next)
self._actions[ActionEnum.NEXT] = next
list_moves = pokemon.moves + [new_move] if new_move else pokemon.moves
for index, move in enumerate(list_moves):
name = move.name.capitalize() if isinstance(
move, MoveModel) else move.move.name.capitalize()
current_pp = move.default_pp if isinstance(
move, MoveModel) else move.current_pp
max_pp = move.default_pp if isinstance(move,
MoveModel) else move.pp
type = move.type.name.lower() if isinstance(
move, MoveModel) else move.move.type.name.lower()
y_position = 170 if isinstance(move,
MoveModel) else 350 - 40 * index
move_sprite = cocos.sprite.Sprite(
pyglet.image.load(
PATH + '/assets/img/battle/moves/{0}.png'.format(type)))
move_sprite.position = (
cocos.director.director.get_window_size()[0] -
move_sprite.width / 2, y_position)
selected_sprite = cocos.sprite.Sprite(
pyglet.image.load(
PATH +
'/assets/img/battle/moves/selected_{0}.png'.format(type)))
selected_sprite.visible = False
move_sprite.add(selected_sprite, name=ActionsLayer.SELECTED_SPRITE)
name_label = cocos.text.Label(name,
font_size=9,
anchor_x="left",
anchor_y="center",
color=(0, 0, 0, 255),
bold=True)
name_label.position = (-57, 8)
move_sprite.add(name_label)
pp = cocos.text.Label("PP {0}/{1}".format(current_pp, max_pp),
font_size=9,
anchor_x="left",
anchor_y="center",
bold=True)
pp.position = (-15, -8)
move_sprite.add(pp)
type = cocos.sprite.Sprite(
pyglet.image.load(
PATH + '/assets/img/common/types/{0}.png'.format(type)))
type.position = (-35, -8)
type.scale = 0.9
move_sprite.add(type)
self.add(move_sprite)
if pkmn_infos_type == PkmnInfosTypeEnum.NEW_MOVE:
if move == new_move:
new = cocos.sprite.Sprite(
pyglet.image.load(
PATH +
'/assets/img/pkmn_infos/new.png'.format(type)))
new.position = (-move_sprite.width / 2 + 8,
-move_sprite.height / 2 + 8)
move_sprite.add(new)
self._actions[self._available_actions[index]] = move_sprite
self._update_screen()
def __init__(self, pokemon: PokemonModel, forced_hp: int = None) -> None:
"""Create a new HUD showing the player's pokemon's information.
The ``hp`` parameter is only useful if the current number of HP is
different from the displayed one.
:param pokemon: The player's pokemon.
:param forced_hp: The number of HP to display.
"""
super().__init__()
self._pokemon = pokemon
for index, pkmn in enumerate(Game().game_state.player.pokemons):
pokeball = cocos.sprite.Sprite(
pyglet.image.load(PATH +
'/assets/img/battle/hud/pokeball{0}.png'.
format("_ko" if pkmn.hp == 0 else "")))
pokeball.position = (-35 + (pokeball.width + 3) * index,
pokeball.height + 5)
self.add(pokeball)
hp = forced_hp if forced_hp else pokemon.hp
self._name = Text(pokemon.nickname)
self._name.position = -self._name.width, 0
self.add(self._name, z=1)
self._level_txt = cocos.sprite.Sprite(
pyglet.image.load(PATH + '/assets/img/battle/hud/level.png'))
self._level_txt.position = 5, -2
self.add(self._level_txt, z=1)
self._level = Text(str(pokemon.level))
self._level.position = 17, 0
self.add(self._level, z=1)
self._hp_bar = cocos.sprite.Sprite(
pyglet.image.load(PATH + '/assets/img/battle/hud/hp_bar.png'))
self._hp_bar.position = -6, -12
self.add(self._hp_bar)
for color in HPBarColorEnum:
if ceil(100 * pokemon.hp /
pokemon.stats[StatEnum.HP]) <= color.upper_limit:
self._bar_color = color
break
self._hp_bar_size = ceil(HUDLayer.HP_BAR_SIZE * hp /
pokemon.stats[StatEnum.HP])
self._hp_bar_content = {color: [] for color in HPBarColorEnum}
for i in range(HUDLayer.HP_BAR_SIZE):
for color in HPBarColorEnum:
hp_pixel = cocos.sprite.Sprite(
pyglet.image.load(PATH +
'/assets/img/battle/hud/hp_bar_{0}.png'.
format(color.name)))
hp_pixel.position = -23 + i, -12
hp_pixel.visible = True if color == self._bar_color and i < self._hp_bar_size else False
self._hp_bar_content[color].append(hp_pixel)
self.add(self._hp_bar_content[color][i], z=1)
self._hp = Text("{0}/{1}".format(hp, pokemon.stats[StatEnum.HP]))
self._hp.position = -20, -24
self.add(self._hp, z=1)
self._xp_bar = cocos.sprite.Sprite(
pyglet.image.load(PATH + '/assets/img/battle/hud/xp_bar.png'))
self._xp_bar.position = -10, -37
self.add(self._xp_bar)
xp_current_lvl = self._pokemon.species.experience_function.get_xp_for_level(
self._pokemon.level)
self._xp_bar_content = []
self._xp_bar_size = HUDLayer.XP_BAR_SIZE * (
pokemon.experience - xp_current_lvl) // (
pokemon.experience_for_next_level - xp_current_lvl)
for i in range(HUDLayer.XP_BAR_SIZE):
self._xp_bar_content.append(
cocos.sprite.Sprite(
pyglet.image.load(
PATH + '/assets/img/battle/hud/xp_bar_blue.png')))
self._xp_bar_content[i].position = -56 + i, -37
self._xp_bar_content[
i].visible = False if i > self._xp_bar_size else True
self.add(self._xp_bar_content[i], z=1)
def lost_battle(self) -> None:
"""The player lost the battle. His game state is erased."""
Game().game_state.delete()
MainMenuController().show_menu()
def __init__(self, settings: SettingsModel) -> None:
"""Create the list of settings.
:param settings: The player's settings.
"""
super().__init__()
self._actions = dict()
self._selected_language = settings.language.index
language = cocos.sprite.Sprite(
pyglet.image.load(PATH +
'/assets/img/main_menu/single_line_action.jpg'))
language.position = (320, 445)
language_selected = cocos.sprite.Sprite(
pyglet.image.load(
PATH +
'/assets/img/main_menu/single_line_action_selected.jpg'))
language.add(language_selected, name=ActionsLayer.SELECTED_SPRITE)
language_text = cocos.text.Label(I18n().get("SETTINGS.LANGUAGE"),
bold=True,
color=(0, 0, 0, 255))
language_text.position = (-180, -5)
language.add(language_text)
language_value = cocos.text.Label(I18n().get(
"SETTINGS.LANGUAGE.{0}".format(settings.language.name)),
bold=True,
color=(0, 0, 0, 255))
language_value.position = (70, -5)
language.add(language_value, name=ActionsLayer.LANGUAGE_VALUE)
language_left_arrow = cocos.sprite.Sprite(
pyglet.image.load(PATH + '/assets/img/common/cursor.png'))
language_left_arrow.do(RotateBy(90, 0))
language_left_arrow.position = (40, 0)
language.add(language_left_arrow)
language_right_arrow = cocos.sprite.Sprite(
pyglet.image.load(PATH + '/assets/img/common/cursor.png'))
language_right_arrow.do(RotateBy(-90, 0))
language_right_arrow.position = (170, 0)
language.add(language_right_arrow)
self._actions[ActionsLayer.LANGUAGE] = language
self.add(language, name=str(ActionsLayer.LANGUAGE))
for index, control in enumerate(ControlsEnum):
control_sprite = cocos.sprite.Sprite(
pyglet.image.load(
PATH + '/assets/img/main_menu/single_line_action.jpg'))
control_sprite.position = (320, 445 - (control_sprite.height + 9) *
(index + 1))
control_sprite_selected = cocos.sprite.Sprite(
pyglet.image.load(
PATH +
'/assets/img/main_menu/single_line_action_selected.jpg'))
control_sprite.add(control_sprite_selected,
name=ActionsLayer.SELECTED_SPRITE)
control_text = cocos.text.Label(I18n().get("CONTROLS.{0}".format(
control.name)),
bold=True,
color=(0, 0, 0, 255))
control_text.position = (-180, -5)
control_sprite.add(control_text)
control_value = cocos.text.Label(str(
keys.symbol_string(Game().settings.controls[control])),
bold=True,
color=(0, 0, 0, 255))
control_value.position = (70, -5)
control_sprite.add(control_value, name=ActionsLayer.CONTROL_VALUE)
self._actions[control.name] = control_sprite
self.add(control_sprite, name=str(control))
cancel = cocos.sprite.Sprite(
pyglet.image.load(
PATH + '/assets/img/main_menu/single_little_line_action.jpg'))
cancel.position = (320, 34)
cancel_selected = cocos.sprite.Sprite(
pyglet.image.load(
PATH +
'/assets/img/main_menu/single_little_line_action_selected.jpg')
)
cancel.add(cancel_selected, name=ActionsLayer.SELECTED_SPRITE)
cancel_text = cocos.text.Label(I18n().get("SETTINGS.CANCEL"),
bold=True,
color=(0, 0, 0, 255))
cancel_text.position = (-cancel_text.element.content_width / 2, -5)
cancel.add(cancel_text)
self._actions[ActionsLayer.CANCEL] = cancel
self.add(cancel)
self._choice = 0
self._update_screen()
def __init__(self) -> None:
"""Create the list of actions available in the main menu."""
super().__init__()
self._game_state = None if Game().game_state.time == 0 else Game(
).game_state
self._actions = []
continue_file = "multi_line_action" if self._game_state else "multi_line_action_disabled"
continue_sprite = cocos.sprite.Sprite(
pyglet.image.load(
PATH + '/assets/img/main_menu/{0}.jpg'.format(continue_file)))
continue_sprite.position = (320, 355)
continue_selected = cocos.sprite.Sprite(
pyglet.image.load(
PATH + '/assets/img/main_menu/multi_line_action_selected.jpg'))
continue_sprite.add(continue_selected,
name=ActionsLayer.SELECTED_SPRITE)
continue_text = cocos.text.Label(I18n().get("MAIN_MENU.CONTINUE"),
bold=True,
color=(0, 0, 0, 255))
continue_text.position = (-180, 60)
continue_sprite.add(continue_text)
if self._game_state:
player = cocos.text.Label(I18n().get("MAIN_MENU.PLAYER"),
bold=True,
color=(16, 173, 231, 255))
player.position = (-130, 30)
continue_sprite.add(player)
player_name = cocos.text.Label(self._game_state.player.name,
bold=True,
color=(16, 173, 231, 255),
anchor_x="right")
player_name.position = (70, 30)
continue_sprite.add(player_name)
time = cocos.text.Label(I18n().get("MAIN_MENU.TIME"),
bold=True,
color=(16, 173, 231, 255))
time.position = (-130, 0)
continue_sprite.add(time)
hours = int(self._game_state.time // 3600)
minutes = int((self._game_state.time - (hours * 3600)) // 60)
time_value = cocos.text.Label("{:02d}:{:02d}".format(
hours, minutes),
bold=True,
color=(16, 173, 231, 255),
anchor_x="right")
time_value.position = (70, 0)
continue_sprite.add(time_value)
for index, pokemon in enumerate(self._game_state.player.pokemons):
pokemon_sprite = cocos.sprite.Sprite(
pyglet.image.load(PATH +
'/assets/img/pokemon/mini/{0}.png'.
format(pokemon.species.id.lower())))
pokemon_sprite.scale = 0.7
pokemon_sprite.position = (-140 + index * 60, -50)
continue_sprite.add(pokemon_sprite)
self.add(continue_sprite)
self._actions.append(continue_sprite)
new_game = cocos.sprite.Sprite(
pyglet.image.load(PATH +
'/assets/img/main_menu/single_line_action.jpg'))
new_game.position = (320, 188)
new_game_selected = cocos.sprite.Sprite(
pyglet.image.load(
PATH +
'/assets/img/main_menu/single_line_action_selected.jpg'))
new_game.add(new_game_selected, name=ActionsLayer.SELECTED_SPRITE)
new_game_text = cocos.text.Label(I18n().get("MAIN_MENU.NEW_GAME"),
bold=True,
color=(0, 0, 0, 255))
new_game_text.position = (-180, -5)
new_game.add(new_game_text)
self.add(new_game)
self._actions.append(new_game)
settings = cocos.sprite.Sprite(
pyglet.image.load(PATH +
'/assets/img/main_menu/single_line_action.jpg'))
settings.position = (320, 91)
settings_selected = cocos.sprite.Sprite(
pyglet.image.load(
PATH +
'/assets/img/main_menu/single_line_action_selected.jpg'))
settings.add(settings_selected, name=ActionsLayer.SELECTED_SPRITE)
settings_text = cocos.text.Label(I18n().get("MAIN_MENU.SETTINGS"),
bold=True,
color=(0, 0, 0, 255))
settings_text.position = (-180, -5)
settings.add(settings_text)
self.add(settings)
self._actions.append(settings)
self._choice = 0 if self._game_state else 1
self._update_screen()
