def print_shortest_path(graph, upperL, lowerL, blockL, dist, pred):
path = {}
ord_path = {}
crawl = []
paths = min(len(upperL), len(lowerL)) # numnber of paths
pathl = 0 # largest path length
# Intialising paths
for p in range(paths):
crawl.append(lowerL[p][1:])
path[lowerL[p]] = [crawl[p]]
ord_path[lowerL[p]] = [crawl[p]]
# Adding Predecessors to paths and ordering.
for p in range(paths):
while (pred[p][crawl[p]] != -1):
path[lowerL[p]].append(pred[p][crawl[p]])
crawl[p] = pred[p][crawl[p]]
pathl = max(pathl, len(path[lowerL[p]]))
for i in range(pathl - 1, -1, -1):
if path[lowerL[p]][i]:
ord_path[lowerL[p]].append(path[lowerL[p]][i])
# Printing out pathways
for i in range(1, pathl):
for p in range(paths):
if i + 1 < len(ord_path[lowerL[p]]):
prev = ord_path[lowerL[p]][i]
curr = ord_path[lowerL[p]][i + 1]
if curr in hex_neighbors(prev[0], prev[1], 4):
print_slide(i, prev[0], prev[1], curr[0], curr[1])
else:
print_swing(i, prev[0], prev[1], curr[0], curr[1])
def print_shortest_path(graph, upperL, lowerL, blockL, dist, pred):
path = {}
crawl = []
paths = min(len(upperL), len(lowerL))
# Intialising paths
for p in range(paths):
#print(lowerL[p][1:])
crawl.append(lowerL[p][1:])
path[lowerL[p]] = [crawl[p]]
for p in range(paths):
t = 0
while (pred[p][crawl[p]] != -1):
path[lowerL[p]].append(pred[p][crawl[p]])
crawl[p] = pred[p][crawl[p]]
t += 1
c = 1
for i in range(len(path[lowerL[p]]) - 1, -1, -1):
if path[lowerL[p]][i - 1] != path[lowerL[p]][-1]:
prev = path[lowerL[p]][i]
curr = path[lowerL[p]][i - 1]
if curr in hex_neighbors(prev[0], prev[1], 4):
print_slide(c, prev[0], prev[1], curr[0], curr[1])
else:
print_swing(c, prev[0], prev[1], curr[0], curr[1])
c += 1
def main():
# 1. validate and load input
try:
with open(sys.argv[1]) as file:
state = State.from_json(file)
state.print("Initial state")
except (IndexError, FileNotFoundError):
print("usage: python3 -m search path/to/input.json", file=sys.stderr)
sys.exit(1)
# 2. compute solution
soln = astar_search(
start=state,
goal_test=goal_test,
heuristic=heuristic,
)
# 3. print solution
if soln is not None:
for t, actions in enumerate(soln, 1):
for a, x, y in actions:
if a == "SLIDE":
print_slide(t, *x, *y)
else:
print_swing(t, *x, *y)
print("# Done!")
else:
print("# No solution found")
def main():
"""
The main entry point of the program which control the main flow of the
simulation of the single player RoPaSci 360 game.
"""
# Read the data from the given json file and load them into a dictionary
try:
with open(sys.argv[1]) as file:
data = json.load(file)
except IndexError:
print("usage: python3 -m search path/to/input.json", file=sys.stderr)
sys.exit(1)
# TO-DO:
# Find and print a solution to the board configuration described
# by `data`.
# Why not start by trying to print this configuration out using the
# `print_board` helper function? (See the `util.py` source code for
# usage information).
# Refine the data from the json into separate dictionaries each for a
# type of token or block in the game
ally_dict, enemy_dict, block_dict = read_file(data)
# Run the best first search and find the solution for the problem
path = best_first_search(ally_dict, enemy_dict, block_dict)
# Retrace the states and find the actions taken by each token
prev_state_dict = {}
time = 0
for state in path:
ally_dict, enemy_dict = state
# Populate the dictonary with states of each tokens in current state
curr_state_dict = {}
for key, values in ally_dict.items():
for token in values:
curr_state_dict[token] = key
# Find the actions taken and print it to stdout
if len(prev_state_dict) != 0:
for token in curr_state_dict:
prev_r, prev_q = prev_state_dict[token]
curr_r, curr_q = curr_state_dict[token]
distance = hex_distance((prev_r, prev_q), (curr_r, curr_q))
# It's a slide action
if distance == 1:
print_slide(time, prev_r, prev_q, curr_r, curr_q)
# It's a swing action
elif distance == 2:
print_swing(time, prev_r, prev_q, curr_r, curr_q)
else:
print("# Unknown Move")
prev_state_dict = copy.deepcopy(curr_state_dict)
time += 1
def do(self, board, turn):
# Does the action to the board
if self.action_type == 'SLIDE':
print_slide(turn, self.token.r, self.token.q, self.r, self.q)
board.move(self.token, self.r, self.q)
elif self.action_type == 'SWING':
print_swing(turn, self.token.r, self.token.q, self.r, self.q)
board.move(self.token, self.r, self.q)
elif self.action_type == "THROW":
board.throw(self.token)
def func_update_state(turn, upper_tuple, state, open_close_dict, sorted_goal_dict):
# 注意！！！！！！！！！！！！！！！！！！！！！！！random只有写入update close，才逻辑不出错！！！！！下次把这个移动到update close list的地方！！！
# if upper_tuple already reached the goal
possible_random_move = []
if upper_tuple not in sorted_goal_dict.keys():
# check surroundings to make a best decision
# print(possible_random_move) --> [[1, -3], [2, -4], [3, -4], [2, -2], [1, -2], [4, -4], [4, -3], [3, -2]]
possible_random_move = func_open_list(
state, list(open_close_dict[upper_tuple][1][-1]), ['r', 1, 1], 1)
if len(possible_random_move) > 1:
for upper in open_close_dict.keys():
if upper != upper_tuple:
if open_close_dict[upper][1][-1] in possible_random_move:
possible_random_move.remove(
open_close_dict[upper][1][-1])
state[tuple(possible_random_move[0])] = upper_tuple[0]
if slide_or_swing(open_close_dict[upper_tuple][1][-1], possible_random_move[0]) == 'SWING':
print_swing(turn, open_close_dict[upper_tuple][1][-1][0], open_close_dict[upper_tuple]
[1][-1][1], possible_random_move[0][0], possible_random_move[0][1])
else:
print_slide(turn, open_close_dict[upper_tuple][1][-1][0], open_close_dict[upper_tuple][1][-1][1],
possible_random_move[0][0], possible_random_move[0][1])
open_close_dict[upper_tuple][1].append(possible_random_move[0])
# delete the previous position upper token is in the state
del state[tuple(open_close_dict[upper_tuple][1][-2])]
if len(possible_random_move) == 1:
for upper in open_close_dict.keys():
if upper != upper_tuple and open_close_dict[upper][1][-1] == possible_random_move[0]:
# new_possible_move = [[x,y, cost],[]...]
new_possible_move = func_open_list(
state, open_close_dict[upper][1][-2], ['r', 1, 1], 0)
open_close_dict[upper][0] = new_possible_move
min_cost_move = func_min_move(open_close_dict, upper)
if min_cost_move[0:2] == open_close_dict[upper_tuple][1][-1]:
min_cost_move = func_min_move(open_close_dict, upper)
open_close_dict[upper][1][-1] = min_cost_move[0:2]
return state
else:
symbol = upper_tuple[0]
state[tuple(open_close_dict[upper_tuple][1][-1])] = symbol
if slide_or_swing(open_close_dict[upper_tuple][1][-2], open_close_dict[upper_tuple][1][-1]) == 'SWING':
print_swing(turn, open_close_dict[upper_tuple][1][-2][0], open_close_dict[upper_tuple][1][-2][1],
open_close_dict[upper_tuple][1][-1][0], open_close_dict[upper_tuple][1][-1][1])
else:
print_slide(turn, open_close_dict[upper_tuple][1][-2][0], open_close_dict[upper_tuple][1][-2][1],
open_close_dict[upper_tuple][1][-1][0], open_close_dict[upper_tuple][1][-1][1])
del state[tuple(open_close_dict[upper_tuple][1][-2])]
return state
def main():
try:
with open(sys.argv[1]) as file:
data = json.load(file)
except IndexError:
print("usage: python3 -m search path/to/input.json", file=sys.stderr)
sys.exit(1)
# TEST IF BOARD MOVE WORKS
firstNode = Node(reformat_board(data), 0, [])
graph = Graph(firstNode)
solution = search(graph)
path = []
while solution:
path.insert(0, solution)
solution = solution.predecessor
for node in path:
for p, q in node.moveset:
if node.distance(p, q) == 1:
print_slide(node.depth, p[0], p[1], q[0], q[1])
elif node.distance(p, q) == 2:
print_swing(node.depth, p[0], p[1], q[0], q[1])