X-Git-Url: https://git.ctpug.org.za/?a=blobdiff_plain;f=naja%2Fgameboard.py;h=8b0e099a77da9ebe02d6d2f58d314aec1a8a9572;hb=172e2665331fba1bcda0a5b07774db8523076e66;hp=7e8f27323aa54f4e9fa4a05e3b1dae6cbd82a96a;hpb=de49aa72249f2fded44e53831f5680d9a48d7f5b;p=naja.git diff --git a/naja/gameboard.py b/naja/gameboard.py index 7e8f273..8b0e099 100644 --- a/naja/gameboard.py +++ b/naja/gameboard.py @@ -2,7 +2,8 @@ from random import choice from naja.constants import( BITS, DIRECTION_BITS, CONDITION_BITS, PLAYER_DEFAULTS, - MOVE, ACT, EXAMINE) + ACT, EXAMINE, ROTATION) +from naja.options import options from naja.player import Player from naja import actions @@ -20,7 +21,7 @@ class GameBoard(object): self.locations = [item.copy() for item in state['locations']] self.player = player self.board_locations = board_locations - self.player_mode = MOVE + self.player_mode = EXAMINE @classmethod def new_game(cls, locations_definition, @@ -28,6 +29,8 @@ class GameBoard(object): initial_pos=PLAYER_DEFAULTS.INITIAL_POS, max_health=PLAYER_DEFAULTS.MAX_HEALTH, wins_required=PLAYER_DEFAULTS.WINS_REQUIRED): + if options.initial_bits: + initial_bits = options.initial_bits state = { 'max_health': max_health, 'health': max_health, @@ -66,24 +69,24 @@ class GameBoard(object): for definition in locations_definition] def export_board_locations(self): - return dict( + return sorted( (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()) + (tuple(position), LocationCard.import_location(definition)) + for position, definition in board_locations_definition) @classmethod def generate_board(cls, locations_definition): - board_locations = {} + 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() + board_locations.append([(x, y), board_location.export()]) return board_locations def lose_health(self): @@ -104,55 +107,70 @@ class GameBoard(object): location = LocationCard.new_location(choice(self.locations).copy()) self.board_locations[position] = location - def shift_locations(self, direction): + def shift_location_row(self, change, is_vertical): px, py = self.player.position shifted_locations = {} - # TODO: Make this less horrible. Also test it. + mkpos = lambda i: (px, i) if is_vertical else (i, py) + + for i in range(5): + if (px, py) == mkpos(i): + continue + new_i = (i + change) % 5 + if (px, py) == mkpos(new_i): + new_i = (new_i + change) % 5 + shifted_locations[mkpos(new_i)] = self.board_locations[mkpos(i)] + + self.board_locations.update(shifted_locations) + + def shift_locations(self, direction): 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)] + self.shift_location_row(-1, is_vertical=True) 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)] + self.shift_location_row(1, is_vertical=True) 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)] + self.shift_location_row(1, is_vertical=False) 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.shift_location_row(-1, is_vertical=False) - self.board_locations.update(shifted_locations) + def rotate_locations(self, direction): + px, py = self.player.position + locations_to_rotate = [] + rotated_locations = {} + + if py > 0: + for i in range(max(0, px - 1), min(5, px + 2)): + locations_to_rotate.append((i, py - 1)) + + if px < 4: + locations_to_rotate.append((px + 1, py)) + + if py < 4: + for i in reversed(range(max(0, px - 1), min(5, px + 2))): + locations_to_rotate.append((i, py + 1)) + + if px > 0: + locations_to_rotate.append((px - 1, py)) + + if ROTATION[direction] == ROTATION.CLOCKWISE: + new_positions = locations_to_rotate[1:] + [locations_to_rotate[0]] + elif ROTATION[direction] == ROTATION.ANTICLOCKWISE: + new_positions = ( + [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] + + self.board_locations.update(rotated_locations) + + def allow_chess_move(self, chesspiece): + self.player.allow_chess_move(chesspiece) 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 (MOVE, ACT, EXAMINE): + elif new_mode in (ACT, EXAMINE): self.player_mode = new_mode else: raise RuntimeError("Illegal player mode %s" % self.player_mode) @@ -187,20 +205,29 @@ class LocationCard(object): @classmethod def build_action(cls, definition): action_class = getattr(actions, definition['action_class']) - required_bits = definition['required_bits'] + required_bits = cls.parse_bits(definition['required_bits']) data = definition.get('data', {}) return action_class(required_bits, **data) @classmethod def new_location(cls, definition): + if 'bits' in definition: + bits = cls.parse_bits(definition['bits']) + else: + bits = cls.generate_bitwise_operand() return cls.import_location({ - 'bitwise_operand': cls.generate_bitwise_operand(), + 'bitwise_operand': bits, 'actions': definition['actions'], }) + @classmethod + def parse_bits(self, bit_list): + # Convert names to numbers if applicable. + return frozenset(BITS.get(bit, bit) for bit in bit_list) + def export(self): return { - 'bitwise_operand': self.bitwise_operand, + 'bitwise_operand': sorted(self.bitwise_operand), 'actions': [action.export() for action in self.actions], }