X-Git-Url: https://git.ctpug.org.za/?a=blobdiff_plain;f=naja%2Fgameboard.py;h=9855546c905a0a96019ecd60861132400cbbe7b6;hb=f174b002a09181473e4b6bd63c28839012e7776a;hp=a2e37796d7972025c077ef88e4b96f0641bb09a5;hpb=aa858388f65344396a7b81a82198e3a6fbc1efca;p=naja.git diff --git a/naja/gameboard.py b/naja/gameboard.py index a2e3779..9855546 100644 --- a/naja/gameboard.py +++ b/naja/gameboard.py @@ -6,6 +6,8 @@ from naja.constants import( from naja.options import options from naja.player import Player from naja import actions +from naja.sound import sound +import random class GameBoard(object): @@ -19,31 +21,63 @@ class GameBoard(object): self.health = state['health'] self.wins = state['wins'] self.locations = [item.copy() for item in state['locations']] - self.puzzle = state['puzzle'] + self.puzzle = state.get('puzzle', False) self.player = player self.board_locations = board_locations - self.player_mode = EXAMINE + self.player_mode = state.get('player_mode', EXAMINE) + self.has_cheated = state.get('cheater', options.cheat_enabled) + self.clock_count = state.get('clock_count', 0) + self.replacement_params = state.get('replacement_params', None) @classmethod - def new_game(cls, deck, - initial_bits=PLAYER_DEFAULTS.INITIAL_BITS, - initial_pos=PLAYER_DEFAULTS.INITIAL_POS, - max_health=PLAYER_DEFAULTS.MAX_HEALTH, - wins_required=PLAYER_DEFAULTS.WINS_REQUIRED): + def new_game(cls, deck, initial_bits=None, initial_pos=None, + max_health=None, wins_required=None): + + defaults = { + 'initial_bits': PLAYER_DEFAULTS.INITIAL_BITS, + 'initial_pos': PLAYER_DEFAULTS.INITIAL_POS, + 'max_health': PLAYER_DEFAULTS.MAX_HEALTH, + 'wins_required': PLAYER_DEFAULTS.WINS_REQUIRED, + } + + puzzle = deck.get('puzzle', False) + + if puzzle: + puzzle_defaults = deck.get('defaults', {}) + for k, v in puzzle_defaults.iteritems(): + if isinstance(v, list): + puzzle_defaults[k] = tuple(v) + defaults.update(puzzle_defaults) + + if initial_bits is None: + initial_bits = defaults['initial_bits'] + if initial_pos is None: + initial_pos = defaults['initial_pos'] + if max_health is None: + max_health = defaults['max_health'] + if wins_required is None: + wins_required = defaults['wins_required'] + + # Overriden by command line if options.initial_bits: initial_bits = options.initial_bits + state = { 'max_health': max_health, 'health': max_health, 'wins_required': wins_required, 'wins': 0, 'locations': deck['cards'], - 'puzzle': deck.get('puzzle', False), + 'puzzle': puzzle, + 'clock_count': 0, + 'replacement_params': deck.get('replacement_params', None), } player = Player(initial_bits, initial_pos) board_locations = cls.import_board_locations( cls.generate_board(deck)) - return cls(state, player, board_locations) + board = cls(state, player, board_locations) + player.set_gameboard(board) + return board @classmethod def import_game(cls, definition): @@ -54,7 +88,7 @@ class GameBoard(object): return cls(state, player, board_locations) def export(self): - return { + data = { 'max_health': self.max_health, 'health': self.health, 'wins_required': self.wins_required, @@ -63,7 +97,15 @@ class GameBoard(object): 'puzzle': self.puzzle, 'player': self.player.export(), 'board_locations': self.export_board_locations(), + 'player_mode': self.player_mode, + 'clock_count': self.clock_count, + 'replacement_params': self.replacement_params, } + if options.cheat_enabled: + self.has_cheated = True + if self.has_cheated: + data['cheater'] = True + return data @classmethod def import_locations(cls, locations_definition): @@ -92,9 +134,11 @@ class GameBoard(object): @classmethod def generate_puzzle_board(cls, deck): assert len(deck['cards']) == 5 * 5 + replacement_params = deck.get('replacement_params', None) board_locations = [ [(i % 5, i // 5), - LocationCard.new_location(card.copy()).export()] + LocationCard.new_location( + card.copy(), replacement_params, puzzle=True).export()] for i, card in enumerate(deck['cards']) ] return board_locations @@ -102,10 +146,12 @@ class GameBoard(object): @classmethod def generate_random_board(cls, deck): board_locations = [] + replacement_params = deck.get('replacement_params', None) for x in range(5): for y in range(5): + new_choice = cls.choose_card(deck['cards'], board_locations) board_location = LocationCard.new_location( - choice(deck['cards']).copy()) + new_choice.copy(), replacement_params) board_locations.append([(x, y), board_location.export()]) return board_locations @@ -123,10 +169,41 @@ class GameBoard(object): if self.wins >= self.wins_required: self.end_game(win=True) + def card_used(self, position): + if not self.puzzle: + self.replace_card(position) + def replace_card(self, position): - location = LocationCard.new_location(choice(self.locations).copy()) + new_choice = self.choose_card(self.locations, + self.board_locations.items(), + position) + location = LocationCard.new_location(new_choice.copy(), + self.replacement_params) self.board_locations[position] = location + @classmethod + def choose_card(cls, cards, board_locations, position=None): + # Find which cards are at their maximum and exclude them from + # the choice list + counts = {} + choices = {card['card_name']: card for card in cards} + for pos, card in board_locations: + if pos == position: + # skip the card we're replacing if appropriate + continue + if isinstance(card, LocationCard): + key = card.card_name + max_num = card.max_number + else: + key = card['card_name'] + max_num = card.get('max_number', 25) + counts.setdefault(key, 0) + counts[key] += 1 + if counts[key] >= max_num: + if key in choices: + del choices[key] + return choice(choices.values()) + def shift_location_row(self, change, is_vertical): px, py = self.player.position shifted_locations = {} @@ -178,7 +255,7 @@ class GameBoard(object): [locations_to_rotate[-1]] + locations_to_rotate[:-1]) for old, new in zip(locations_to_rotate, new_positions): - rotated_locations[old] = self.board_locations[new] + rotated_locations[new] = self.board_locations[old] self.board_locations.update(rotated_locations) @@ -192,14 +269,22 @@ class GameBoard(object): % self.player_mode) elif new_mode in (ACT, EXAMINE): self.player_mode = new_mode + if new_mode is EXAMINE: + self.board_update() else: raise RuntimeError("Illegal player mode %s" % self.player_mode) + def board_update(self): + self.clock_count += 1 + for position, location in self.board_locations.iteritems(): + location.timer_action(position, self) + def end_game(self, win): # TODO: Find a way to not have UI stuff in game logic stuff. from naja.events import SceneChangeEvent from naja.scenes.lose import LoseScene from naja.scenes.win import WinScene + sound.stop() if win: SceneChangeEvent.post(WinScene) else: @@ -211,16 +296,21 @@ class LocationCard(object): A particular set of options available on a location. """ - def __init__(self, bitwise_operand, location_actions): + def __init__(self, card_name, bitwise_operand, location_actions, + replacement_time=None, max_number=25): + self.card_name = card_name self.bitwise_operand = bitwise_operand self.actions = location_actions - self.check_actions() + self.max_number = max_number + self.replacement_time = replacement_time @classmethod def import_location(cls, state): location_actions = [ cls.build_action(definition) for definition in state['actions']] - return cls(state['bitwise_operand'], location_actions) + return cls(state['card_name'], state['bitwise_operand'], + location_actions, state['replacement_time'], + state['max_number']) @classmethod def build_action(cls, definition): @@ -230,15 +320,30 @@ class LocationCard(object): return action_class(required_bits, **data) @classmethod - def new_location(cls, definition): + def new_location(cls, definition, replacement_params=None, puzzle=False): if 'bits' in definition: bits = cls.parse_bits(definition['bits']) else: bits = cls.generate_bitwise_operand() - return cls.import_location({ + + if 'replacement_time' in definition: + replacement_time = definition['replacement_time'] + else: + replacement_time = cls.generate_replacement_time( + replacement_params) + + max_number = definition.get('max_number', 25) + card_name = definition['card_name'] + location = cls.import_location({ 'bitwise_operand': bits, 'actions': definition['actions'], + 'max_number': max_number, + 'card_name': card_name, + 'replacement_time': replacement_time, }) + if not puzzle: + location.check_actions() + return location @classmethod def parse_bits(self, bit_list): @@ -249,6 +354,9 @@ class LocationCard(object): return { 'bitwise_operand': sorted(self.bitwise_operand), 'actions': [action.export() for action in self.actions], + 'max_number': self.max_number, + 'card_name': self.card_name, + 'replacement_time': self.replacement_time, } def check_actions(self): @@ -279,3 +387,20 @@ class LocationCard(object): if choice(range(3)) == 0: bits.add(choice(BITS.values())) return frozenset(bits) + + @staticmethod + def generate_replacement_time(replacement_params): + if replacement_params is None: + return None + else: + if replacement_params['chance'] > random.random(): + return random.randint(replacement_params['min'], + replacement_params['max']) + else: + return None + + def timer_action(self, position, board): + if self.replacement_time is not None: + self.replacement_time -= 1 + if self.replacement_time <= 0: + board.replace_card(position)