Skip to content
Snippets Groups Projects
Commit 8eee33b7 authored by Xuan Trinh's avatar Xuan Trinh
Browse files

Add more type hinting, change some of the parameter name to keep all the terms the same

parent 2471335a
Branches
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
.idea/inspectionProfiles/Project_Default.xml
+ 1
− 0
View file @ 8eee33b7
......@@ -13,6 +13,7 @@
<option name="ignoredIdentifiers">
<list>
<option value="tuple.*" />
<option value="dict.__getitem__" />
</list>
</option>
</inspection_tool>
......
search/movement_logic.py
+ 94
− 80
View file @ 8eee33b7
......@@ -19,85 +19,97 @@ Slide action logic:
# '-._.-'-._.-'
#
"""
row = 0
column = 1
ROW = 0
COLUMN = 1
# 1
def slide_left(coordinate):
def slide_left(coordinate: tuple[int, int]) -> tuple[int, int]:
if coordinate:
new_pos = (coordinate[row], coordinate[column] - 1)
new_pos = (coordinate[ROW], coordinate[COLUMN] - 1)
if not check_within_board(new_pos):
return coordinate
else:
print("Empty coordinate")
return
return new_pos
# 2
def slide_right(coordinate):
def slide_right(coordinate: tuple[int, int]) -> tuple[int, int]:
if coordinate:
new_pos = (coordinate[row], coordinate[column] + 1)
new_pos = (coordinate[ROW], coordinate[COLUMN] + 1)
if not check_within_board(new_pos):
return coordinate
else:
print("Empty coordinate")
return
return new_pos
# 3
def slide_up_left(coordinate):
def slide_up_left(coordinate: tuple[int, int]) -> tuple[int, int]:
new_pos = ()
if coordinate:
new_pos = (coordinate[row] + 1, coordinate[column] - 1)
new_pos = (coordinate[ROW] + 1, coordinate[COLUMN] - 1)
if not check_within_board(new_pos):
return coordinate
else:
print("Empty coordinate")
return
return new_pos
# 4
def slide_up_right(coordinate):
def slide_up_right(coordinate: tuple[int, int]) -> tuple[int, int]:
if coordinate:
new_pos = (coordinate[row] + 1, coordinate[column])
new_pos = (coordinate[ROW] + 1, coordinate[COLUMN])
if not check_within_board(new_pos):
return coordinate
else:
print("Empty coordinate")
return
return new_pos
# 5
def slide_down_left(coordinate):
def slide_down_left(coordinate: tuple[int, int]) -> tuple[int, int]:
if coordinate:
new_pos = (coordinate[row] - 1, coordinate[column])
new_pos = (coordinate[ROW] - 1, coordinate[COLUMN])
if not check_within_board(new_pos):
return coordinate
else:
print("Empty coordinate")
return
return new_pos
# 6
def slide_down_right(coordinate):
def slide_down_right(coordinate: tuple[int, int]) -> tuple[int, int]:
if coordinate:
new_pos = (coordinate[row] - 1, coordinate[column] + 1)
new_pos = (coordinate[ROW] - 1, coordinate[COLUMN] + 1)
if not check_within_board(new_pos):
return coordinate
else:
print("Empty coordinate")
return
return new_pos
......@@ -110,7 +122,7 @@ DOWN_LEFT = 5
DOWN_RIGHT = 6
OUT_OF_BOARD = 0
"""
:argument token - the selected game object that is presented by its position on board { (row, column)}
:argument piece - the selected game object that is presented by its position on board { (row, column)}
x - the adjacent game object
:return new position after the action is complete
if the new position is out of the board return the token's position instead
......@@ -124,182 +136,184 @@ Swing action logic:
RIGHT .-'-. UP_RIGHT .-'-._.-'-.
| 1 | | 1 | 2 |
.-'-._.-'-._.-'-. '-._.-'-._.-'-.
|token| [x] | 2 | | [x] | 3 |
|piece| [x] | 2 | | [x] | 3 |
'-._.-'-._.-'-._.-' .-'-._.-'-._.-'
| 3 | |token|
| 3 | |piece|
'-._.-' '-._.-'
OWN_RIGHT .-'-. UP_LEFT .-'-._.-'-.
|token| | 2 | 3 |
|piece| | 2 | 3 |
'-._.-'-._.-'-. .-'-._.-'-._.-'
| [x] | 1 | | 1 | [x] |
.-'-._.-'-._.-' '-._.-'-._.-'-.
| 3 | 2 | |token|
| 3 | 2 | |piece|
'-._.-'-._.-' '-._.-'
DOWN_LEFT .-'-. LEFT .-'-.
|token| | 3 |
|piece| | 3 |
.-'-._.-'-._.-' .-'-._.-'-._.-'-.
| 3 | [x] | | 2 | [x] |token|
| 3 | [x] | | 2 | [x] |piece|
'-._.-'-._.-'-. '-._.-'-._.-'-._.-'
| 2 | 1 | | 1 |
'-._.-'-._.-' '-._.-'
"""
def swing_to_tile_1(token, x):
position = get_relative_position(token, x)
def swing_to_tile_1(piece: tuple[int, int], x: tuple[int, int]) -> tuple[int, int]:
position = get_relative_position(piece, x)
new_position = ()
if position == LEFT:
new_postion = slide_down_left(slide_left(token))
new_position = slide_down_left(slide_left(piece))
if position == RIGHT:
new_postion = slide_up_right(slide_right(token))
new_position = slide_up_right(slide_right(piece))
if position == UP_RIGHT:
new_postion = slide_up_left(slide_up_right(token))
new_position = slide_up_left(slide_up_right(piece))
if position == UP_LEFT:
new_postion = slide_left(slide_up_left(token))
new_position = slide_left(slide_up_left(piece))
if position == DOWN_LEFT:
new_postion = slide_down_right(slide_down_left(token))
new_position = slide_down_right(slide_down_left(piece))
if position == DOWN_RIGHT:
new_postion = slide_right(slide_down_right(token))
new_position = slide_right(slide_down_right(piece))
# if the position of the token after the action complete is out of board, return the token position in
# stead
if compare_tile(new_postion, x):
return token
if compare_tile(new_position, x):
return piece
return new_postion
return new_position
def swing_to_tile_2(token, x):
position = get_relative_position(token, x)
def swing_to_tile_2(piece: tuple[int, int], x: tuple[int, int]) -> tuple[int, int]:
position = get_relative_position(piece, x)
new_position = ()
if position == LEFT:
new_postion = slide_left(slide_left(token))
new_position = slide_left(slide_left(piece))
if position == RIGHT:
new_postion = slide_right(slide_right(token))
new_position = slide_right(slide_right(piece))
if position == UP_RIGHT:
new_postion = slide_up_right(slide_up_right(token))
new_position = slide_up_right(slide_up_right(piece))
if position == UP_LEFT:
new_postion = slide_up_left(slide_up_left(token))
new_position = slide_up_left(slide_up_left(piece))
if position == DOWN_LEFT:
new_postion = slide_down_left(slide_down_left(token))
new_position = slide_down_left(slide_down_left(piece))
if position == DOWN_RIGHT:
new_postion = slide_down_right(slide_down_right(token))
new_position = slide_down_right(slide_down_right(piece))
# if the position of the token after the action complete is out of board, return the token position in
# stead
if compare_tile(new_postion, x):
return token
if compare_tile(new_position, x):
return piece
return new_postion
return new_position
def swing_to_tile_3(token, x):
position = get_relative_position(token, x)
def swing_to_tile_3(piece: tuple[int, int], x: tuple[int, int]) -> tuple[int, int]:
position = get_relative_position(piece, x)
new_position = ()
if position == LEFT:
new_postion = slide_up_left(slide_left(token))
new_position = slide_up_left(slide_left(piece))
if position == RIGHT:
new_postion = slide_down_right(slide_right(token))
new_position = slide_down_right(slide_right(piece))
if position == UP_RIGHT:
new_postion = slide_right(slide_up_right(token))
new_position = slide_right(slide_up_right(piece))
if position == UP_LEFT:
new_postion = slide_up_right(slide_up_left(token))
new_position = slide_up_right(slide_up_left(piece))
if position == DOWN_LEFT:
new_postion = slide_left(slide_down_left(token))
new_position = slide_left(slide_down_left(piece))
if position == DOWN_RIGHT:
new_postion = slide_down_left(slide_down_right(token))
new_position = slide_down_left(slide_down_right(piece))
# if the position of the token after the action complete is out of board, return the token position in
# stead
if compare_tile(new_postion, x):
return token
if compare_tile(new_position, x):
return piece
return new_postion
return new_position
def get_relative_position(token, x):
def get_relative_position(piece: tuple[int, int], x: tuple[int, int]) -> tuple[int, int]:
"""
:argument token - the selected game object that is presented by its position on board { (row, column)}
x - the adjacent game object
:param x: the adjacent game object
:argument piece: the selected game object that is presented by its position on board { (row, column)}
:return the position of x relative to token
-> using the slide direction as the position definition.
e.g left,right, up_left, up_right,..etc
"""
# check if x is to the left of tile
if compare_tile(slide_left(token), x):
if compare_tile(slide_left(piece), x):
return LEFT
# check if x is to the right of tile
if compare_tile(slide_right(token), x):
if compare_tile(slide_right(piece), x):
return RIGHT
# check if x is to the up_left of the tile
if compare_tile(slide_up_left(token), x):
if compare_tile(slide_up_left(piece), x):
return UP_LEFT
# check if x is to the up_right of the tile
if compare_tile(slide_up_right(token), x):
if compare_tile(slide_up_right(piece), x):
return UP_RIGHT
# check if x is to the down_left of the tile
if compare_tile(slide_down_left(token), x):
if compare_tile(slide_down_left(piece), x):
return DOWN_LEFT
# check if x is to the down_right of the tile
if compare_tile(slide_down_right(token), x):
if compare_tile(slide_down_right(piece), x):
return DOWN_RIGHT
def compare_tile(tile1, tile2):
def compare_tile(tile1: tuple[int, int], tile2: tuple[int, int]) -> bool:
"""
:argument tile1 - compose of (row, column)
tile2 - compose of (row, column)
:param tile2: compose of (row, column)
:param tile1: compose of (row, column)
:return true if both of the row and column are matches between 2 tiles
"""
return tile1[row] == tile2[row] \
and tile1[column] == tile2[column]
return tile1[ROW] == tile2[ROW] \
and tile1[COLUMN] == tile2[COLUMN]
def check_within_board(tile):
def check_within_board(tile: tuple[int, int]) -> bool:
"""
ensure that the tile is exist within the board
:param tile: coordinate of the tile
:return: true if the tile exist within the board, else false
"""
if tile[row] < -4 or tile[row] > 4:
if tile[ROW] < -4 or tile[ROW] > 4:
return False
if tile[column] < -4 or tile[column] > 4:
if tile[COLUMN] < -4 or tile[COLUMN] > 4:
return False
if tile[column] in [-4, -3, -2, -1] and tile[row] < -4 - tile[column]:
if tile[COLUMN] in [-4, -3, -2, -1] and tile[ROW] < -4 - tile[COLUMN]:
return False
if tile[column] in [4, 3, 2, 1] and tile[row] > 4 - tile[column]:
if tile[COLUMN] in [4, 3, 2, 1] and tile[ROW] > 4 - tile[COLUMN]:
return False
return True
def distance_between(Upper_token, Lower_token):
def distance_between(piece: tuple[int, int], target: tuple[int, int]) -> bool:
"""
:argument Upper_token - compose of (row, column)
:argument Lower_token - compose of (row, column)
:argument piece - compose of (row, column)
:argument target - compose of (row, column)
:return the number of step from upper's token to lower's token
Taken from https://www.redblobgames.com/grids/hexagons/
......@@ -307,7 +321,7 @@ def distance_between(Upper_token, Lower_token):
->
"""
dx = abs(Upper_token[1] - Lower_token[1])
dy = abs(Upper_token[0] - Lower_token[0])
dx = abs(piece[1] - target[1])
dy = abs(piece[0] - target[0])
result = dx + max(0, (dy - dx) / 2)
return result
search/search_algorithm.py
+ 10
− 10
View file @ 8eee33b7
......@@ -29,9 +29,9 @@ HIGHEST_RANK = 0
# Global variable:
# All the dictionary is made into global variable since all method is interact with them
upperPiecesDict = {}
lowerPiecesDict = {}
setBlocks = set()
upperPiecesDict: dict[str, tuple] = {}
lowerPiecesDict: dict[str, tuple] = {}
setBlocks: set[tuple, ...] = set()
targetsDict = {}
# keep track all the lower player's piece <- to ensure no two Upper piece can target only one distinguish lower piece
......@@ -41,10 +41,12 @@ targetedPiece = set()
# this help rank the action.
positionHistory = {}
board = {}
board: dict[tuple:str] = {}
'''
METHOD
'''
def get_weaker_piece(piece: str) -> str:
"""
get the weaker piece type in low case
......@@ -87,8 +89,6 @@ def make_board():
board[block] = BLOCK
def check_valid_action(piece: str, new_position: tuple) -> bool:
"""
check if the action is resolved successfully.
......@@ -110,7 +110,7 @@ def check_valid_action(piece: str, new_position: tuple) -> bool:
if new_position in board.keys():
if board[new_position] == BLOCK:
return False
if piece_collision(board[new_position], piece) != DRAW:
if result_of_collision(board[new_position], piece) != DRAW:
return False
return True
......@@ -149,7 +149,7 @@ def rank(position: tuple, piece: str) -> int:
return baseRank + reduceFactor
def piece_collision(pieceA: str, pieceB: str) -> int:
def result_of_collision(pieceA: str, pieceB: str) -> int:
"""
Our upper pieces are R, P and S, lower pieces are r, p and s
We will convert both to lower case letters and check each case
......@@ -312,7 +312,7 @@ def perform_optimal_combination(move_list: dict):
break
if move_list[piece][index] in board.keys() and\
piece_collision(board[move_list[piece][index]], piece) != DRAW:
result_of_collision(board[move_list[piece][index]], piece) != DRAW:
index += 1
continue
......
search/test.py deleted 100644 → 0
+ 0
− 8
View file @ 2471335a
from search.movement_logic import distance_between
print(distance_between((2, -2), (4, 0)))
print(distance_between((2, -1), (4, 0)))
print(distance_between((1, 0), (4, 0)))
print(distance_between((0, 0), (4, 0)))
print(distance_between((0, -1), (4, 0)))
print(distance_between((1, -2), (4, 0)))
\ No newline at end of file
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment