RoboRallyGUI/roborally.py

594 lines
24 KiB
Python

import random
import sys
random.seed(0)
class Card:
possible_moves = ['forward', 'forward x2', 'forward x3', 'backward', 'turn left', 'turn right', 'turn around']
card_counter = 0
def __init__(self):
self.number = Card.card_counter
Card.card_counter += 1
self.action = random.choice(Card.possible_moves)
self.priority = random.randint(0, 100)
def __str__(self):
return "Card No. " + str(self.number) + " " + self.action + " " + str(self.priority)
def __repr__(self):
return self.action + " (" + str(self.priority) + ")"
class CardDeck:
def __init__(self, n=84):
self.deck = {}
# generate cards
for i in range(0, n):
self.deck[i] = Card()
self.dealt = set()
self.discard_pile = set()
def draw_cards(self, n=1):
available = set(self.deck.keys()).difference(self.dealt)
# print("{} cards are available".format(len(available)))
if len(available) < n:
drawn = list(available) # give out remaining cards
# print("drawing remaining {} cards".format(len(drawn)))
self.dealt = self.dealt.union(drawn)
# put the cards from the discard pile back into the game
self.dealt = self.dealt - self.discard_pile
self.discard_pile = set() # reset the discard pile
# draw rest of cards
available = set(self.deck.keys()).difference(self.dealt)
# print("drawing another {} cards".format(n - len(drawn)))
drawn += random.sample(available, n - len(drawn))
else:
drawn = random.sample(available, n)
# print("cards drawn: {}".format(drawn))
self.dealt = self.dealt.union(drawn)
return [self.deck[i] for i in drawn]
def return_cards(self, cards):
self.discard_pile = self.discard_pile.union(set([c.number for c in cards]))
pass
class Robot:
# dictionary mapping the current orientation and a turn command to the resulting orientation
resulting_orientation = {
'^': {'turn left': '<', 'turn right': '>', 'turn around': 'v'},
'>': {'turn left': '^', 'turn right': 'v', 'turn around': '<'},
'v': {'turn left': '>', 'turn right': '<', 'turn around': '^'},
'<': {'turn left': 'v', 'turn right': '^', 'turn around': '>'},
}
# dictionary mapping the current orientation and the target orientation to the necessary turn command
necessary_turn = {
'^': {'>': 'turn right', 'v': 'turn around', '<': 'turn left'},
'>': {'v': 'turn right', '<': 'turn around', '^': 'turn left'},
'v': {'<': 'turn right', '^': 'turn around', '>': 'turn left'},
'<': {'^': 'turn right', '>': 'turn around', 'v': 'turn left'},
}
# dictionary mapping an orientation to its opposite
opposites = {'^': 'v', '>': '<', 'v': '^', '<': '>'}
def __init__(self, x, y, orientation, marker_id, board):
self.x = x
self.y = y
self.orientation = orientation
self.marker_id = marker_id
self.damage = 0
self.collected_flags = set()
self.board = board
# mark the tile on the board as occupied
self.board[(x,y)].occupant = self
def get_tile(self):
# return the tile the robot is standing on
return self.board[(self.x, self.y)]
def get_adjecent_tile(self, direction):
# get the tile adjecent to the robot in the given direction
current_tile = self.get_tile()
return self.board[current_tile.get_neighbor_coordinates(direction)]
def get_accessed_tiles(self, count, forward=True):
# create a list of all tiles the robot would enter if it drives <count> steps forward
tiles = []
current_tile = self.get_tile()
for i in range(1, count + 1):
if forward:
current_tile = self.board.get(current_tile.get_neighbor_coordinates(self.orientation))
else:
current_tile = self.board.get(current_tile.get_neighbor_coordinates(Robot.opposites[self.orientation]))
if current_tile is None:
return tiles
else:
tiles.append(current_tile)
return tiles
def is_pushable(self, direction):
# check if the robot can be pushed in the given direction
# this is the case if there is a non-blocking tile next to the robot or if there is another robot that is pushable
robot_tile = self.get_tile()
neighbor_tile = self.board.get(robot_tile.get_neighbor_coordinates(direction))
if neighbor_tile is None: # neighbor tile could not be found -> robot would be pushed out of the board
return False
else:
if neighbor_tile.is_empty():
return True
elif neighbor_tile.modifier == '#': # if there's a wall on the neighbor tile the robot cannot be pushed there
return False
else:
# this means there's another robot on the neighbor tile -> check if it can be pushed away
return neighbor_tile.occupant.is_pushable(direction)
def has_opposite_orientation(self, direction):
opposites = [('^', 'v'), ('>', '<'), ('v', '^'), ('<', '>')]
return (self.orientation, direction) in opposites
def get_turn_direction(self, target_orienation):
return Robot.necessary_turn[self.orientation][target_orienation]
def get_opposite_orientation(self):
return Robot.opposites[self.orientation]
def turn(self, type):
# change the orientation of the robot
self.orientation = Robot.resulting_orientation[self.orientation][type]
return "{}, {}".format(type, self.marker_id)
def move(self, type):
# move the robot forward or backward
# this involves
tile = self.get_tile()
if type == 'forward':
target_tile = self.get_adjecent_tile(self.orientation)
if target_tile.occupant is not None:
print("error: target tile is not empty")
sys.exit(1)
tile.occupant = None # delete the robot from the current tile
target_tile.occupant = self # place the robot in the next tile
self.x = target_tile.x
self.y = target_tile.y
# return the move for sending to the controller
return "forward, {}".format(self.marker_id)
elif type == 'backward':
opposite_orientation = self.get_opposite_orientation()
target_tile = self.get_adjecent_tile(opposite_orientation)
if target_tile.occupant is not None:
print("error: target tile is not empty")
sys.exit(1)
tile.occupant = None # delete the robot from the current tile
target_tile.occupant = self # place the robot in the next tile
self.x = target_tile.x
self.y = target_tile.y
# return the move for sending to the controller
return "backward, {}".format(self.marker_id)
else:
print("error: invalid move")
sys.exit(1)
def nop(self):
# do nothing command
return "nop, {}".format(self.marker_id)
def board_element_processable(self):
# check if we can directly process the board element for the tile the current robot is located on
tile = self.get_tile()
if tile.modifier in ['^', '>', 'v', '<']:
direction = tile.modifier
neighbor_tile = self.get_adjecent_tile(direction)
return neighbor_tile.occupant is None # if the adjacent tile the robot will be pushed into is empty
# we can execute the push
return True
def take_damage(self, count):
self.damage = min(self.damage + count, 4)
def heal_damage(self, count):
self.damage = max(self.damage - count, 0)
def pick_up_flag(self, flag):
self.collected_flags.add(flag)
def __str__(self):
return str(self.marker_id)
class Tile:
# possible modifiers:
# # : wall (robot is blocked from moving there)
# [<, >, ^, v] : conveyors (robot is pushed to the next tile)
# + : rotation in positive direction (robot is rotated ccw)
# - : rotation in negative direction (robot is rotated cw)
# p : pit (robot takes damage)
# r : repair station (robot heals damage)
# [a,b,c,d] : flag (robot scores)
#
# occupant: Robot that is standing on the tile
def __init__(self, x, y, modifier=None):
if modifier == ' ':
self.modifier = None
else:
self.modifier = modifier
self.occupant = None
self.x = x
self.y = y
def get_neighbor_coordinates(self, direction):
# get the coordinates of the neighboring tile in the given direction
if direction == '^':
return (self.x, self.y - 1)
elif direction == '>':
return (self.x + 1, self.y)
elif direction == 'v':
return (self.x, self.y + 1)
elif direction == '<':
return (self.x - 1, self.y)
else:
print("error: unknown direction")
sys.exit(1)
def is_empty(self):
# check if the tile is non-empty and does not contain a wall
return self.occupant is None and self.modifier != '#'
def __str__(self):
if self.is_empty():
if self.modifier is None:
return ' '
else:
return self.modifier
else:
if self.occupant is None:
return self.modifier
else:
return str(self.occupant)
def __repr__(self):
return "({}, {}) occ: {} mod: {}".format(self.x, self.y, self.occupant, self.modifier)
class Board:
x_dims = 13 # number of tiles in x direction
y_dims = 7 # number of tiles in y direction
def __init__(self):
self.board = self.read_board_from_file('board.txt')
#self.read_board_from_file('board.txt')
# for x in range(Board.x_dims + 2):
# for y in range(Board.y_dims + 2):
# if (x == 0) or (x == Board.x_dims + 1) or (y == 0) or (y == Board.y_dims + 1):
# # place walls around the board
# self.board[(x, y)] = Tile(x, y, '#')
# elif y > 2 and y < 6 and x == 7:
# self.board[(x, y)] = Tile(x, y, '#')
# elif x == 1 and (y >= 1) and (y < 4):
# self.board[(x, y)] = Tile(x, y, 'v')
# elif y == 4:
# self.board[(x, y)] = Tile(x, y, '>')
# elif y == 1 and (x >= 2) and (x < 5):
# self.board[(x, y)] = Tile(x, y, '>')
# elif y == 1 and (x >= 6) and (x <= 8):
# self.board[(x, y)] = Tile(x, y, '<')
# else:
# self.board[(x,y)] = Tile(x,y)
#
# self.board[(5, 1)].modifier = '+'
# self.board[(5, 4)].modifier = '-'
# self.board[(2, 2)].modifier = 'p'
# self.board[(3, 3)].modifier = 'r'
#
# # place flags near the corners of the board
# self.board[(2,2)].modifier = 'a'
# self.board[(Board.x_dims-1, 2)].modifier = 'b'
# self.board[(Board.x_dims-1, Board.y_dims-1)].modifier = 'c'
# self.board[(2, Board.y_dims-1)].modifier = 'd'
# self.board[(2, 2)].modifier = '^'
# self.board[(2, 1)].modifier = '<'
self.robots = {}
#self.robots[0] = Robot(1, 1, 'v', 0, self.board)
#self.robots[1] = Robot(1, 2, 'v', 1, self.board)
#self.robots[2] = Robot(2, 1, '>', 2, self.board)
#self.robots[3] = Robot(2, 2, 'v', 3, self.board)
#self.create_robot(1,1,'>', 7, 11)
def read_board_from_file(self, file):
fh = open('board.txt').readlines()
Board.x_dims = len(fh[0].strip()) - 2
Board.y_dims = len(fh) - 2
board = {}
for y, line in enumerate(fh):
for x, tile_modifier in enumerate(line.strip()):
board[(x,y)] = Tile(x, y, tile_modifier)
return board
def create_robot(self, x, y, orientation, player_id, marker_id):
new_robot = Robot(x, y, orientation, marker_id, self.board)
self.robots[player_id] = new_robot
return new_robot
def handle_push(self, direction, pushed_robot, forward=True, pushing_robot=None):
cmd_list = []
# push robot out of the way
if pushed_robot.orientation == direction:
if forward:
# the pushed robot can just drive forward
cmd_list += self.handle_single_action('forward', pushed_robot)
else:
# the pushed robot can just drive backward
cmd_list += self.handle_single_action('backward', pushed_robot)
elif pushed_robot.has_opposite_orientation(direction):
if forward:
# the pushed robot can drive backward
cmd_list += self.handle_single_action('backward', pushed_robot)
else:
# the pushed robot drives forward
cmd_list += self.handle_single_action('forward', pushed_robot)
else:
# we first have to turn the pushed robot s.t. it faces in the same orientation as the
# pushing robot
turn_direction = pushed_robot.get_turn_direction(direction)
cmd_list += self.handle_single_action(turn_direction, pushed_robot)
if forward:
# then the pushed robot drives one step forward
cmd_list += self.handle_single_action('forward', pushed_robot)
else:
# if its pushed backward it instead drives on step backward
cmd_list += self.handle_single_action('backward', pushed_robot)
# afterwards we turn the robot back to the original orientation
if turn_direction == 'turn left':
turn_back_direction = 'turn right'
elif turn_direction == 'turn right':
turn_back_direction = 'turn left'
else:
print("error: invalid turn direction")
sys.exit(1)
cmd_list += self.handle_single_action(turn_back_direction, pushed_robot)
if pushing_robot is not None:
# now the tile should be empty so the pushing robot can move into the tile
if forward:
cmd_list.append(pushing_robot.move('forward'))
else:
cmd_list.append(pushing_robot.move('backward'))
return cmd_list
def handle_single_action(self, action, robot):
cmd_list = []
if 'forward' in action: # driving forward
if "x2" in action:
move_count = 2
elif "x3" in action:
move_count = 3
else:
move_count = 1
accessed_tiles = robot.get_accessed_tiles(move_count)
for tile in accessed_tiles:
if tile is None:
# this case should not happen
print("error: unknown state occured")
sys.exit(1)
elif tile.is_empty():
# if the tile is empty we can just move there
cmd_list.append(robot.move('forward'))
elif tile.modifier == '#': # robot hits a wall -> stop the robot
cmd_list.append(robot.nop())
return cmd_list
elif any([(tile.x, tile.y) == (r.x, r.y) for r in
self.robots.values()]): # robots hits a tile occupied by another robot
pushed_robot = next(filter(lambda r: (tile.x, tile.y) == (r.x, r.y), self.robots.values()))
if pushed_robot.is_pushable(robot.orientation): # check if robot is pushable in the given direction
cmd_list += self.handle_push(direction=robot.orientation, pushed_robot=pushed_robot, forward=True, pushing_robot=robot)
else:
cmd_list.append(robot.nop())
return cmd_list
else:
# this case should not happen
print("error: unknown state occured")
sys.exit(1)
elif action == 'backward':
# basically do the same as with forward
accessed_tiles = robot.get_accessed_tiles(1, forward=False)
for tile in accessed_tiles:
if tile is None:
# this case should not happen
print("error: unknown state occured")
sys.exit(1)
elif tile.is_empty():
# if the tile is empty we can just move there
cmd_list.append(robot.move('backward'))
elif tile.modifier == '#': # robot hits a wall -> stop the robot
cmd_list.append(robot.nop())
return cmd_list
elif any([(tile.x, tile.y) == (r.x, r.y) for r in
self.robots.values()]): # robots hits a tile occupied by another robot
pushed_robot = next(filter(lambda r: (tile.x, tile.y) == (r.x, r.y), self.robots.values()))
if pushed_robot.is_pushable(Robot.opposites[robot.orientation]): # check if robot is pushable in the given direction
cmd_list += self.handle_push(direction=robot.orientation, pushed_robot=pushed_robot, forward=False, pushing_robot=robot)
else:
cmd_list.append(robot.nop())
return cmd_list
else:
# this case should not happen
print("error: unknown state occured")
sys.exit(1)
else: # this means we have a turn action
cmd_list.append(robot.turn(action))
return cmd_list
def handle_board_element(self, robot):
cmd_list = []
tile = self.board[(robot.x, robot.y)]
if tile.modifier is None:
return cmd_list
elif tile.modifier in ['^', '>', 'v', '<']:
# board element pushes the robot to next tile
if robot.is_pushable(tile.modifier):
cmd_list += self.handle_push(direction=tile.modifier, pushed_robot=robot, forward=True)
else:
cmd_list.append(robot.nop())
elif tile.modifier == '+':
cmd_list.append(robot.turn('turn left'))
elif tile.modifier == '-':
cmd_list.append(robot.turn('turn right'))
elif tile.modifier == 'p':
robot.take_damage(1)
elif tile.modifier == 'r':
robot.heal_damage(1)
elif tile.modifier in 'abcd':
robot.pick_up_flag(tile.modifier)
return cmd_list
def apply_actions(self, cards):
cmd_list = []
# apply the actions to the board and generate a list of movement commands
for i, phase in enumerate(cards): # process register phases
print("processing phase {}".format(i+1))
# sort actions by priority
sorted_actions = sorted(phase, key=lambda a: a[1].priority)
for a in sorted_actions:
robot_id = a[0]
robot = self.robots[robot_id]
action = a[1].action
print("robot {} action {}".format(robot, action))
cmd_list += self.handle_single_action(action, robot)
print(self)
# apply the actions caused by board elements at the end of the phase
cmd_list += self.apply_board_element_actions()
print(self)
return cmd_list
def apply_board_element_actions(self):
cmd_list = []
remaining_robots = set(self.robots.values())
processed_robots = set()
# first we compute all tiles the robots would enter as a result of board game elements
target_tiles = {} # get target tiles for each robot
for r in remaining_robots:
tile = r.get_tile()
if tile.modifier in ['^', '>', 'v', '<']: # tile would push the robot around
direction = tile.modifier
target_tiles[r] = r.get_adjecent_tile(direction) # save tile the robot would be pushed to
# now we check if there are any conflicts
conflicting_tiles = set([x for x in target_tiles.values() if list(target_tiles.values()).count(x) > 1])
if len(conflicting_tiles) > 0: # check if any robots would be pushed to the same tile
# there is a conflict -> skip the board element execution and mark those robots as processed
conflicting_robots = set(filter(lambda r: target_tiles[r] in conflicting_tiles, target_tiles.keys()))
processed_robots = processed_robots.union(conflicting_robots)
# Now we process the board game elements for the robots which have no conflicts.
# We have to pay attention to the order of the execution in order to avoid robots pushing other robots
# during this phase.
# This is done in a loop because we don't know yet which robot goes first. For instance, it may happen that
# multiple robots are queued on a conveyor belt. Then we first have to move the robot which is furthest down the
# line, then the second one and so on
# By doing this in a loop we can automatically determine the correct order by checking for each robot if it can
# move and then processing the robot such that the next robot can move
while len(processed_robots) < len(self.robots):
# update remaining robots to process
remaining_robots = set(self.robots.values()) - processed_robots
# check which robots can be moved around
processable_robots = list(filter(lambda r: r.board_element_processable(), remaining_robots))
if len(processable_robots) > 0:
# handle the board game elements for robots that can move
for current_robot in processable_robots:
cmd_list += self.handle_board_element(current_robot)
processed_robots.add(current_robot)
else:
# this happens if there is a deadlock that cannot be resolved (e.g. caused by a cyclical conveyor belt)
break
return cmd_list
def __str__(self):
#output = '#' * (Board.x_dims + 2) + '\n'
output = ''
for y in range(Board.y_dims+2):
for x in range(Board.x_dims+2):
if any((r.x, r.y) == (x,y) for (r_id, r) in self.robots.items()):
r = next(filter(lambda r: (r[1].x,r[1].y) == (x,y), self.robots.items()))
output += str(r[0])
else:
output += str(self.board[(x, y)])
output += '\n'
#output += '#' * (Board.x_dims + 2)
for r_id, r in self.robots.items():
output += "Robot {}: {}\n".format(r_id, r.orientation)
return output
if __name__ == "__main__":
n = 5
deck = CardDeck(n=1000)
player_1_cards = deck.draw_cards(200)
#player_2_cards = deck.draw_cards(200)
#player_3_cards = deck.draw_cards(200)
#player_4_cards = deck.draw_cards(200)
#player_1_cards = random.sample(list(filter(lambda c: 'turn around' in c.action, deck.deck.values())), n)
#player_2_cards = random.sample(list(filter(lambda c: 'turn around' in c.action, deck.deck.values())), n)
#player_3_cards = random.sample(list(filter(lambda c: 'turn around' in c.action, deck.deck.values())), n)
#player_4_cards = random.sample(list(filter(lambda c: 'turn around' in c.action, deck.deck.values())), n)
cards_1 = [(0, c) for c in player_1_cards]
#cards_2 = [(1, c) for c in player_2_cards]
#cards_3 = [(2, c) for c in player_3_cards]
#cards_4 = [(3, c) for c in player_4_cards]
#chosen_cards = list(zip(cards_1, cards_2, cards_3, cards_4))
chosen_cards = list(zip(cards_1))
b = Board()
print(b)
b.apply_actions(chosen_cards)