X-Git-Url: https://git.ctpug.org.za/?a=blobdiff_plain;f=naja%2Fgameboard.py;h=d62684924a514847634707ff038250de5ed5f33f;hb=0cef06f581d48315a59a19ac06ca1d2be14cbb4c;hp=5cbecb9bdac04663cdbface35eba1dc6b1bfaaca;hpb=da7b5b8cfedca73f510a85275a5c9155b07c2cf9;p=naja.git diff --git a/naja/gameboard.py b/naja/gameboard.py index 5cbecb9..d626849 100644 --- a/naja/gameboard.py +++ b/naja/gameboard.py @@ -1,6 +1,10 @@ from random import choice -from naja.constants import BITS, DIRECTION_BITS, CONDITION_BITS +from naja.constants import( + BITS, DIRECTION_BITS, CONDITION_BITS, PLAYER_DEFAULTS, + ACT, EXAMINE) +from naja.player import Player +from naja import actions class GameBoard(object): @@ -8,36 +12,160 @@ class GameBoard(object): A representation of the game board. """ - def __init__(self, player, health, wins, locations=None, state=None): + def __init__(self, state, player, board_locations): + self.max_health = state['max_health'] + self.wins_required = state['wins_required'] + self.health = state['health'] + self.wins = state['wins'] + self.locations = [item.copy() for item in state['locations']] self.player = player - self.max_health = health - self.wins_required = wins - - if locations is None: - locations = self.generate_locations() - self.locations = locations - - if state is None: - state = self.generate_state() - self.update_state(state) + self.board_locations = board_locations + self.player_mode = EXAMINE @classmethod - def generate_locations(cls): - raise NotImplementedError("TODO") + def new_game(cls, locations_definition, + initial_bits=PLAYER_DEFAULTS.INITIAL_BITS, + initial_pos=PLAYER_DEFAULTS.INITIAL_POS, + max_health=PLAYER_DEFAULTS.MAX_HEALTH, + wins_required=PLAYER_DEFAULTS.WINS_REQUIRED): + state = { + 'max_health': max_health, + 'health': max_health, + 'wins_required': wins_required, + 'wins': 0, + 'locations': locations_definition, + } + player = Player(initial_bits, initial_pos) + board_locations = cls.import_board_locations( + cls.generate_board(locations_definition)) + return cls(state, player, board_locations) - def generate_state(self): + @classmethod + def import_game(cls, definition): + state = definition.copy() + player = Player.import_player(state.pop('player')) + board_locations = cls.import_board_locations( + state.pop('board_locations')) + return cls(state, player, board_locations) + + def export(self): return { - 'health': self.max_health, - 'wins': 0, + 'max_health': self.max_health, + 'health': self.health, + 'wins_required': self.wins_required, + 'wins': self.wins, + 'locations': [item.copy() for item in self.locations], + 'player': self.player.export(), + 'board_locations': self.export_board_locations(), } - def update_state(self, state): - self.health = state['health'] - self.wins = state['wins'] + @classmethod + def import_locations(cls, locations_definition): + return [ + LocationCard.import_location(definition) + for definition in locations_definition] + + def export_board_locations(self): + return dict( + (position, location.export()) + for position, location in self.board_locations.iteritems()) + + @classmethod + def import_board_locations(cls, board_locations_definition): + return dict( + (position, LocationCard.import_location(definition)) + for position, definition in board_locations_definition.iteritems()) + + @classmethod + def generate_board(cls, locations_definition): + board_locations = {} + for x in range(5): + for y in range(5): + board_location = LocationCard.new_location( + choice(locations_definition).copy()) + board_locations[(x, y)] = board_location.export() + return board_locations def lose_health(self): self.health -= 1 - # TODO: Check win/lose + if self.health <= 0: + self.end_game(win=False) + + def gain_health(self): + if self.health < self.max_health: + self.health += 1 + + def acquire_win_token(self): + self.wins += 1 + if self.wins >= self.wins_required: + self.end_game(win=True) + + def replace_card(self, position): + location = LocationCard.new_location(choice(self.locations).copy()) + self.board_locations[position] = location + + def shift_locations(self, direction): + px, py = self.player.position + shifted_locations = {} + # TODO: Make this less horrible. Also test it. + if BITS[direction] == BITS.NORTH: + for y in range(5): + if y == py: + continue + new_y = y - 1 + if new_y == py: + new_y -= 1 + new_y %= 5 + shifted_locations[(px, new_y)] = self.board_locations[(px, y)] + elif BITS[direction] == BITS.SOUTH: + for y in range(5): + if y == py: + continue + new_y = y + 1 + if new_y == py: + new_y += 1 + new_y %= 5 + shifted_locations[(px, new_y)] = self.board_locations[(px, y)] + elif BITS[direction] == BITS.EAST: + for x in range(5): + if x == px: + continue + new_x = x + 1 + if new_x == px: + new_x += 1 + new_x %= 5 + shifted_locations[(new_x, py)] = self.board_locations[(x, py)] + elif BITS[direction] == BITS.WEST: + for x in range(5): + if x == px: + continue + new_x = x - 1 + if new_x == px: + new_x -= 1 + new_x %= 5 + shifted_locations[(new_x, py)] = self.board_locations[(x, py)] + + self.board_locations.update(shifted_locations) + + def change_mode(self, new_mode): + """Advance to the next mode""" + if new_mode == self.player_mode: + raise RuntimeError("Inconsistent state. Setting mode %s to itself" + % self.player_mode) + elif new_mode in (ACT, EXAMINE): + self.player_mode = new_mode + else: + raise RuntimeError("Illegal player mode %s" % self.player_mode) + + 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 + if win: + SceneChangeEvent.post(WinScene) + else: + SceneChangeEvent.post(LoseScene) class LocationCard(object): @@ -45,13 +173,49 @@ class LocationCard(object): A particular set of options available on a location. """ - def __init__(self, bitwise_operand, actions): + def __init__(self, bitwise_operand, location_actions): self.bitwise_operand = bitwise_operand - self.actions = actions + self.actions = location_actions + self.check_actions() - @staticmethod - def generate_location(): - raise NotImplementedError("TODO") + @classmethod + def import_location(cls, state): + location_actions = [ + cls.build_action(definition) for definition in state['actions']] + return cls(state['bitwise_operand'], location_actions) + + @classmethod + def build_action(cls, definition): + action_class = getattr(actions, definition['action_class']) + required_bits = definition['required_bits'] + data = definition.get('data', {}) + return action_class(required_bits, **data) + + @classmethod + def new_location(cls, definition): + return cls.import_location({ + 'bitwise_operand': cls.generate_bitwise_operand(), + 'actions': definition['actions'], + }) + + def export(self): + return { + 'bitwise_operand': self.bitwise_operand, + 'actions': [action.export() for action in self.actions], + } + + def check_actions(self): + if not self.actions: + print "Warning: Location has no actions." + self.insert_default_default_action() + if self.actions[0].required_bits: + self.insert_default_default_action() + + def insert_default_default_action(self): + self.actions.insert(0, self.build_action({ + 'action_class': 'DoNothing', + 'required_bits': [], + })) @staticmethod def generate_bitwise_operand(): @@ -68,32 +232,3 @@ class LocationCard(object): if choice(range(3)) == 0: bits.add(choice(BITS.values())) return frozenset(bits) - - @staticmethod - def generate_location_actions(): - raise NotImplementedError("TODO") - - -class LocationAction(object): - """ - An action that may be performed on a location. - """ - - TEXT = None - REQUIRED_BITS = frozenset() - - def __init__(self, **data): - self.data = data - - def check_available(self, player): - return player.bits.check_bits(*self.REQUIRED_BITS) - - def perform_action(self, player, board): - raise NotImplementedError("TODO") - - def check_and_clear_MSB(self, player): - if player.bits.check_bit(BITS.MSB): - player.bits.clear_bit(BITS.MSB) - return True - else: - return False