def make_enemies_shoot(self):
# TODO frequence shot en fonction du lvl
if (time.get_ticks() - self.timer) > 700:
enemy = self.enemies.random_shooter(self.player.placement)
if enemy:
# TODO add second shot en fonction du lvl
self.enemyBullets.add(
Bullet(enemy.rect.x + 14, enemy.rect.y + 20, 1, 5,
'enemylaser', 'center', self,
self.player.placement))
self.allSprites.add(self.enemyBullets)
self.timer = time.get_ticks()
if self.mobs_shape == 'EXPLODED':
self.enemyBullets.add(
Bullet(enemy.rect.x + 14, enemy.rect.y + 20, 1, 5,
'enemylaser', 'center', self, 'BOTTOM'))
self.allSprites.add(self.enemyBullets)
self.timer = time.get_ticks()
self.enemyBullets.add(
Bullet(enemy.rect.x + 14, enemy.rect.y + 20, 1, 5,
'enemylaser', 'center', self, 'LEFT_SIDE'))
self.allSprites.add(self.enemyBullets)
self.timer = time.get_ticks()
self.enemyBullets.add(
Bullet(enemy.rect.x + 14, enemy.rect.y + 20, 1, 5,
'enemylaser', 'center', self, 'RIGHT_SIDE'))
self.allSprites.add(self.enemyBullets)
self.timer = time.get_ticks()
def arc_func(spawner, parameters):
"""pattern_name = arc ------- Standard parameters, plus:
angle_start
angle_end
angle_interval
"""
bullets = []
bullet_definition = BULLET_TYPE[parameters["bullet_type"]]
bullet_image = pygame.image.load("../../graphics/{}".format(bullet_definition["image"]))
bullet_dimensions = bullet_definition.get("dimensions")
bullet_hitbox = bullet_definition.get("hitbox",(1,1))
angle_start = parameters.get("angle_start",0)
angle_end = parameters.get("angle_end",180)
angle_interval = parameters.get("angle_interval",15)
speed = parameters.get("bullet_speed",3.5)
target = parameters.get("target","absolute")
position = spawner.get_position(parameters.get("spawn_from","midbottom"))
n_angles = ((angle_end - angle_start) / angle_interval) + 1
frame_angle = get_frame_angle(target,spawner.mediator,position,spawner)
for n in range(n_angles):
angle = (angle_start + (n * angle_interval) + frame_angle)
delay = parameters.get("delay",2) * n
rads = math.radians(angle)
bullet = Bullet(spawner.mediator,(speed*math.sin(rads),speed*math.cos(rads)),bullet_image,position,bullet_dimensions,bullet_hitbox,parameters.get("actions",{}))
bullet.set_parent(spawner)
bullet.set_tick_delay(delay)
bullets.append(bullet)
return bullets
def shoot2():
sound_pew.play()
bullet = Bullet(player.rect.centerx, player.rect.centery)
bullets.add(bullet)
all_sprites.add(bullet)
bullet2 = Bullet(player.rect.centerx + 20, player.rect.centery)
all_sprites.add(bullet2)
def listener(self, packet):
self.clientSocket.clientLock()
if isinstance(packet, Packets.RequestGameStatePacket):
w, h = self.getGame().getSize()
self.player = Player(
self.getGame(), [w/2, h/2], Color(255, 255, 255)
)
self.player.setPlayerName(self.username)
self.bullets = {}
self.bonuses = {}
self.players = {}
elif isinstance(packet, Packets.PlayerInfoPacket):
if packet.isMe():
self.player.setHealth(packet.getHealth())
self.player.setDeath(packet.getDeath())
self.player.setRespawnTime(packet.getRespawnTime())
else:
if packet.getPlayerId() not in self.players:
player = Player(self.getGame())
player.setPlayerName(packet.getPlayerName())
self.players[packet.getPlayerId()] = player
else:
player = self.players[packet.getPlayerId()]
player.setDelegate(lambda p, k: self.playerDelegate(p, k))
player.setPosition(packet.getPosition())
player.setVelocity(packet.getVelocity())
player.setAngle(packet.getAngle())
player.setHealth(packet.getHealth())
player.setDeath(packet.getDeath())
player.resetTimeout()
elif isinstance(packet, Packets.BulletInfoPacket):
if packet.getBulletId() not in self.bullets:
bullet = Bullet()
self.bullets[packet.getBulletId()] = bullet
else:
bullet = self.bullets[packet.getBulletId()]
bullet.setPosition(packet.getPosition())
bullet.setVelocity(packet.getVelocity())
bullet.resetTimeout()
if not packet.isAlive():
bullet.kill()
elif isinstance(packet, Packets.BonusInfoPacket):
if packet.getBonusId() not in self.bonuses:
bonus = Bonus()
self.bonuses[packet.getBonusId()] = bonus
else:
bonus = self.bonuses[packet.getBonusId()]
bonus.setPosition(packet.getPosition())
bonus.resetTimeout()
if not packet.isAlive():
bonus.kill()
elif isinstance(packet, Packets.PlayerGunPacket):
self.player.getGun().setReload(packet.isReloading())
self.player.getGun().setBulletInMagazine(
packet.getBulletInMagazine()
)
self.player.getGun().setTotalBullet(packet.getTotalBullet())
elif packet is not None:
print("Packet received (type " + str(packet) + ")")
self.clientSocket.clientUnlock()
def shoot(self):
now = pygame.time.get_ticks()
if now - self.last_shot > self.shoot_delay:
self.last_shot = now
#单火力
if self.power == 1:
bullet = Bullet(self.rect.centerx, self.rect.top)
all_sprites.add(bullet)
bullets.add(bullet)
shooting_sound.play()
#双火力
if self.power == 2:
bullet1 = Bullet(self.rect.left, self.rect.centery)
bullet2 = Bullet(self.rect.right, self.rect.centery)
all_sprites.add(bullet1)
all_sprites.add(bullet2)
bullets.add(bullet1)
bullets.add(bullet2)
shooting_sound.play()
#三火力
if self.power >= 3:
bullet1 = Bullet(self.rect.left, self.rect.centery)
bullet2 = Bullet(self.rect.right, self.rect.centery)
missile1 = Missile(self.rect.centerx, self.rect.top) # 导弹
all_sprites.add(bullet1)
all_sprites.add(bullet2)
all_sprites.add(missile1)
bullets.add(bullet1)
bullets.add(bullet2)
bullets.add(missile1)
shooting_sound.play()
missile_sound.play()
def gameLogic():
global score, GameOver
# create black screen
screen.fill((0, 0, 0))
screen.blit(background_img, (0, 0))
Inputs()
Player.Update(screen, player_img)
Enemy.Update(screen, enemy_img)
Bullet.Update(screen, bullet_img)
for i in range(num_of_enemy):
for j in range(Bullet.MaxSize):
on_EnemyCollision = Collision(Bullet.bullet_x[j],
Bullet.bullet_y[j], Enemy.enemy_x[i],
Enemy.enemy_y[i])
if (on_EnemyCollision):
collided_Enemy = i
explosion_Sound.play()
Bullet.Reset(j)
score += 100
Enemy.Reset(collided_Enemy)
on_collisionWithPlayer = Collision(Player.pos_X, Player.pos_Y,
Enemy.enemy_x[i], Enemy.enemy_y[i])
if (on_collisionWithPlayer):
GameOver = True
explosion_Sound.play()
def __init__(self, screen_temp):
Plane.__init__(self, screen_temp, 'myplane-1')
self.x = 0
self.speed = 5
self.y = 200
self.Herobullet = Bullet(screen_temp, self.x, self.y)
self.bullet_list = [Bullet(self.screen, self.x, self.y)] * 10
class UserTank():
def __init__(self):
self.x_pos = 200
self.y_pos = 400
self.x_change = 0
self.y_change = 0
self.img = pygame.image.load("transportation.png")
self.bullet = Bullet()
self.fired = False
self.score = 0
self.bullet.tank = "User Tank"
self.health = 200
def move_left(self):
self.x_change = -5
def move_right(self):
self.x_change = 5
def move_up(self):
self.y_change = -5
def move_down(self):
self.y_change = 5
def reset_change(self):
self.x_change = 0
self.y_change = 0
def update_location(self):
self.x_pos += self.x_change
self.y_pos += self.y_change
if self.x_pos <= 0:
self.x_pos = 0
elif self.x_pos >= 790:
self.x_pos = 790
if self.y_pos <= 0:
self.y_pos = 0
elif self.y_pos >= 580:
self.y_pos = 580
def shoot(self, x, y):
self.bullet.x_pos = self.x_pos
self.bullet.y_pos = self.y_pos
self.fired = True
self.bullet.shoot(x, y)
if self.bullet.fired == False:
self.fired = False
def hit_enemy(self):
self.score += 1
def get_shot(self):
self.health -= 50
def replenish_health(self):
self.health = 200
def shot(self,player,b_list):
if(self.delay>0):
self.delay -= 1
elif(self.check) :
x = self.get_x()
y = self.get_y()
b_list.append(Bullet(x,y,x,y+200,5,1))
b_list.append(Bullet(x,y,x,y-200,5,1))
self.delay = 3
def __init__(self):
self.x_pos = 200
self.y_pos = 400
self.x_change = 0
self.y_change = 0
self.img = pygame.image.load("transportation.png")
self.bullet = Bullet()
self.fired = False
self.score = 0
self.bullet.tank = "User Tank"
self.health = 200
def __init__(self):
x_positions = [0, 800]
y_positions = [0, 600]
self.x_pos = x_positions[random.randint(0, 1)]
self.y_pos = y_positions[random.randint(0, 1)]
self.x_change = 0
self.y_change = 0
self.img = pygame.image.load("enemy.png")
self.bullet = Bullet()
self.fired = False
self.health = 100
self.bullet.tank = "Enemy"
class TestBoss(ut.TestCase): def setUp(self): self.Bullet=Bullet(0, 0, 50, 0, 2, 2, 2) def testMove(self): self.Bullet.move() self.assertEqual(self.Bullet.x, 0) self.assertEqual(self.Bullet.y, 2) def testReset(self): self.Bullet.reset(2, 3) self.assertEqual(self.Bullet.x, 2) self.assertEqual(self.Bullet.y, 3)
def shot(self,player,b_list):
self.change_delay -= 1
if(self.delay>0):
self.delay -= 1
else:
b_list.append(Bullet(self.s_x,self.s_y,self.p_x,self.p_y,4,1))
b_list.append(Bullet(self.s_x,self.s_y,self.o_x,self.o_y,3,1))
self.eyes_change()
if(self.change_delay <= 0):
self.change_delay = random.randrange(101,151)
self.speeds = random.randrange(5,8)
def handleAttack(self, player):
self.fireDelay = 50
if(self.delay >= self.fireDelay):
if(self.attackFlag != moveDirection.ATTACK):
newBullet = Bullet("Bullets.gif", self.upperLeft.x + (self.get_width() / 2), self.upperLeft.y + (self.get_height() / 2), 30, 30, 3, 3, player)
newBullet.play(True)
newBullet.scale_sprite(3)
self.gun.addBullet(newBullet)
self.attackFlag = moveDirection.ATTACK
else:
self.attackFlag = moveDirection.NULL
self.delay = 0
else:
self.delay += random.randint(2, 5)
def updateEvents(self):
#movement
if self.event1 == True:
#update accurate position
self.x_acc += self.xspeed
self.y_acc += self.yspeed
#update real position
self.rect.x = self.x_acc
self.rect.y = self.y_acc
#update speed
self.xspeed += self.xaccel
self.yspeed += self.yaccel
#destroy if leaves window
if (self.rect.left > WINDOWWIDTH or self.rect.right < 0
or self.rect.bottom < 0 or self.rect.top > WINDOWHEIGHT):
self.kill()
#flame size
if self.event2 == True:
#decrease size
self.changeSize(self.rect.w + self.waccel,
self.rect.h + self.haccel)
#split into 2 halves if size is half IFF size is not 0
wlimit = self.origSize[0] / 1.1
hlimit = self.origSize[1] / 1.1
if self.rect.w <= 6 or self.rect.h <= 6:
self.kill()
rnd = random.randint(0, 300)
if rnd == 1:
crnd = random.randint(0, 200)
srnd = random.randint(2, 5)
smoke = Bullet((crnd, crnd, crnd), srnd, srnd)
smoke.load(self, self.bullets)
smoke.aim(self.dir, self.margin)
smoke.fire(1)
smoke.yaccel = 0
elif self.rect.w <= wlimit and self.rect.h <= hlimit:
#prepare some variables
speed = int(math.sqrt((self.xspeed**2) + (self.yspeed**2)))
color = self.incrementColor()
self.margin += 15
#make 2 more flames
flame = Flame(color, wlimit, hlimit)
flame.load(self, self.bullets)
flame.aim(70, self.margin)
flame.throw(speed, self.xaccel, self.yaccel, self.waccel,
self.haccel) #--1
flame = Flame(color, wlimit, hlimit)
flame.load(self, self.bullets)
flame.aim(110, self.margin)
flame.throw(speed, self.xaccel, self.yaccel, self.waccel,
self.haccel) #--2
def Make_Laser(self):
if gfw.world.count_at(gfw.layer.Laser) > 0:
self.laserTime += gfw.delta_time * 2
if win32api.GetAsyncKeyState(0x41) & 0x1001:
if gfw.world.count_at(gfw.layer.Laser) == 0 and self.Gage > 20:
LayL = Bullet.Player_Laser(13)
gfw.world.add(gfw.layer.Laser, LayL)
LayR = Bullet.Player_Laser(-25)
gfw.world.add(gfw.layer.Laser, LayR)
elif self.laserTime > 3 and gfw.world.count_at(
gfw.layer.Laser) > 0:
self.laserTime = 0
for Laser in gfw.world.objects_at(gfw.layer.Laser):
Laser.isDead = True
def gunFired(self):
#add new bullet in bullet list.
py.mixer.Sound.play(fire_sound)
self.bullets.append(
b.Bullet(gameDisplay,
self.gun.pipeXCo + (self.gun.pipeWidth) / 2 - 2.5,
self.gun.pipeYCo, 5, up.Colors.red, 4))
def createBulletIfInRange(self, onBalloons):
#find balloon with max dist traveled that's also in range
furthestBalloon = None
for balloon in onBalloons:
if isinstance(
balloon,
Balloon.DisappearingBalloon) and not balloon.isVisible:
continue
bx = balloon.position[0]
by = balloon.position[1]
tx = self.location[0]
ty = self.location[1]
distance = getDistance(tx, ty, bx, by)
if distance < Tower.towerRange:
if (furthestBalloon == None):
furthestBalloon = balloon
elif (balloon.distanceTraveled >
furthestBalloon.distanceTraveled):
furthestBalloon = balloon #never gets to here
#possible that furthestBalloon is still none
if furthestBalloon != None:
deltaX = furthestBalloon.position[0] - self.location[0]
deltaY = furthestBalloon.position[1] - self.location[1]
scaleFactor = (deltaX**2 + deltaY**2)**.5
dx = deltaX / scaleFactor
dy = deltaY / scaleFactor
return [Bullet.Bullet(self.location, dx, dy)]
#return bullet with location of tower and dx dy according to balloon it's shooting at
return []
def createBullet(self, bulletType, life, delayT, alpha, addSpeed):
#Position
bulletpos = QVector2D(self.position.x(), self.position.y())
#velocity
speed = Bullet.Bullet_Speed + addSpeed
#velocity based on angle
GesX = math.cos(math.radians(alpha)) * speed
GesY = -math.sin(math.radians(alpha)) * speed
#set Bullet to middle of Robot
OffsetVector = QVector2D((self.radius + Bullet.Bullet_Size) / 2,
(self.radius + Bullet.Bullet_Size) / 2)
bulletpos.__iadd__(OffsetVector)
#set bullet to edge in firing direction
OffsetX = math.cos(math.radians(alpha)) * (self.radius + 6)
OffsetY = -math.sin(math.radians(alpha)) * (self.radius + 6)
OffsetVector = QVector2D(OffsetX, OffsetY)
bulletpos.__iadd__(OffsetVector)
#set Bullet Speed
Vel = QVector2D(GesX, GesY)
Vel.__iadd__(self.v_vector)
#create Bullet
Bullet1 = Bullet.Bullet(bulletpos, Vel, speed, alpha, life, delayT,
bulletType)
return Bullet1
def shoot(self, accel, list1, list2):
"""spawning your bullets"""
bullet = Bullet.Bullet(self.pos.x, self.pos.y, accel)
bullet_sound.set_volume(0.1)
bullet_sound.play()
list1.add(bullet) #and adding them to the list
list2.add(bullet)
def handle_events(self, event) -> None:
if event.type == pygame.KEYDOWN: # shooting
if event.key == pygame.K_SPACE:
bullet_object = Bullet.Bullet(
self.game_engine.assets.get("bullet"), self.spaceship)
bullet_object.shoot_sound()
self.bullets.append(bullet_object)
if event.type == self.ALIEN_HIT:
for alien in self.destroyed_aliens:
alien.explode()
if event.type == self.REMOVE_ALIEN:
for alien in self.destroyed_aliens:
if self.destroyed_aliens.__contains__(alien):
self.destroyed_aliens.remove(alien)
if self.aliens.__contains__(alien):
self.aliens.remove(alien)
if event.type == self.SPACESHIP_HIT:
self.spaceship.health -= 1
self.heart_containers[
self.spaceship.health] = pygame.transform.scale(
self.game_engine.assets.get("empty_heart"), (36, 36))
if self.spaceship.health == 0:
pygame.event.post(
pygame.event.Event(
self.game_engine.state_events.get("GAME_OVER"))
) # this event is registered in the main loop of GameEngine
return
def shoot(self, player, b_list):
s_x = self.get_x() + 20
s_y = self.get_y() + 20
arr = [[s_x+500,s_y],[s_x-500,s_y],[s_x,s_y+500],[s_x,s_y-500],
[s_x+500,s_y+500],[s_x-500,s_y+500],[s_x+500,s_y-500],[s_x-500,s_y-500]]
for i in arr :
b_list.append(Bullet(s_x+20,s_y+20,i[0],i[1],8,1))
def handleEvents(elapsed):
ev = SDL_Event()
while 1:
if not SDL_PollEvent(byref(ev)):
break
if ev.type == SDL_QUIT:
SDL_Quit()
sys.exit(0)
elif ev.type == SDL_KEYDOWN:
k = ev.key.keysym.sym
globs.keyset.add(k)
if k == SDLK_q:
SDL_Quit()
sys.exit(0)
elif ev.type == SDL_KEYUP:
k = ev.key.keysym.sym
globs.keyset.discard(k)
#if the spacebar has just been released, spawn
#a bullet
if k == SDLK_SPACE:
Mix_PlayChannel(-1, globs.pewSound, 0)
globs.bullets.append(
Bullet(
vec3(globs.player.pos.x, globs.player.pos.y,
globs.player.pos.z)))
elif ev.type == SDL_MOUSEBUTTONDOWN:
print("mouse down:", ev.button.button, ev.button.x, ev.button.y)
elif ev.type == SDL_MOUSEBUTTONUP:
print("mouse up:", ev.button.button, ev.button.x, ev.button.y)
elif ev.type == SDL_MOUSEMOTION:
pass
def run(self):
while True:
time.sleep(0.07)
data = self.mySocket.recv(1024)
try:
data = pickle.loads(data)
except:
print("pickle sie wysral")
data = None
continue
for towers in data:
if isinstance(towers, Tower.Tower) or isinstance(
towers, Bot.Bot):
if towers.position != self.game.player.position:
for bots in self.game.botList.sprites():
if bots.position == towers.position:
bots.setX(towers.rect.x)
bots.setY(towers.rect.y)
else:
for bullets in data:
for bots in self.game.botList:
if bullets.position == bots.position:
newBullet = Bullet.Bullet(
bullets.dx, bullets.dy, bullets.position)
self.game.sbulletList.add(newBullet)
bots.hasBullet = True
#self.game.shouldSend = True
for bullets2 in self.game.sbulletList:
bullets.load_image(bullets)
if bullets.position == bullets2.position:
bullets2.setX(bullets.rect.x)
bullets2.setY(bullets.rect.y)
def update(self, dt):
if (self.dead == False):
self.player.move()
self.frameCount += 1
# Makes turret face the player
startX = self.turret.x
startY = self.turret.y
tarX = self.player.x
tarY = self.player.y
diffX = tarX - startX
diffY = tarY - startY
angle = math.atan2(diffY, diffX)
self.turret.angle = math.degrees(angle)
if self.frameCount % 20 == 0:
self.bullet = Bullet.Bullet(startX, startY, self.turret.angle)
self.bullet.deltaX = math.cos(angle) * bulletSpeed
self.bullet.deltaY = math.sin(angle) * bulletSpeed
self.bulletList.append(self.bullet)
if (self.player.x < (self.token.x + 25) and self.player.x >
(self.token.x - 25) and self.player.y < (self.token.y + 25)
and self.player.y > (self.token.y - 25)):
self.token.resPos()
self.score += 1
if (self.player.health <= 0):
self.dead = True
def GenData():
Character.GenCharaterData()
PlayerState.GenStateList()
Action.GenAction()
DrawManager.GenGraphicList()
Bullet.GenBulletData()
SoundManager.GenData()
def update(self, *args):
if 0 <= self.rect.x <= 1300 and self.timeToShoot % 60 == 0:
Bullet.Bullet(self.bullets, self.rect.x, self.rect.y, self.direct,
self.blocks, self.all_sprites, self.player)
self.timeToShoot += 1
if self.direct == 0 and self.rect.x <= 1300:
pass
self.rect.x += self.type[self.direct] * 25
self.rect.y += 5
block = pygame.sprite.spritecollide(self, self.blocks, False)
if len(block) == 0:
self.rect.y -= 5
self.rect.x -= self.type[self.direct] * 25
if self.direct == 0:
self.image = pygame.image.load("sprites/monster1_2.png")
else:
self.image = pygame.image.load("sprites/monster1_1.png")
self.direct = abs(self.direct - 1)
else:
self.rect.y -= 5
self.rect.x -= self.type[self.direct] * 25
self.rect.x += self.type[self.direct]
block = pygame.sprite.spritecollide(self, self.blocks, False)
if len(block) != 0:
if self.direct == 0:
self.image = pygame.image.load("sprites/monster1_2.png")
else:
self.image = pygame.image.load("sprites/monster1_1.png")
self.direct = abs(self.direct - 1)
monster = pygame.sprite.spritecollide(self, self.hero_bullets, False)
if len(monster) > 0:
self.group.remove(self)
for i in monster:
self.hero_bullets.remove(i)
def update_keypressed(self, event, tilemap):
#################################
if self.canMove:
if event.key == pygame.K_a:
self.animationState = "walking_left"
self.deltax = -self.velocity
self.dir = 1
#################################
elif event.key == pygame.K_d:
self.animationState = "walking_right"
self.deltax = self.velocity
self.dir = 2
#################################
elif event.key == pygame.K_w:
#self.animationState = "walking_left"
self.deltay = -self.velocity
self.dir = 3
#################################
elif event.key == pygame.K_s:
#self.animationState = "walking_right"
self.deltay = self.velocity
self.dir = 0
#################################
elif event.key == pygame.K_SPACE:
if(self.gui.inventory.currentItem.name == "simple_pistol"):
if(self.gui.inventory.pistol.currentAmmo >= 0):
#print("you shot")
#print(self.gui.inventory.pistol.currentAmmo)
self.gui.inventory.pistol.currentAmmo -= 1
bullet = Bullet(self.rect.x, self.rect.y, 16, 16, 10, self.dir)
bullet_sprite.add(bullet)
else:
print("you have no ammo")
def run(self):
while True:
time.sleep(0.05)
#data2 = clients.recv(8192)
data = self.clientList[0].recv(1024)
data = pickle.loads(data)
for towers in data:
if isinstance(towers, Tower.Tower) or isinstance(
towers, Bot.Bot):
if towers.position != self.game.player.position:
for bots in self.game.botList.sprites():
if bots.position == towers.position:
bots.setX(towers.rect.x)
bots.setY(towers.rect.y)
else:
for bullets in data:
if isinstance(bullets, Bullet.Bullet):
for bots in self.game.botList:
if bullets.position == bots.position:
newBullet = Bullet.Bullet(
bullets.dx, bullets.dy,
bullets.position)
self.game.sbulletList.add(newBullet)
bots.hasBullet = True
self.game.shouldSend = True
for bullets2 in self.game.sbulletList:
bullets.load_image(bullets)
if bullets.position == bullets2.position:
bullets2.setX(bullets.rect.x)
bullets2.setY(bullets.rect.y)
def update(self, evt):
#self.camera.setPos(0,-100,100)
lifes = self.player.getPythonTag("ObjectController").getLifes()
if (lifes > 2):
self.lifes[0].show()
self.lifes[1].show()
elif (lifes > 1):
self.lifes[0].show()
self.lifes[1].hide()
elif (lifes > 0):
self.lifes[0].hide()
self.lifes[1].hide()
self.camera.lookAt(self.player)
self.rails.setPos(self.scene, Path.getXOfY(self.rails_y), self.rails_y,
12.4)
self.rails.setHpr(Path.getHeading(self.rails_y), 0, 0)
self.dirLight.color = (self.rails_y / 600, 0.7, 1, 1)
self.camera.setHpr(Path.getHeading(self.rails_y), 0, 0)
if (self.onGame):
self.rails_y = self.rails_y + globalClock.getDt() * 10
#self.player.setPos(self.rails, 0, 0, sin(self.z/10.0)*40 )
relX, relZ, isShooting = self.player.getPythonTag(
"ObjectController").update(self.rails, globalClock.getDt())
self.camera.setPos(self.rails, relX, -30, relZ)
if (isShooting):
self.fireSound.play()
b = Bullet(
self.bullet, self.scene, self.player.getPos(self.scene),
base.cTrav, self.CollisionHandlerEvent,
self.scene.getRelativeVector(self.player,
Vec3(0, 1, 0)), 40, 0x4)
enemies = self.scene.findAllMatches("dynamicEnemy")
for e in enemies:
enemy = e.getPythonTag("ObjectController")
enemy.update(self.scene, globalClock.getDt(), self.player,
self.bullet)
bullets = self.scene.findAllMatches("bulletC")
for b in bullets:
bullet = b.getPythonTag("ObjectController")
bullet.update(self.scene, globalClock.getDt(), self.player)
return Task.cont
def main():
pygame.font.init()
pygame.init()
screen = pygame.display.set_mode((1000, 700))
pygame.display.set_caption('Spaceships')
img = pygame.image.load("images\Background.jpg")
BackGround = pygame.transform.scale(img, (1000, 700))
backdropbox = BackGround.get_rect()
Player1 = Player()
score = 0
# enemy = Enemy("images\enemy.png")
pygame.display.flip()
screen.blit(BackGround, backdropbox)
clock = pygame.time.Clock()
all_sprites = pygame.sprite.Group()
bullets_group = pygame.sprite.Group()
mobs_group = pygame.sprite.Group()
all_sprites.add(Player1)
start = pygame.time.get_ticks()
now = pygame.time.get_ticks()
hits = pygame.sprite.groupcollide(mobs_group, bullets_group, True, True)
while True:
hits = pygame.sprite.groupcollide(mobs_group, bullets_group, True,
True)
for hit in hits.items():
score += 1
now = pygame.time.get_ticks()
screen.blit(BackGround, backdropbox)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit(0)
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
if bullets_group.__len__() < 1:
bullet = Bullet("images\Bullet.png", Player1.rect.x,
Player1.rect.y, bullets_group)
if now - start > 1000:
start = now
mob = Enemy("images\enemy.png", all_sprites)
mobs_group.add(mob)
all_sprites.update()
bullets_group.update()
bullets_group.draw(screen)
all_sprites.draw(screen)
text(screen, score)
Player1.show_lifes(screen)
# screen.blit(Player1.image, (Player1.rectx, Player1.recty))
pygame.display.flip()
clock.tick(60)
def getBullet(self, position, angle, minimumDistance):
# speed = 500
# position = [
# px+math.sin(angle)*minimumDistance,
# py+math.cos(angle)*minimumDistance
# ]
# velocity = [math.sin(angle)*speed, math.cos(angle)*speed]
return Bullet(position, angle, minimumDistance)
def updateEvents(self):
#movement
if self.event1 == True:
#update accurate position
self.x_acc += self.xspeed
self.y_acc += self.yspeed
#update real position
self.rect.x = self.x_acc
self.rect.y = self.y_acc
#update speed
self.xspeed += self.xaccel
self.yspeed += self.yaccel
#destroy if leaves window
if(self.rect.left > WINDOWWIDTH or
self.rect.right < 0 or
self.rect.bottom < 0 or
self.rect.top > WINDOWHEIGHT):
self.kill()
#flame size
if self.event2 == True:
#decrease size
self.changeSize(self.rect.w + self.waccel, self.rect.h + self.haccel)
#split into 2 halves if size is half IFF size is not 0
wlimit = self.origSize[0]/1.1
hlimit = self.origSize[1]/1.1
if self.rect.w <= 6 or self.rect.h <= 6:
self.kill()
rnd = random.randint(0,300)
if rnd == 1:
crnd = random.randint(0,200)
srnd = random.randint(2,5)
smoke = Bullet( (crnd,crnd,crnd), srnd,srnd)
smoke.load(self, self.bullets)
smoke.aim(self.dir, self.margin)
smoke.fire(1)
smoke.yaccel = 0
elif self.rect.w <= wlimit and self.rect.h <= hlimit:
#prepare some variables
speed = int(math.sqrt( (self.xspeed**2) + (self.yspeed**2) ))
color = self.incrementColor()
self.margin += 15
#make 2 more flames
flame = Flame(color, wlimit, hlimit)
flame.load(self, self.bullets)
flame.aim(70, self.margin)
flame.throw(speed, self.xaccel, self.yaccel, self.waccel, self.haccel) #--1
flame = Flame(color, wlimit, hlimit)
flame.load(self, self.bullets)
flame.aim(110, self.margin)
flame.throw(speed, self.xaccel, self.yaccel, self.waccel, self.haccel) #--2
def smoke(self):
if self.smokeLevel > 0:
hue_rnd = random.randint(115,200)
size_rnd = random.randint(int(2*self.w_max/4),self.w_max-1)
#highest smoke level = 10000, lowest = 1
exist_rnd = random.randint(0,int(10000 / (self.smokeLevel+1) ))
color = ( hue_rnd, hue_rnd, hue_rnd )
if exist_rnd == 1:
smoke = Bullet(color, size_rnd, size_rnd)
smoke.load(self, self.group)
smoke.aim(90, 75)
smoke.fire(1)
images = {
'f': pygame.image.load(os.path.join("images", "fish.png")).convert_alpha(),
'm': pygame.image.load(os.path.join("images", "mountain.png")).convert_alpha(),
'a': pygame.image.load(os.path.join("images", "alien.png")).convert_alpha(),
'b': pygame.image.load(os.path.join("images", "bird.png")).convert_alpha(),
}
Fish.getstuff((images['f'], None), sfx_slap)
Mountain.getstuff((images['m'], None))#,sounds)
Alien.getstuff((images['a'], None))
Bird.getstuff((images['b'], None))
Player.getstuff((images['b'], None))
Bullet.getstuff((images['f'], None), sfx_slap)
player = Player.Player()
fish = Fish.Fish((0,0))
mountains = pygame.sprite.Group()
aliens = pygame.sprite.Group()
pools = pygame.sprite.Group()
birds = pygame.sprite.Group()
bullets = pygame.sprite.Group()
def newlevel(level):
fish.active = False
mountains.empty()
aliens.empty()
pools.empty()
class Bike(DirectObject):
def __init__(self, cTrav):
self.lights = True
self.cTrav = cTrav
#load the bike actor and parent it to a physics node
#self.physNode = NodePath("PhysicsNode")
#self.physNode.reparentTo(render)
#self.actNode = ActorNode("bike-phys")
#self.actNodePath = self.physNode.attachNewNode(self.actNode)
#base.physicsMgr.attachPhysicalNode(actNode)
#create empty list for bullets and a task for updating the positions
self.bulletList = []
self.bullet = Bullet(self.cTrav)
taskMgr.add(self.bullet.update, "bulletTask")
#load the bike actor and parent it to a physics node
#self.bike = Actor("temp_bike.egg", {"move":"bike-move", "shoot":"bike-shoot"})
#self.bike = Actor("motorcycle1.egg", {"move":"bike-move", "shoot":"bike-shoot"})
self.bike = Actor("moto1_actor1.egg", {"move":"moto1_moveAnimAtion.egg", "turnL":"moto1_moveLAnimation.egg", "turnR":"moto1_moveRAnimation.egg"})
self.bike.reparentTo(render)
self.bike.setScale(.5)
#self.bike.setH(self.bike.getH() - 3.1415/2)
#load the gun actors
"""
self.gun1 = Actor("temp_gun.egg", {"shoot":"gun-shoot"})
self.gun1.reparentTo(self.bike)
self.gun1.setPos(-.5, 0, .5)
self.gun1.setH(180)
self.gun2 = Actor("temp_gun.egg", {"shoot":"gun-shoot"})
self.gun2.reparentTo(self.bike)
self.gun2.setPos(.46, 0, 1)
self.gun2.setH(180)
self.gun2.setR(180)
"""
"""
#load the headlight models
self.headlight1 = loader.loadModel("temp_light.egg")
self.headlight1.reparentTo(self.bike)
self.headlight1.setPos(.3, .55, .4)
self.headlight1.setScale(.75)
#load the headlight models
self.headlight2 = loader.loadModel("temp_light.egg")
self.headlight2.reparentTo(self.bike)
self.headlight2.setPos(-.3, .55, .4)
self.headlight2.setScale(.75)
"""
#setup a move task for the bike
#taskMgr.add(self.move, "moveTask")
self.prevTime = 0
self.isMoving = False
#setup a shoot task for the bike
#taskMgr.add(self.shoot, "shootTask")
self.shotClock = 25
# for shooting anim self.isShooting = False
#setup a moving dictionary
#self.moveMap = {"left":0, "right":0, "forward":0}
###
#pusher collision spheres
#front
collisionPusher = CollisionHandlerPusher()
collisionPusher.setInPattern("e_bike-%in")
cPushSphere = CollisionSphere((0,3.5,2),2)
cNode1 = CollisionNode("e_bike_push")
cNode1.addSolid(cPushSphere)
#cNode1.setIntoCollideMask(0x1 + 0x2)
cNode1.setIntoCollideMask(0x10)
cNode1.setFromCollideMask(0x1 + 0x2)
self.cNodePath1 = self.bike.attachNewNode(cNode1)
#self.cNodePath1.show()
collisionPusher.addCollider(self.cNodePath1, self.bike)
self.cTrav.addCollider(self.cNodePath1, collisionPusher)
#middle
cPushSphere = CollisionSphere((0,0,2),2)
cNode2 = CollisionNode("e_bike_push")
cNode2.addSolid(cPushSphere)
cNode2.setIntoCollideMask(0x1 + 0x2)
cNode2.setFromCollideMask(0x0)
self.cNodePath2 = self.bike.attachNewNode(cNode2)
#self.cNodePath2.show()
collisionPusher.addCollider(self.cNodePath2, self.bike)
self.cTrav.addCollider(self.cNodePath2, collisionPusher)
#back
cPushSphere = CollisionSphere((0,-2.5,2),2)
cNode3 = CollisionNode("e_bike_push")
cNode3.addSolid(cPushSphere)
cNode3.setIntoCollideMask(0x1 + 0x2)
cNode3.setFromCollideMask(0x0)
self.cNodePath3 = self.bike.attachNewNode(cNode3)
#self.cNodePath3.show()
collisionPusher.addCollider(self.cNodePath3, self.bike)
self.cTrav.addCollider(self.cNodePath3, collisionPusher)
###
#cHandler = CollisionHandlerEvent()
#cHandler.setInPattern("e_bike-%in")
cSphere = CollisionSphere((0, 0, .75), 1)
cNode = CollisionNode("e_bike")
cNode.addSolid(cSphere)
#cNode.setIntoCollideMask(BitMask32.allOff())
cNode.setIntoCollideMask(BitMask32(0x10)) # Player bike collides into enemy bike
cNode.setFromCollideMask(BitMask32.allOff())
self.cNodePath = self.bike.attachNewNode(cNode)
#self.cNodePath.show()
#self.cTrav.addCollider(self.cNodePath, cHandler)
#setup the node as a pusher
pusher = CollisionHandlerPusher()
pusher.addCollider(self.cNodePath, self.bike)
#show the node
#self.cNodePath.show()
#add the collider to the traverser
base.cTrav.addCollider(self.cNodePath, pusher)
#setup and parent spotlights to the player
self.spotlight1 = Spotlight("headlight1")
self.spotlight1.setColor((1, 1, 1, 1))
lens = PerspectiveLens()
#can change size of cone
lens.setFov(20)
self.spotlight1.setLens(lens)
self.spotlight1.setExponent(100)
self.spotnode1 = self.bike.attachNewNode(self.spotlight1)
self.spotnode1.setH(180)
render.setLight(self.spotnode1)
"""
self.spotlight2 = Spotlight("headlight2")
self.spotlight2.setColor((1, 1, 1, 1))
self.spotlight2.setLens(lens)
self.spotlight2.setExponent(100)
self.spotnode2 = self.headlight2.attachNewNode(self.spotlight2)
render.setLight(self.spotnode2)"""
"""
def setDirection(self, key, value):
#set the direction as on or off
self.moveMap[key] = value
"""
def setShoot(self, value):
self.shootCheck = value
#print("set shoot =", self.shootCheck)
def shoot(self):
if self.shotClock >= 25:
#create a bullet
self.bullet.createBullet(self.gun1, self.bike)
self.shotClock = 0
else:
self.shotClock += 1
"""
def move(self, task):
elapsed = task.time - self.prevTime
#check key map
if self.moveMap['left']:
self.bike.setH(self.bike.getH() + elapsed * 100)
if self.moveMap['right']:
self.bike.setH(self.bike.getH() - elapsed * 100)
if self.moveMap['forward']:
dist = 8 * elapsed
angle = deg2Rad(self.bike.getH())
dx = dist * math.sin(angle)
dy = dist * -math.cos(angle)
self.bike.setPos(self.bike.getX() - dx, self.bike.getY() - dy, 0)
if self.moveMap['left'] or self.moveMap['right'] or self.moveMap['forward']:
if self.isMoving == False:
self.isMoving = True
#self.bike.loop("walk")
else:
if self.isMoving:
self.isMoving = False
self.bike.stop()
#self.bike.pose("walk", 4)
self.prevTime = task.time
return Task.cont
"""
def setupCollisions(self):
pass
def lightsToggle(self):
if self.lights:
self.lightsOff()
else:
self.lightsOn()
def lightsOff(self):
self.lights = False
render.clearLight(self.spotnode1)
def lightsOn(self):
self.lights = True
render.setLight(self.spotnode1)
def __init__(self, cTrav):
self.lights = True
self.cTrav = cTrav
#load the bike actor and parent it to a physics node
#self.physNode = NodePath("PhysicsNode")
#self.physNode.reparentTo(render)
#self.actNode = ActorNode("bike-phys")
#self.actNodePath = self.physNode.attachNewNode(self.actNode)
#base.physicsMgr.attachPhysicalNode(actNode)
#create empty list for bullets and a task for updating the positions
self.bulletList = []
self.bullet = Bullet(self.cTrav)
taskMgr.add(self.bullet.update, "bulletTask")
#load the bike actor and parent it to a physics node
#self.bike = Actor("temp_bike.egg", {"move":"bike-move", "shoot":"bike-shoot"})
#self.bike = Actor("motorcycle1.egg", {"move":"bike-move", "shoot":"bike-shoot"})
self.bike = Actor("moto1_actor1.egg", {"move":"moto1_moveAnimAtion.egg", "turnL":"moto1_moveLAnimation.egg", "turnR":"moto1_moveRAnimation.egg"})
self.bike.reparentTo(render)
self.bike.setScale(.5)
#self.bike.setH(self.bike.getH() - 3.1415/2)
#load the gun actors
"""
self.gun1 = Actor("temp_gun.egg", {"shoot":"gun-shoot"})
self.gun1.reparentTo(self.bike)
self.gun1.setPos(-.5, 0, .5)
self.gun1.setH(180)
self.gun2 = Actor("temp_gun.egg", {"shoot":"gun-shoot"})
self.gun2.reparentTo(self.bike)
self.gun2.setPos(.46, 0, 1)
self.gun2.setH(180)
self.gun2.setR(180)
"""
"""
#load the headlight models
self.headlight1 = loader.loadModel("temp_light.egg")
self.headlight1.reparentTo(self.bike)
self.headlight1.setPos(.3, .55, .4)
self.headlight1.setScale(.75)
#load the headlight models
self.headlight2 = loader.loadModel("temp_light.egg")
self.headlight2.reparentTo(self.bike)
self.headlight2.setPos(-.3, .55, .4)
self.headlight2.setScale(.75)
"""
#setup a move task for the bike
#taskMgr.add(self.move, "moveTask")
self.prevTime = 0
self.isMoving = False
#setup a shoot task for the bike
#taskMgr.add(self.shoot, "shootTask")
self.shotClock = 25
# for shooting anim self.isShooting = False
#setup a moving dictionary
#self.moveMap = {"left":0, "right":0, "forward":0}
###
#pusher collision spheres
#front
collisionPusher = CollisionHandlerPusher()
collisionPusher.setInPattern("e_bike-%in")
cPushSphere = CollisionSphere((0,3.5,2),2)
cNode1 = CollisionNode("e_bike_push")
cNode1.addSolid(cPushSphere)
#cNode1.setIntoCollideMask(0x1 + 0x2)
cNode1.setIntoCollideMask(0x10)
cNode1.setFromCollideMask(0x1 + 0x2)
self.cNodePath1 = self.bike.attachNewNode(cNode1)
#self.cNodePath1.show()
collisionPusher.addCollider(self.cNodePath1, self.bike)
self.cTrav.addCollider(self.cNodePath1, collisionPusher)
#middle
cPushSphere = CollisionSphere((0,0,2),2)
cNode2 = CollisionNode("e_bike_push")
cNode2.addSolid(cPushSphere)
cNode2.setIntoCollideMask(0x1 + 0x2)
cNode2.setFromCollideMask(0x0)
self.cNodePath2 = self.bike.attachNewNode(cNode2)
#self.cNodePath2.show()
collisionPusher.addCollider(self.cNodePath2, self.bike)
self.cTrav.addCollider(self.cNodePath2, collisionPusher)
#back
cPushSphere = CollisionSphere((0,-2.5,2),2)
cNode3 = CollisionNode("e_bike_push")
cNode3.addSolid(cPushSphere)
cNode3.setIntoCollideMask(0x1 + 0x2)
cNode3.setFromCollideMask(0x0)
self.cNodePath3 = self.bike.attachNewNode(cNode3)
#self.cNodePath3.show()
collisionPusher.addCollider(self.cNodePath3, self.bike)
self.cTrav.addCollider(self.cNodePath3, collisionPusher)
###
#cHandler = CollisionHandlerEvent()
#cHandler.setInPattern("e_bike-%in")
cSphere = CollisionSphere((0, 0, .75), 1)
cNode = CollisionNode("e_bike")
cNode.addSolid(cSphere)
#cNode.setIntoCollideMask(BitMask32.allOff())
cNode.setIntoCollideMask(BitMask32(0x10)) # Player bike collides into enemy bike
cNode.setFromCollideMask(BitMask32.allOff())
self.cNodePath = self.bike.attachNewNode(cNode)
#self.cNodePath.show()
#self.cTrav.addCollider(self.cNodePath, cHandler)
#setup the node as a pusher
pusher = CollisionHandlerPusher()
pusher.addCollider(self.cNodePath, self.bike)
#show the node
#self.cNodePath.show()
#add the collider to the traverser
base.cTrav.addCollider(self.cNodePath, pusher)
#setup and parent spotlights to the player
self.spotlight1 = Spotlight("headlight1")
self.spotlight1.setColor((1, 1, 1, 1))
lens = PerspectiveLens()
#can change size of cone
lens.setFov(20)
self.spotlight1.setLens(lens)
self.spotlight1.setExponent(100)
self.spotnode1 = self.bike.attachNewNode(self.spotlight1)
self.spotnode1.setH(180)
render.setLight(self.spotnode1)
"""
existbball2 = False
firebullet = False
if existbball2 == False:
screen.blit(bballdefeated,(bball2_x, bball2_y))
if existball == False and existbball2 == True:
bball2_x = bball2_x + bball2_dx
bball2_y = bball2_y + bball2_dy
if bball2_x < 0 or bball2_x > 970:
bball2_dx = -bball2_dx
if bball2_y <0 or bball2_y > 684:
bball2_dy = -bball2_dy
screen.blit(bball2,(bball2_x, bball2_y))
if firebullet == True:
bullet_1 = Bullet()
bullet_x, bullet_y = bullet_1.shoot(bullet_x, posx, posy)
if bullet_x < 0 or bullet_x > 1000:
firebullet = False
del bullet_1
if posx < 500:
screen.blit(bullet,(bullet_x, bullet_y))
if posx > 500:
screen.blit(reversebullet,(bullet_x, bullet_y))
fpsi = fpsi + 1
if fpsi%250 == 0:
print "FPS:",clock.get_fps()#print FPS every 50 loops/frames.
clock.tick(70) #FPS
pygame.display.update()
jugador.chocar()
explosion.play()
reloj.tick(0.5)
ls_choque_asteroides = pygame.sprite.spritecollide(jugador,ls_asteroides,False)
for c in ls_choque_asteroides:
jugador.chocar()
explosion.play()
reloj.tick(10)
#para los disparos de los enemigos
for e in ls_enemigos:
if e.disparar == 0:
disparo_enemigo.play()
balae = Bullet('Images/Bullet.png')
balae.jugador = 0
balae.rect.x = e.rect.x+50
balae.rect.y = e.rect.y+90
ls_balae.add(balae)
ls_todos.add(balae)
#impactos de las balas enemigas al jugador
for be in ls_balae:
impactos = pygame.sprite.spritecollide(be,ls_jugadores,False)
for imp in impactos:
#print jugador.salud
jugador.Me_dieron()
ls_balae.remove(be)
ls_todos.remove(be)
Me_dieron.play()
