def shoot(self, bullet_collection, counter, speed):
# se crea el controlador de animaciones y se inicializa con la textura
bullet_anim = anim.Anim_Controller(self.bullet_animations, [BULLET_SIZE, BULLET_SIZE * WIDTH / HEIGHT, 1], 0)
bullet_anim.Play("shooted") # se pone la textura de la bala
#se crea un nodo que contiene la animacion
scaled_bullet = sg.SceneGraphNode("scaled_bullet")
scaled_bullet.transform = tr.rotationZ(np.pi)
scaled_bullet.childs += [bullet_anim]
# se crea un nodo con una gpuShape que servira para detectar las colisiones y verlas si se quiere
collision_node = sg.SceneGraphNode("collision_enemyBullet")
# se escala la hitbox para que tenga el mismo tamaño que la textura
collision_node.transform = tr.scale(1, 1 * WIDTH / HEIGHT, 1)
collision_node.childs += [es.toGPUShape(cl.createCircleHitbox(BULLET_HITBOX_RADIO, 10, 0, 1, 0))]
# se crea uno nodo/objeto CollisionShape que tiene informacion y metodos para detectar colisiones con respecto de una gpuShape
scaled_collision = cl.CollisionShape("scaled_collision", BULLET_HITBOX_RADIO, True)
scaled_collision.transform = tr.rotationZ(np.pi) #se voltea
scaled_collision.childs += [collision_node]
#posicion donde aparece la bala
tempPos = self.position + self.bullet_pos
# se crea el objeto bullet que contendra como nodos hijos a la animacion y la hitbox
bullet_object = go.bulletObject("bullet" + str(counter))
bullet_object.fromEnemy = True #es bala enemiga
# se traslada la bala en la pantalla a su posicion inicial
bullet_object.transform = tr.translate(tempPos[0], tempPos[1], tempPos[2])
bullet_object.position = tempPos
bullet_object.velocity[1] = -speed #se indica su velocidad
bullet_object.childs += [scaled_bullet] #se agrega la animacion
bullet_object.childs += [scaled_collision] #se agrega la hitbox
bullet_object.childs[1].parent = bullet_object # se agrega la referencia de padre al objeto CollisionShape
#se agrega el objeto bullet a la collecion de balas enemigas
bullet_collection.childs += [bullet_object]
def setupfinishAnim(lose_image, win_image):
global MAIN_NODE, BACKGROUND_ANIM, LETTERS_ANIM, WIN_ANIM
backGround_frames = anim.createFrames(lose_image, [256, 76], [0, 0], [10, 1], [0, 0]) #se recorta la imagen
letters_frames = anim.createFrames(lose_image, [256, 76], [0, 0], [10, 1], [1, 0]) #se recorta la imagen
bg_animations = {"appear" : anim.Animation(backGround_frames, 9, False, False)} #se crean las animaciones
lt_animations = {"appear": anim.Animation(letters_frames, 9, False, False)} #se crean las animaciones
#Se crean los controladores de las animaciones y se inicializan
BACKGROUND_ANIM = anim.Anim_Controller(bg_animations, [2, WIDTH / HEIGHT * 1, 1], 0)
BACKGROUND_ANIM.Play("appear")
LETTERS_ANIM = anim.Anim_Controller(lt_animations, [2 * 0.4, WIDTH / HEIGHT * 0.4, 1], 0)
LETTERS_ANIM.Play("appear")
win_frames = anim.createFrames(win_image, [128, 192], [0, 0], [2, 11], [0, 0]) #se recorta la imagen
win_animations = {"appear": anim.Animation(win_frames, 12, False, False)} #se crea la animacion
# Se crea el controlador de la animacion y se inicializa
WIN_ANIM = anim.Anim_Controller(win_animations, [2, WIDTH / HEIGHT * 2 * 1.5, 1], 0)
WIN_ANIM.Play("appear")
def addEnemies2(enemies_collection, amount):
global enemy_counter, enemy2_center
#se inicializan los valores para el centro de rotacion
enemy2_center[0] = 0
enemy2_center[1] = ENEMY2_SPAWN_POSY
#angulo para distribuir radialmente a las naves
tempTheta = 2 * np.pi / amount
# se distribuyen los enemigos en la pantalla segun su cantidad
for enemy in range(amount):
# se crea el controlador de animaciones y se inicializa
enemy_anim = anim.Anim_Controller(enemy2_animations, [ENEMY2_SIZE, ENEMY2_SIZE * WIDTH/HEIGHT, 1], 0)
enemy_anim.Play("flying")
# se define su posicion
temp_posX = enemy2_center[0] + enemy2_radio * math.cos(tempTheta * enemy) * 2.5
temp_posY = enemy2_center[1] + enemy2_radio * math.sin(tempTheta * enemy)* WIDTH / HEIGHT
# se crea un nodo que contiene la animacion y que la voltea
scaled_enemy = sg.SceneGraphNode("scaled_enemy")
scaled_enemy.transform = tr.rotationZ(np.pi)
scaled_enemy.childs += [enemy_anim]
# se crea un nodo con una gpuShape que servira para detectar las colisiones y verlas si se quiere
collision_node = sg.SceneGraphNode("collision_enemy2")
collision_node.transform = tr.scale(1, 1* WIDTH / HEIGHT, 1)
collision_node.childs += [es.toGPUShape(cl.createCircleHitbox(ENEMY2_HITBOX_RADIO, 10, 0, 1, 0))]
# se crea uno nodo/objeto CollisionShape que tiene informacion y metodos para detectar colisiones con respecto de una gpuShape
scaled_collision = cl.CollisionShape("scaled_collision", ENEMY2_HITBOX_RADIO, True)
scaled_collision.transform = tr.rotationZ(np.pi)
scaled_collision.childs += [collision_node]
# se crea el objeto enemy que contendra como nodos hijos a la animacion y la hitbox
enemy_object = enemyObject("enemy" + str(enemy_counter))
enemy_object.theta = tempTheta * enemy
enemy_object.enemy = 2 # es el tercer tipo de enemigos
# se traslada la nave en la pantalla a su posicion inicial
enemy_object.transform = tr.translate(temp_posX, temp_posY, 0)
enemy_object.position[0] = temp_posX
enemy_object.position[1] = temp_posY
enemy_object.position[2] = 0
enemy_object.velocity = [0, ENEMY2_CENTER_SPEED, 0] #se indica la velocidad del centro de rotacion
enemy_object.childs += [scaled_enemy] #se agrega la animacion
enemy_object.childs += [scaled_collision] #se agrega la hitbox
enemy_object.childs[1].parent = enemy_object # se agrega la referencia de padre al objeto CollisionShape
# se le agrega la animacion de su bala correspondiente
enemy_object.bullet_animations = bullet2_animation
enemy_counter += 1
# se agrega el objeto enemy a la coleccion de enemigos
enemies_collection.childs += [enemy_object]
def setupPlayer(image, main_node):
#Se crean los distintos frames para cada animacion, recortando la imagen
ship_frames1 = anim.createFrames(image, [128, 128], [0, 0], [2], [0, 0]) #animacion para avanzar
ship_frames2 = anim.createFrames(image, [128, 128], [0, 0], [2], [0, 1]) #animacion para retroceder
hurt_frames = anim.createFrames(image, [128, 128], [0, 0], [2], [2, 2]) # animacion cuando le llega una bala
explode_frames = anim.createFrames(image, [128, 128], [0, 0], [2, 5], [2, 0]) # animacion de explosion
#se crea un diccionario con las animaciones
ship_animations = {}
ship_animations["fast"] = anim.Animation(ship_frames1, 12, True, False)
ship_animations["slow"] = anim.Animation(ship_frames2, 12, True, False)
ship_animations["hurt"] = anim.Animation(hurt_frames, 12, True, False)
ship_animations["explode"] = anim.Animation(explode_frames, 9, False, False)
#se crea el controlador de animaciones y se inicializa
ship_Anim = anim.Anim_Controller(ship_animations, [PLAYER_SIZE, WIDTH / HEIGHT * PLAYER_SIZE, 1], 0)
ship_Anim.Play("slow")
#se crea un nodo que contiene la animacion
anim_node = sg.SceneGraphNode("anim_player")
anim_node.childs += [ship_Anim]
# se crea un nodo con una gpuShape que servira para detectar las colisiones y verlas si se quiere
collision_node = sg.SceneGraphNode("collision_player")
collision_node.childs += [es.toGPUShape(cl.createCircleHitbox(PLAYER_HITBOX_RADIO, 10, 0, 1, 0))]
# se crea uno nodo/objeto CollisionShape que tiene informacion y metodos para detectar colisiones con respecto de una gpuShape
scaled_collision = cl.CollisionShape("scaled_collision", PLAYER_HITBOX_RADIO, True)
# se escala la hitbox para que tenga el mismo tamaño que la textura
scaled_collision.transform = tr.scale(1, 1 * WIDTH/HEIGHT, 1)
scaled_collision.childs += [collision_node]
# se crea el objeto player que contendra como nodos hijos a la animacion y la hitbox
player_gameObject = playerObject("player")
# se traslada la nave en la pantalla a su posicion inicial
player_gameObject.transform = tr.translate(0, -0.5, 0)
player_gameObject.position[0] = 0
player_gameObject.position[1] = -0.5
player_gameObject.position[2] = 0
player_gameObject.childs += [anim_node] #se agrega la animacion
player_gameObject.childs += [scaled_collision] #se agrega la hitbox
player_gameObject.childs[1].parent = player_gameObject # se agrega la referencia de padre al objeto CollisionShape
#agrega el objeto player a la escena principal
main_node.childs += [player_gameObject]
#retorna la referencia al objeto player
return go.findNode(main_node, "player")
def addEnemies0(enemies_collection, amount):
global enemy_counter
#se distribuyen los enemigos en la pantalla segun su cantidad
for enemy in range(amount):
# se crea el controlador de animaciones y se inicializa
enemy_anim = anim.Anim_Controller(enemy0_animations, [ENEMY0_SIZE, ENEMY0_SIZE * WIDTH/HEIGHT, 1], 0)
enemy_anim.Play("flying")
#se define su posicion horizontal
temp_posX = -1 + 1/amount -0.05 + enemy*(2/amount)
# se crea un nodo que contiene la animacion y que la voltea
scaled_enemy = sg.SceneGraphNode("scaled_enemy")
scaled_enemy.transform = tr.rotationZ(np.pi)
scaled_enemy.childs += [enemy_anim]
# se crea un nodo con una gpuShape que servira para detectar las colisiones y verlas si se quiere
collision_node = sg.SceneGraphNode("collision_enemy0")
collision_node.transform = tr.scale(1, 1* WIDTH / HEIGHT, 1)
collision_node.childs += [es.toGPUShape(cl.createCircleHitbox(ENEMY0_HITBOX_RADIO, 10, 0, 1, 0))]
# se crea uno nodo/objeto CollisionShape que tiene informacion y metodos para detectar colisiones con respecto de una gpuShape
scaled_collision = cl.CollisionShape("scaled_collision", ENEMY0_HITBOX_RADIO, True)
scaled_collision.transform = tr.rotationZ(np.pi)
scaled_collision.childs += [collision_node]
# se crea el objeto enemy que contendra como nodos hijos a la animacion y la hitbox
enemy_object = enemyObject("enemy" + str(enemy_counter))
enemy_object.enemy = 0 # es el primer tipo de enmigos
# se traslada la nave en la pantalla a su posicion inicial
enemy_object.transform = tr.translate(temp_posX, ENEMY0_SPAWN_POSY, 0)
enemy_object.position[0] = temp_posX
enemy_object.position[1] = ENEMY0_SPAWN_POSY
enemy_object.position[2] = 0
#se indica su velocidad
enemy_object.velocity = [0, ENEMY0_SPAWN_SPEED, 0]
enemy_object.childs += [scaled_enemy] #se agrega la animacion
enemy_object.childs += [scaled_collision] #se agrega la hitbox
enemy_object.childs[1].parent = enemy_object # se agrega la referencia de padre al objeto CollisionShape
#se le agrega la animacion de su bala correspondiente
enemy_object.bullet_animations = bullet0_animation
enemy_counter += 1
#se agrega el objeto enemy a la collecion de enemigos
enemies_collection.childs += [enemy_object]
def addStars(stars_coll):
posY = 0
#posicion horizontal del paquete depende de los anteriores
if len(stars_coll.childs) == 0:
posY = -1
else:
posY = stars_coll.childs[-1].position[1] + STAR_POSY
#se crea un gameObject que vendria siendo el paquete de estrellas y se posiciona
start_node = gameObject("star_node")
start_node.transform = tr.translate(0, posY, 0)
start_node.position[1] = posY
#cantidad random de estrellas que contendra el paquete
amountInX = random.randint(STARS_IN_X_MIN, STARS_IN_X_MAX)
for x in range(amountInX):
#por cada estrella del paquete se crea una animController con una estrella random, tamaño random y se inicializa
anim0 = anim.Animation(stars_images[random.randint(0, 15)],
random.randint(STAR_MIN_FPS, STAR_MAX_FPS),
True, False)
scale = STAR_MIN_SIZE + random.random() * (STAR_MAX_SIZE -
STAR_MIN_SIZE)
anim_Ctl = anim.Anim_Controller({"star": anim0},
[scale, scale * WIDTH / HEIGHT, scale],
0)
anim_Ctl.Play("star")
#posicion horizontal random
startPosX = -1 + (2 / amountInX) * x + random.random() * (2 /
amountInX)
#posicion vertical variando un poco con respecto a la del paquete
startPosY = (-1 + random.random() * 2) * STAR_DELTA_POSY
#se crea el gameobject de cada estrella con su animacion
star_object = gameObject("star")
star_object.transform = tr.translate(startPosX, startPosY, 0)
star_object.position = np.array([startPosX, startPosY, 0])
star_object.childs += [anim_Ctl]
#se agrega cada estrella al paquete
start_node.childs += [star_object]
#se agrega el paquete a la coleccion de estrellas
stars_coll.childs += [start_node]