def test_epsilon_cfpq_tensors(self):
grammar, epsilon_set = Graph.recursive_automata_from_file(epsilon_tensors_grammar_path)
graph = Graph.from_file(graph_path)
actual_res = context_free_path_querying_tensors(grammar, epsilon_set, graph)
self.assertEqual(actual_res['a'].nonzero().nvals, 3)
self.assertEqual(actual_res['b'].nonzero().nvals, 2)
self.assertEqual(actual_res['S'].nonzero().nvals, 9)
def test_graph_regex_abc(self):
args = parser.parse_args(
args=('--graph ' + resources_path + '/graph.txt ' + '--queries ' +
resources_path + '/queries/regex_abc.txt').split())
graph = Graph.from_file(args.graph)
query = Graph.from_regex_file(args.queries)
automata, reachable_vertices_matrix = execute_query(args, graph, query)
excepted_reachable_vertices = {(0, 1), (0, 2), (0, 3), (1, 2), (1, 3),
(2, 3)}
for i, j, _ in zip(*reachable_vertices_matrix.nonzero().to_lists()):
self.assertEqual(reachable_vertices_matrix[i, j], (i, j)
in excepted_reachable_vertices)
def test_epsilon_context_free_path_querying_matrices(self):
grammar = CNF.from_file(epsilon_matrices_grammar_path)
graph = Graph.from_file(graph_path)
actual_res = context_free_path_querying_matrices(grammar, graph)
self.assertEqual(actual_res['A'].nonzero().nvals, 3)
self.assertEqual(actual_res['B'].nonzero().nvals, 2)
self.assertEqual(actual_res['S'].nonzero().nvals, 5)
def test_cfpq(self):
grammar = CNF.from_file(grammar_path, is_reduced=True)
graph = Graph.from_file(graph_path)
actual_res = context_free_path_querying(grammar, graph)
self.assertEqual(len(actual_res), len(expected_res))
for tuple in expected_res:
self.assertTrue(actual_res.__contains__(tuple))
def test_graph_regex_abc_from0_to2(self):
args = parser.parse_args(
args=('--graph ' + resources_path + '/graph.txt ' + '--queries ' +
resources_path + '/queries/regex_abc.txt ' + '--fr ' +
resources_path + '/vertices_0.txt ' + '--to ' +
resources_path + '/vertices_2.txt').split())
graph = Graph.from_file(args.graph)
query = Graph.from_regex_file(args.queries)
automata, reachable_vertices_matrix = execute_query(args, graph, query)
self.assertEqual(automata['a'].nonzero().nvals, 1)
self.assertEqual(automata['b'].nonzero().nvals, 2)
self.assertEqual(automata['c'].nonzero().nvals, 2)
excepted_reachable_vertices = {(0, 2)}
for i, j, _ in zip(*reachable_vertices_matrix.nonzero().to_lists()):
self.assertEqual(reachable_vertices_matrix[i, j], (i, j)
in excepted_reachable_vertices)
def test_recursive_automata_from_file(self):
graph, epsilon_set = Graph.recursive_automata_from_file(
test_resources_path + 'recursive.txt')
self.assertEqual(graph['a'].nonzero().nvals, 1)
self.assertEqual(graph['b'].nonzero().nvals, 2)
self.assertEqual(graph['S'].nonzero().nvals, 1)
self.assertEqual(len(epsilon_set), 0)
def test_from_file(self):
graph = Graph.from_file(test_resources_path + 'graph.txt')
self.assertEqual(graph['a'].nonzero().nvals, 1)
self.assertEqual(graph['b'].nonzero().nvals, 2)
self.assertEqual(graph['c'].nonzero().nvals, 2)
self.assertTrue(graph['a'][0, 1])
self.assertTrue(graph['b'][1, 2])
self.assertTrue(graph['c'][2, 3])
self.assertTrue(graph['c'][0, 1])
self.assertTrue(graph['b'][1, 3])
from src.classes import Enemy, Graph
from src.config import SIZE
from src.game import init, start
# Este archivo se encarga de las funciones principales del juego
if __name__ == "__main__":
SCREEN, CLOCK, BACKGROUND = init(SIZE)
while True:
Enemy.Clean() # Se limpia el array que guarda los enemigos en pantalla
Graph.Clean() # Se limpia el array que guarda las graficas a dibujar
# El siguiente codigo genera Enemigos, siendo estos las cajas.
start(
SCREEN, CLOCK, BACKGROUND
) # Se llama a la funcion start pasandole las variables screen y clock
type=str,
help='sqr closure is default, set adj for adj closure')
parser.add_argument(
'--fr',
required=False,
default=None,
type=str,
help='path to file with start vertices\nfile format:\n0 1 2')
parser.add_argument(
'--to',
required=False,
default=None,
type=str,
help='path to file with end vertices\nfile format:\n0 1 2')
args = parser.parse_args()
graph = Graph.from_file(args.graph)
for subdir, dirs, files in os.walk(args.queries):
for filename in files:
filepath = subdir + os.sep + filename
print(filepath)
queryGraph = Graph.from_regex_file(filepath)
start_working_time = time.time()
intersection, reachable_vertices = execute_query(
args, graph, queryGraph)
print('intersection statistic:')
counter = 0
for label, matrix in intersection.label_matrices.items():
counter += matrix.nonzero().nvals
# print('label: ', label, ': ', matrix.nonzero().nvals, ' - vertices amount')
print(args.graph, ': vertices amount: ', counter)
start_printing_working_time = time.time()
def start(screen, clock, background):
player = None
last_cursor_position = [
21,
HEIGHT - 21,
]
time_calculated = 0 # Variable que guardara cuando demorara el tiro en caer al piso
xfinal = 0 # Variable que guardara cual sera la posicion final en X
ymedia = 0 # Variable que guardara cual sera la altura maxima en Y
background.set_image("./assets/bgi.png")
while True: # Mientras el usuario esta decidiendo strength y angle
check_close()
player_y = HEIGHT - FLOOR - 21
background.draw(screen) # Se dibuja el fondo en screen
# Se dibuja la linea que va del puntero del cursor al inicio del jugador
pygame.draw.line(screen, (0, 0, 0), (21, player_y),
(last_cursor_position[0], last_cursor_position[1]), 4)
# Se dibuja el texto de la variable global Creditos en pantalla
draw_text(screen, CREDITS, (15, 15))
# Se asigna a last_cursor_position la posicion actual del cursor a traves de eventos
last_cursor_position = [
pygame.mouse.get_pos()[0]
if pygame.mouse.get_pos()[0] > 21 else 21,
pygame.mouse.get_pos()[1]
if pygame.mouse.get_pos()[1] < player_y else player_y,
]
strength = round(
math.sqrt((last_cursor_position[0] - 21.0)**2 +
((player_y - last_cursor_position[1]))**2),
2,
) # Se pitagoras para conseguir la hipotenusa de las coordenadas
try:
angle = round(
math.degrees(
math.atan((player_y - last_cursor_position[1]) /
(last_cursor_position[0] - 21.0))),
2,
) # Se consigue el angulo con arco tangente y/x
except ZeroDivisionError:
angle = 90 # Si x es 0 se asigna al angulo 90
# Se calcula el tiempo que va a demorar el jugador en llegar al piso
formula_1 = strength * math.sin(math.radians(angle))
time_calculated = round((formula_1 * 2) / GRAVITY, 2)
# Se calcula la posicion en X final
xfinal = round(
strength * math.cos(math.radians(angle)) * time_calculated, 2)
# Se calcula la altura maxima
ymedia = round(
(time_calculated / 2) * formula_1 + (GRAVITY / 2) *
((time_calculated / 2)**2) * -1,
2,
)
# Se dibujan los enemigos en pantalla
for enemy in Enemy.list_objects:
enemy.draw(screen)
for row in enumerate([
"|F|: %s N/m" % str(strength),
"angle: %s°" % str(angle),
"*Tiempo Final: %s s" % str(time_calculated),
"*Posicion en X Final: %s m" % str(xfinal),
"*Posicion en Y Maxima: %s m (Altura Maxima)" % str(ymedia),
]):
draw_text(screen, row[1],
(10, 200 + 20 * row[0])) # Se dibuja texto en pantalla
# Se espera el evento de clic para lanzar
if pygame.mouse.get_pressed()[0]:
# Una vez se hace clic se crea el jugador y se inicia el siguiente while parando a este
player = Player("./assets/player.png", strength, angle)
break
pygame.display.update() # Se actualiza la pantalla
# Si alguno de los datos calculados es 0 se le asgina 1, estos datos
# son usados para el escalado de las graficas
# Por ende modificarlos no afectaria a ninguna muestra en el juego visual,
# se asigna a 1 para que la division no de error
if ymedia == 0:
ymedia = 1
pvgo = player.vy
if player.vy == 0:
pvgo = 1
if xfinal == 0:
xfinal = 1
data1 = time_calculated * 1000
if data1 == 0:
data1 = 1
# Se crean objetos de clase Garfica
Graph(175, "y (m)", "x (m)", -1, text_graph_XY, [[0, 0]], xfinal, ymedia)
Graph(45, "Vy", "t (s)", 1, text_graph_TV, [], data1, pvgo)
Graph(45, "y (m) ", "t (s)", -1, text_graph_T, [[0, 0]], data1, ymedia)
Graph(45, "x (m) ", "t (s)", 1, text_graph_T, [[0, 0]], data1, xfinal)
# Se consigue el tiempo inicial del juego, ya que el tiempo
# empieza a incrementarse una vez que se inicia el juego.
start_tick = pygame.time.get_ticks()
background.set_image("./assets/bg.png")
# Esta variable controlara si hay que seguir escribiendo el aumento del tiempo
update_time = True
elapsed = 0 # Esta variable tendra lo que demoro en ejecutar el codigo
half_gravity = GRAVITY / 2
while True:
# Se asigna lo que se demoro en ejecutar el codigo al dato de la ultima linea de este while
calculated_value = pygame.time.get_ticks() - start_tick
time = calculated_value if calculated_value - elapsed < 0 else calculated_value - elapsed
check_close()
if pygame.mouse.get_pressed(
)[2]: # Si el usuario hace clic derecho se termina el while
break
if player.rect.bottom < HEIGHT - FLOOR or time < 100:
# Si la parte de abajo del jugador es menor que la altura del piso,
# siendo q el Y se incrementa hacia abajo
# Normalmente esto seria si la parte de abajo del jugador es mayor al piso
# Se realiza el movimiento con la Ley Horaria de MURV en Y
time_ms = time / 1000.0
player.rect.y = player.y - player.vy * time_ms + half_gravity * (
time_ms**2)
if player.rect.left >= 0 or player.rect.right <= WIDTH:
# Si el jugador se encuentra dentro de la pantalla en X
# Se mueve al jugador en X con MRU
player.rect.x = player.x + player.vx * time_ms
elif update_time:
# Si el jugador se da contra el piso
Graph.active = False # Se dejan de agregar valores a las graficas
update_time = time # Se deja de actualizar el tiempo
if Enemy.falling or (player.rect.right >= Enemy.area_objects[0]
and player.rect.left <= Enemy.area_objects[1]):
# Si hay enemigos cayendo o el jugador esta en el area de enemigos
Enemy.check_collision(time)
# Se comprueban colisiones de jugador con enemigos
player.check_collision(Enemy.get_active_enemies())
if update_time: # Si se tiene que actualizar el tiempo en variables
# Se da el tiempo normal
draw_handler(screen, time, player, Graph.Array, Enemy, background)
else:
# Si no se da el guardado cuando el jugador se da contra el piso
draw_handler(screen, update_time, player, Graph.Array, Enemy,
background)
# Se asigna el maximo de FPS a 120 y esta variable es la que de la diferencia
elapsed = clock.tick(120)