def get_lines(self, color, coord):
pos_fin = Coordinate(coord.x, coord.y)
pos_inicial = Coordinate(coord.x, coord.y)
can_fichas_volteables = 0
vec_lineas = []
for inc_fila in xrange(-1, 2):
for inc_col in xrange(-1, 2):
pos_fin.x = pos_inicial.x + inc_fila
pos_fin.y = pos_inicial.y + inc_col
#Verifica que haya al menos una ficha del color opuesto para voltear
if Referee.can_turn(color, pos_inicial, inc_fila, inc_col,
self):
hash_linea = {}
vec_casillas = []
#Contar las fichas volteables en esa linea
while True:
can_fichas_volteables += 1
vec_casillas.append(Coordinate(pos_fin.x, pos_fin.y))
pos_fin.x += inc_fila
pos_fin.y += inc_col
if not self.__casilla[pos_fin.x][pos_fin.y] == -color:
break
hash_linea["casilla_inicial"] = pos_inicial
hash_linea["casilla_final"] = Coordinate(
pos_fin.x, pos_fin.y)
hash_linea["can_fichas_volteables"] = can_fichas_volteables
hash_linea["casillas_volteables"] = vec_casillas
vec_lineas.append(hash_linea)
can_fichas_volteables = 0
return vec_lineas
class Direction:
LEFT = Coordinate(-1, 0)
RIGHT = Coordinate(1, 0)
DOWN = Coordinate(0, -1)
UP = Coordinate(0, 1)
STAY = Coordinate(0, 0)
@staticmethod
def all():
return {
Direction.LEFT, Direction.RIGHT, Direction.UP, Direction.DOWN,
Direction.STAY
}
@staticmethod
def as_movement_delta(direction):
directions = {
"DOWN": (0, 1),
"UP": (0, -1),
"RIGHT": (1, 0),
"LEFT": (-1, 0),
"STAY": (0, 0)
}
return directions[direction.upper()]
def test_data_repository():
width = 10
height = 10
seed = random.randint(76, 76000)
print("seed:", seed)
a = SimPhysicalInterface(width, height, seed)
d = DataRepository(width, height)
print(a.env.text_map())
visit(a, d)
c = d.find_target(a.position, Coordinate(0, 0))
while c != Coordinate(0, 0):
print("target:", c)
p = d.find_path(a.position, c)
print("path:", p)
if len(p) > 0:
a.turn(p[0])
a.forward()
visit(a, d)
print(d.text_map(a.position, a.facing))
input()
c = d.find_target(a.position, Coordinate(0, 0))
def possibles_moves(color, tablero):
coordenadas = []
pos = Coordinate()
dimension = tablero.get_dimension()
for i in range(0, dimension):
for j in range(0, dimension):
pos.x = i
pos.y = j
if Referee.is_valid_move(color, pos, tablero):
nueva_pos = Coordinate(i, j)
coordenadas.append(nueva_pos)
return coordenadas
def __init__(self,
tablero,
turno=NEGRO,
etiqueta=MAX,
profundidad=0,
cantidad_hnos=0):
self.tablero = tablero.copy()
self.etiqueta = etiqueta
self.profundidad = profundidad
self.turno = turno
self.cantidad_hnos = cantidad_hnos
#Guardo la coordenada para llegar al mejor sucesor de este estado
self.mejor_sucesor = Coordinate()
#Guardo la accion que dio nacimiento al estado
self.iniciador = Coordinate()
def extract_coordinates(self) -> Coordinate:
""" inverse of coord_str starting from index cursor
:returns Coordinate """
x = self.extract_number()
y = self.extract_number()
return Coordinate(x, y)
def is_at_least_one_move(color, tablero):
dimension = tablero.get_dimension()
pos = Coordinate()
for i in range(0, dimension):
for j in range(0, dimension):
pos.x = i
pos.y = j
if Referee.is_valid_move(color, pos, tablero):
return True
return False
def number_of_successors(color, tablero):
cant_sucesores = 0
pos = Coordinate()
dimension = tablero.get_dimension()
for i in range(0, dimension):
for j in range(0, dimension):
pos.x = i
pos.y = j
if Referee.is_valid_move(color, pos, tablero):
cant_sucesores += 1
return cant_sucesores
def parse_telemetry(self):
"""
Parse a command received and turn it into a coordinate if possible
:return: The coordinate parsed from the command stream
"""
telemetry = self.buffer
self.buffer = ""
if telemetry[0] == '<':
if telemetry[len(telemetry) - 1] == '>':
values = telemetry[1:len(telemetry)-1].split(',')
coord = Coordinate(int(values[0]), int(values[1]))
return coord
return None
def turn_pieces(self, color, pos_ini):
pos_fin = Coordinate(pos_ini.x, pos_ini.y)
for inc_fila in xrange(-1, 2):
for inc_col in xrange(-1, 2):
pos_fin.x = pos_ini.x + inc_fila
pos_fin.y = pos_ini.y + inc_col
#Verifica que haya al menos una ficha del color opuesto para voltear
if Referee.can_turn(color, pos_ini, inc_fila, inc_col, self):
#Voltear las fichas
while True:
self.__casilla[pos_fin.x][pos_fin.y] = color
pos_fin.x += inc_fila
pos_fin.y += inc_col
if not self.__casilla[pos_fin.x][pos_fin.y] == -color:
break
#Actualizo los contadores de las fichas blancas o negras dependiendo del color
self.update_pieces_counters()
def test_message():
print(Message.coord_str(Coordinate(536, 0)))
assert Message.coord_str(Coordinate(536, 0)) == "536 0 "
print("passed Message.coord_str")
Message.set_my_robot_id(1)
m = Message()
m.add_objective(Coordinate(3, 5), 2.0)
print(m.get_data())
assert m.get_data() == Message.BEGIN + "1 1 j3 5 2.0k" + Message.END
print("passed add_objective")
m._cursor = 10
ov = m.extract_objective_value()
print(ov)
assert ov == 2.0
print("passed extract_objective_value")
m = Message()
m.add_obstacle(Coordinate(0, 6), Knowledge.YES)
print(m.get_data())
assert m.get_data() == Message.BEGIN + "1 2 s0 6 yt" + Message.END
print("passed add_obstacle")
m._cursor = 6
co = m.extract_coordinates()
print(co)
assert co == Coordinate(0, 6)
print("passed extract coordinate")
d = DataRepository(10, 10)
m.add_objective(Coordinate(6, 0), 7.0)
m.handle(d)
obs = d.get_obstacle(Coordinate(0, 6))
obj = d.get_objective(Coordinate(6, 0))
print(obs, obj)
assert obs == Knowledge.YES
assert obj == 7.0
print("passed handle")
def can_turn(color, pos_ini, dir_horizontal, dir_vertical, tablero):
pos_fin = Coordinate(pos_ini.x + dir_horizontal,
pos_ini.y + dir_vertical)
if not tablero.valid_coord(pos_fin):
return False
# Verifica que haya al menos una ficha del color opuesto en esa direccion
if tablero.get_casillas()[pos_fin.x][pos_fin.y] != -1 * color:
return False
# Ejecuto el while mientras la casilla del tablero contenga piezas del color opuesto,
# es decir no sea VACIO, ni de mi color, ni este fuera del tablero
while True:
pos_fin.x += dir_horizontal
pos_fin.y += dir_vertical
if not tablero.valid_coord(pos_fin):
return False
if tablero.get_casillas()[pos_fin.x][pos_fin.y] == board.VACIO:
return False
elif tablero.get_casillas()[pos_fin.x][pos_fin.y] == color:
return True
def __number_stable_boxes(self, tablero):
pos = Coordinate()
estables = []
dim = tablero.get_dimension()
for _ in xrange(dim):
estables.append([False] * dim)
cambio_estado = True
while (cambio_estado):
cambio_estado = False
for i in xrange(0, dim):
for j in xrange(0, dim):
pos.x = i
pos.y = j
if tablero.get_valor_casilla(
i, j
) != VACIO and not estables[i][j] and not self.__can_turn(
pos, tablero, estables):
estables[i][j] = True
cambio_estado = True
return estables
def __init__(self, nivel=1):
if nivel == Ai.FACIL:
self.__profundidad_maxima = 1
self.__frontera_peso = 1 #Cuanto mas fichas tengas en la frontera es peor
self.__movilidad_peso = 0 #Cuantas jugadas posible se tiene
self.__estabilidad_peso = 0 #Cuantas mas fichas logres estabilizar en la jugada mejor
self.__diferencia_cantidad_fichas_peso = 8
elif nivel == Ai.MEDIO:
self.__profundidad_maxima = 2
self.__frontera_peso = 1 #Cuanto mas fichas tengas en la frontera es peor
self.__movilidad_peso = 0 #Cuantas jugadas posible se tiene
self.__estabilidad_peso = 3 #Cuantas mas fichas logres estabilizar en la jugada mejor
self.__diferencia_cantidad_fichas_peso = 1
elif nivel == Ai.DIFICIL:
self.__profundidad_maxima = 3
self.__frontera_peso = 2 #Cuanto mas fichas tengas en la frontera es peor
self.__movilidad_peso = 1 #Cuantas jugadas posible se tiene
self.__estabilidad_peso = 5 #Cuantas mas fichas logres estabilizar en la jugada mejor
self.__diferencia_cantidad_fichas_peso = 4
else:
raise Exception("Nivel desconocido (Ai Class)")
#Guardo la ultima jugada de la PC
self.__ultima_jugada = Coordinate(0, 0)
def __border_pieces(self, tablero, color):
can_fichas_frontera = 0
dim = tablero.get_dimension()
for i in xrange(0, dim):
for j in xrange(0, dim):
es_frontera = False
if tablero.get_valor_casilla(i, j) == color:
aux_coord = Coordinate()
for inc_fila in xrange(-1, 2):
for inc_col in xrange(-1, 2):
aux_coord.x = i + inc_fila
aux_coord.y = j + inc_col
if not (inc_fila == 0 and inc_col == 0
and tablero.valid_pos(aux_coord)
and tablero.get_valor_casilla(
aux_coord.x, aux_coord.y) == VACIO):
es_frontera = True
inc_fila = 2
break
if es_frontera:
can_fichas_frontera += 1
return can_fichas_frontera
def create_robot_with_options(options: dict) -> Robot:
return Robot(options["width"], options["height"],
Coordinate(options["home_x"], options["home_y"]),
options["seed"], options["robot_id"], options["robot_count"])
def __init__(self):
self.position = Coordinate()
self.facing = Direction.EAST
def __init__(self, width: int, height: int, seed: int):
super().__init__()
self.env = EnvironmentSimulator()
self.env.generate(width, height, seed)
self.position = Coordinate(0, 0)
self.facing = Direction.EAST
