Пример #1
0
    def fire(self):
        '''英雄飛機開火 '''
        x, y = self.pos()
        if not self.firetwo:
            # 單子彈位置(0, -60)
            pos = (x, y - 60)
            b1 = Bullet(self.__canvas,
                        position=pos,
                        destroy_cb=self.__bullet_list.remove)
            self.__bullet_list.append(b1)
        else:
            # 雙子彈位置(-32, -18)和 (32, -18)
            pos1 = (x - 14, y - 18)
            pos2 = (x + 14, y - 18)
            b1 = Bullet(self.__canvas,
                        position=pos1,
                        destroy_cb=self.__bullet_list.remove)
            b2 = Bullet(self.__canvas,
                        position=pos2,
                        destroy_cb=self.__bullet_list.remove)

            self.__bullet_list.append(b2)
            self.__bullet_list.append(b1)

            self.firetwo -= 1
Пример #2
0
    def start(self):
        pygame.init()

        self.stage = Stage(self, 1)
        self.screen = pygame.display.set_mode((800, 600))

        self.background = Background(self)
        self.background.load()

        self.player = Player(self)
        self.player.load()

        self.bullet = Bullet(self)
        self.bullet.load()

        self.enemies = Enemies(self)
        self.enemies.load()

        self.game_text = GameText(self)
        self.game_text.load()

        self.explosion = Explosion(self)
        self.explosion.load()

        self.caption = Caption(self)
        self.caption.load()

        self.score = Score(self)
        self.score.load()

        while self.running:
            self.screen.fill((0, 0, 0))
            self.background.show()
            self.handle_event()
Пример #3
0
    def check_input(self):
        self.keys = key.get_pressed()
        for e in event.get():
            if self.should_exit(e):
                sys.exit()
            if e.type == KEYDOWN and e.key == K_SPACE:
                num_bullets = (self.score // 1000) + 1
                center = (self.player.rect.x + 23, self.player.rect.y + 5)
                distance = 15
                leftess_x = self.player.rect.x + 23 - (distance *
                                                       num_bullets // 2)
                rightest_x = self.player.rect.x + 23 + (distance *
                                                        num_bullets // 2)
                for i in range(0, num_bullets // 2):
                    left_bullet = Bullet(leftess_x + (distance * i),
                                         self.player.rect.y + 5, -1, 15,
                                         'laser', 'left_' + str(i))
                    right_bullet = Bullet(rightest_x - (distance * i),
                                          self.player.rect.y + 5, -1, 15,
                                          'laser', 'right_' + str(i))
                    self.bullets.add(left_bullet)
                    self.bullets.add(right_bullet)
                if num_bullets % 2 > 0:
                    bullet = Bullet(self.player.rect.x + 23,
                                    self.player.rect.y + 5, -1, 15, 'laser',
                                    'center')
                    self.bullets.add(bullet)
                if 1 == num_bullets:
                    self.sounds['shoot'].play()
                else:
                    self.sounds['shoot2'].play()

                self.allSprites.add(self.bullets)
Пример #4
0
    def update(self):
        """ Update the player position. """
        # Move left/right
        self.rect.x += self.change_x * (2 if self.shoot_mode == 1 else 1)

        # Did this update cause us to hit a wall?
        if self.rect.x < 0 or self.rect.x > Constants.SCREEN_WIDTH - self.rect.width:
            if self.change_x > 0:
                self.rect.right = Constants.SCREEN_WIDTH
            else:
                # Otherwise if we are moving left, do the opposite.
                self.rect.left = 0

        self.rect.y += self.change_y * (2 if self.shoot_mode == 1 else 1)

        if self.rect.y < 0 or self.rect.y > Constants.SCREEN_HEIGHT - self.rect.height:
            # Reset our position based on the top/bottom of the object.
            if self.change_y > 0:
                self.rect.bottom = Constants.SCREEN_HEIGHT
            else:
                self.rect.top = 0
        #logic for shooting modes
        if self.power_counter > 0:
            self.power_counter -= 1
            if self.power_counter == 0:
                print("Reset time")
                self.shoot_mode = 0

        if self.shoot_countdown == 0:
            if self.shoot_mode == 0:
                mx, my = pygame.mouse.get_pos()
                dx = float(mx - self.rect.x)
                dy = float(my - self.rect.y)
                mag = math.sqrt(dx**2 + dy**2)
                if not (mag == 0):
                    dx *= 10.0 / mag
                    dy *= 10.0 / mag
                    Game.bullets.append(
                        Bullet(self.rect.x, self.rect.y, dx, dy))
                self.shoot_countdown = 10
            if self.shoot_mode == 3:
                mx, my = pygame.mouse.get_pos()
                dx = float(mx - self.rect.x)
                dy = float(my - self.rect.y)
                mag = math.sqrt(dx**2 + dy**2)
                if not (mag == 0):
                    dx *= 10.0 / mag
                    dy *= 10.0 / mag
                    Game.bullets.append(
                        Bullet(self.rect.x, self.rect.y, dx, dy))
                self.shoot_countdown = 1
            if self.shoot_mode == 2:
                for i in range(10):
                    th = float(math.pi * 2 * i / 10.0)
                    Game.bullets.append(
                        Bullet(self.rect.x, self.rect.y, 10 * math.cos(th),
                               10 * math.sin(th)))
                self.shoot_countdown = 10
        else:
            self.shoot_countdown -= 1
Пример #5
0
    def test_bullet_collision_with_brick(self):
        terrain = BrickTerrain(150, 150)
        enemy_bullet = Bullet(150, 141, 5, 500, 1, Direction.DOWN)

        self.assertFalse(terrain.contains(enemy_bullet))

        enemy_bullet.move();
        self.assertTrue(terrain.contains(enemy_bullet))
Пример #6
0
 def creatingTheBullets(self):
     # Bullet
     self.noOfBullets = []
     bulletX = -5
     bulletY = -5
     bulletX_change = 0
     bullet_state = "ready"
     self.bullet = Bullet(0, 0, bullet_state, bulletX_change)
Пример #7
0
 def testMove(self):
     map = Game(1, 13)
     bullet = Bullet(0, 0, map, 2, 2, "right")
     x, y = bullet.currPos
     self.assertEqual([x, y], [2, 2])
     bullet.move()
     x, y = bullet.currPos
     self.assertEqual([x, y], [3, 2])
Пример #8
0
 def addElemListB(self, x, y, direction, type):
     bullet = Bullet(self.config)
     bullet.setx(x)
     bullet.sety(y)
     bullet.setType(type)
     bullet.setDirection(direction)
     self.listB.append(bullet)
     return time.time_ns()
Пример #9
0
    def cardinal_shoot(self):
        top_bullet = Bullet(self, self.rect.centerx, self.rect.top, BLACK)
        bottom_bullet = Bullet(self, self.rect.centerx, self.rect.bottom,
                               BLACK)
        right_bullet = Bullet(self, self.rect.right, self.rect.centery, BLACK)
        left_bullet = Bullet(self, self.rect.left, self.rect.centery, BLACK)

        self.bullet_list.add(top_bullet, bottom_bullet, right_bullet,
                             left_bullet)
Пример #10
0
    def fire(self, screen):

        nbullet = Bullet(self)
        nbullet.mx = 1
        self.bullets.append(nbullet)
        # her ateş edilişinde bir ateş edilme animasyonu devreye girmelidir
        # bu işlem farklı yollarla yapılabilir
        # burada yaprığımız normalde -1 olan shoot değerini 0  yapıyoruz ve nesnenin çizim fonksiyonunda bir if yapısıyla bu durumu kontrol ediyoruz.
        self.shootImageOrder = 0
Пример #11
0
    def shoot(self, stage, board):
        ret = board
        if time.time() - self.__shoot_time >= 1:
            obj_bullet = Bullet(self.__x, self.__y, stage)
            ret = obj_bullet.print(board)
            self.__bul_arr.append(obj_bullet)
            self.__shoot_time = time.time()

        return ret
Пример #12
0
    def diagonal_shoot(self):
        top_right_bullet = Bullet(self, self.rect.right, self.rect.top, BLACK)
        top_left_bullet = Bullet(self, self.rect.left, self.rect.top, BLACK)
        bottom_right_bullet = Bullet(self, self.rect.right, self.rect.bottom,
                                     BLACK)
        bottom_left_bullet = Bullet(self, self.rect.left, self.rect.bottom,
                                    BLACK)

        self.bullet_list.add(top_right_bullet, top_left_bullet,
                             bottom_right_bullet, bottom_left_bullet)
Пример #13
0
 def shoot(self):
     if len(BULLETS) < 3:
         self.shot = True
         self.anim_count_shot = 0
         if self.right:
             bullet = Bullet(self.rect.x, self.rect.y, 'right')
             BULLETS.add(bullet)
         elif self.left:
             bullet = Bullet(self.rect.x, self.rect.y, 'left')
             BULLETS.add(bullet)
Пример #14
0
    def test_player_tank_collision_with_enemy_bullet(self):
        # x, y, speed, owner_id, attack, direction
        enemy_bullet = Bullet(86, 100, 5, 500, 1, Direction.RIGHT)
        self.assertFalse(self.player.contains(enemy_bullet))

        enemy_bullet.move()
        self.assertFalse(self.player.contains(enemy_bullet))

        enemy_bullet.move()
        self.assertTrue(self.player.contains(enemy_bullet))
Пример #15
0
    def shoot(self, _bulletList, _playerPos):
        self.shootCounter += 1
        if self.shootCounter == self.shootFreq:
            self.shootCounter = 0

            # generuje pociski z zaleznosci od typu strzalu

            if self.shootType == ShootType.NORMAL:
                self.bulletAdd(_bulletList, 0, 1)

            elif self.shootType == ShootType.FOURDIRECTION:
                self.bulletAdd(_bulletList, 0, 1)
                self.bulletAdd(_bulletList, 1, 0)
                self.bulletAdd(_bulletList, 0, -1)
                self.bulletAdd(_bulletList, -1, 0)

            elif self.shootType == ShootType.AIMED:
                xP = _playerPos.x
                yP = _playerPos.y
                xE = self.rect.x
                yE = self.rect.y
                r = math.sqrt(pow(abs(xP - xE), 2) + pow(abs(yP - yE), 2))
                sin = (yP - yE) / r
                cos = (xP - xE) / r
                self.bulletAdd(_bulletList, cos, sin)

            elif self.shootType == ShootType.EIGHTDIRECTION:
                self.bulletAdd(_bulletList, 0, 1)
                self.bulletAdd(_bulletList, 1, 0)
                self.bulletAdd(_bulletList, -1, 0)
                self.bulletAdd(_bulletList, 0, -1)
                self.bulletAdd(_bulletList, 1, 1)
                self.bulletAdd(_bulletList, -1, 1)
                self.bulletAdd(_bulletList, 1, -1)
                self.bulletAdd(_bulletList, -1, -1)

            elif self.shootType == ShootType.DOUBLE:
                _bulletList.add(
                    Bullet(
                        "data/new_bullet.png",
                        pygame.math.Vector2(
                            self.rect.left,
                            self.rect.top + self.img.get_height() / 2 - 3), 3,
                        pygame.math.Vector2(0, 1), 8))
                _bulletList.add(
                    Bullet(
                        "data/new_bullet.png",
                        pygame.math.Vector2(
                            self.rect.right,
                            self.rect.top + self.img.get_height() / 2 - 3), 3,
                        pygame.math.Vector2(0, 1), 8))
            elif self.shootType == ShootType.SPUN:
                sin = math.sin(self.rect.y)
                cos = math.cos(self.rect.y)
                self.bulletAdd(_bulletList, cos, sin)
Пример #16
0
 def shootBullet(self, state):  #pew pew
     if self.ammo > 0:
         #state is 0 use the mouse
         if state == 0:
             offset = (
                 self.mouseY - self.playerY, self.mouseX - self.playerX
             )  #should calculate angle between player and mouse, unsure if this works
             angle = 135 - math.degrees(math.atan2(*offset))
             #angle = 0 #placeholder
             playerBullet = Bullet(self.playerX, self.playerY, angle)
         #state is 1 use space key
         elif state == 1:
             if self.currentFace == MoveConstants.UP:
                 playerBullet = Bullet(self.playerX, self.playerY, -135)
             elif self.currentFace == MoveConstants.DOWN:
                 playerBullet = Bullet(self.playerX, self.playerY, 45)
             elif self.currentFace == MoveConstants.LEFT:
                 playerBullet = Bullet(self.playerX, self.playerY, -45)
             elif self.currentFace == MoveConstants.RIGHT:
                 playerBullet = Bullet(self.playerX, self.playerY, 135)
             elif self.currentFace == MoveConstants.UPRIGHT:
                 playerBullet = Bullet(self.playerX, self.playerY, 180)
             elif self.currentFace == MoveConstants.UPLEFT:
                 playerBullet = Bullet(self.playerX, self.playerY, -90)
             elif self.currentFace == MoveConstants.DOWNRIGHT:
                 playerBullet = Bullet(self.playerX, self.playerY, 90)
             elif self.currentFace == MoveConstants.DOWNLEFT:
                 playerBullet = Bullet(self.playerX, self.playerY, 0)
         pygame.mixer.Sound(Sounds.SHOOTSOUND).play()
         self.bulletList.append(playerBullet)
         self.ammo -= 1
    def maybeShoot(self, keys):
        """ Shoots a bullet if the player pressed the trigger

        arguments:
        keys -- A list consisting of keys preseed
        """
        if ( keys[pygame.K_SPACE] and self.bullet.bulletFlag <= 0):
            self.bullet = Bullet([self.rect.x+self.rect.width/2,
                                 self.rect.y-10],"UP")
            audio.fire()
            self.bullet.run()
    def __init__(self, pos):
        """Initializes the player ship.

        arguments:
        pos --  a list consisting of x and y coordinate of player ship
        """
        self.image = pygame.image.load("images/player-sprite.png")
        self.rect = self.image.get_rect()
        self.rect.move_ip(*pos)
        # The player bullet 
        self.bullet = Bullet([0,0],"UP", isEnemyBullet=False)
Пример #19
0
 def new_bullet(self):
     if self.bullet == None:
         self.bullet = Bullet(self.settings, self.screen, self,
                              self.settings.bullet2)
         self.bullet_number += 1
     else:
         if self.bullet.rect.y < self.settings.screenHeight:
             self.bullet.rect.y += self.settings.bullet_speed_factor
             self.bullet.draw_bullet()
         else:
             self.bullet = None
Пример #20
0
 def fire(self, mposition):
     nbullet = Bullet(self)
     mx = float(mposition[0] - self.width / 2)
     my = float(mposition[1] - self.height / 2)
     angle = math.atan2(my, mx)
     nbullet.mx = float(math.cos(angle)) * 10
     nbullet.my = float(math.sin(angle)) * 10
     print(nbullet.mx)
     print(nbullet.my)
     nbullet.image = pygame.transform.rotate(nbullet.image,
                                             -math.degrees(angle))
     self.bullets.append(nbullet)
Пример #21
0
    def shoot(self, x, y):
        xChange = x-self.x-32
        yChange = y-self.y-32

        size = xChange*xChange + yChange*yChange
        xChange /= math.sqrt(size)
        yChange /= math.sqrt(size)
        return [Bullet(xChange*self.bulletSpeed, yChange*self.bulletSpeed, self.bulletDamage, self), 
                Bullet(xChange*self.bulletSpeed, yChange*self.bulletSpeed + 1, self.bulletDamage, self),
                Bullet(xChange*self.bulletSpeed, yChange*self.bulletSpeed - 1, self.bulletDamage, self),
                Bullet(xChange*self.bulletSpeed, yChange*self.bulletSpeed + 2, self.bulletDamage, self),
                Bullet(xChange*self.bulletSpeed, yChange*self.bulletSpeed - 2, self.bulletDamage, self),]
Пример #22
0
    def single_shoot(self, bullet1_surface):

        bullet1 = Bullet(bullet1_surface,
                         [self.rect.left + 24, self.rect.top - 8])
        bullet2 = Bullet(bullet1_surface,
                         [self.rect.left + 24 - 8, self.rect.top])
        bullet3 = Bullet(bullet1_surface,
                         [self.rect.left + 24 + 8, self.rect.top])

        self.bullets1.add(bullet1)
        self.bullets2.add(bullet2)
        self.bullets3.add(bullet3)
Пример #23
0
class Alien(Sprite):
    """description of class"""
    def __init__(self, **kwargs):
        super().__init__()
        self.screen = kwargs['screen']
        self.settings = kwargs['settings']
        self.image = pygame.image.load(kwargs['image'])
        self.rect = self.image.get_rect()
        self.x = -float(self.rect.width)
        self.y = float(self.rect.height / 2)
        self.rect.x = self.x
        self.rect.y = self.y
        self.is_finish_bullet = False
        #斜率K
        self.k = -(self.settings.screenHeight -
                   200) / self.settings.screenWidth
        self.bullet = None
        self.bullet_number = 0

    def update(self, *args):
        if self.rect.x <= self.settings.screenWidth - 100 and self.y == float(
                self.rect.height / 2):
            self.x += self.settings.alien_x_speed
        else:
            #self.x=(self.y-self.settings.screenHeight+200)/self.k
            self.y += self.settings.alien_y_speed
            self.x -= self.settings.alien_x_speed
        self.rect.x = self.x
        self.rect.y = self.y

    def new_bullet(self):
        if self.bullet == None:
            self.bullet = Bullet(self.settings, self.screen, self,
                                 self.settings.bullet2)
            self.bullet_number += 1
        else:
            if self.bullet.rect.y < self.settings.screenHeight:
                self.bullet.rect.y += self.settings.bullet_speed_factor
                self.bullet.draw_bullet()
            else:
                self.bullet = None

    def update_bullet(self):
        if self.bullet.rect.y < self.settings.screenHeight:
            self.bullet.rect.y += self.settings.bullet_speed_factor
            self.bullet.draw_bullet()
        else:
            self.bullet = None

    def blitme(self):
        """在指定的位置显示外星人"""
        self.screen.blit(self.image, self.rect)
Пример #24
0
 def __init__(self, pos, angle):
     Bullet.__init__(self, pos, angle)
     self.image = pygame.image.load("Resources/powerUps/pierce.png")
     self.rect = self.image.get_rect()
     self.angle = angle
     self.rot_angle = self.angle - 90
     rot_image = pygame.transform.rotate(self.image, self.rot_angle)
     rot_rect = self.rect.copy()
     rot_rect.center = rot_image.get_rect().center
     rot_image = rot_image.subsurface(rot_rect)
     self.image = rot_image
     self.place(pos)
     self.radius = self.rect.height/2
Пример #25
0
 def __init__(self, player):
     pygame.sprite.Sprite.__init__(self)
     # 玩家编号(1/2)
     self.player = player
     # 不同玩家用不同的坦克(不同等级对应不同的图)
     if player == 1:
         self.Tanks = [
             './images/myTank/tank_T1_0.png',
             './images/myTank/tank_T1_1.png',
             './images/myTank/tank_T1_2.png'
         ]
     elif player == 2:
         self.Tanks = [
             './images/myTank/tank_T2_0.png',
             './images/myTank/tank_T2_1.png',
             './images/myTank/tank_T2_2.png'
         ]
     else:
         raise ValueError('myTank class -> player value error.')
     # 坦克等级(初始0)
     self.level = 0
     # 载入(两个tank是为了轮子特效)
     self.tank = pygame.image.load(self.Tanks[self.level]).convert_alpha()
     self.tank_0 = self.tank.subsurface((0, 0), (48, 48))
     self.tank_1 = self.tank.subsurface((48, 0), (48, 48))
     self.rect = self.tank_0.get_rect()
     # 保护罩
     self.protected_mask = pygame.image.load(
         './images/others/protect.png').convert_alpha()
     self.protected_mask1 = self.protected_mask.subsurface((0, 0), (48, 48))
     self.protected_mask2 = self.protected_mask.subsurface((48, 0),
                                                           (48, 48))
     # 坦克方向
     self.direction_x, self.direction_y = 0, -1
     # 不同玩家的出生位置不同
     if player == 1:
         self.rect.left, self.rect.top = 3 + 24 * 8, 3 + 24 * 24
     elif player == 2:
         self.rect.left, self.rect.top = 3 + 24 * 16, 3 + 24 * 24
     else:
         raise ValueError('myTank class -> player value error.')
     # 坦克速度
     self.speed = 3
     # 是否存活
     self.being = True
     # 有几条命
     self.life = 3
     # 是否处于保护状态
     self.protected = False
     # 子弹
     self.Bullet = Bullet()
Пример #26
0
class Player(object):

	def __init__(self, surface):
		self.gun_type = 1
		self.player = pygame.image.load("res/player gunner" + str(self.gun_type) + ".png")
		self.bullet = Bullet(surface, self.gun_type)
		self.surface = surface
		self.player_posx = 100
		self.player_posy = 400
		self.check_change_gun = 1
		self.check = False
		self.fire_bullet = False
		self.bullet_posx = 480
		

	def render(self):
		self.surface.blit(self.player,(self.player_posx, 720 - self.player_posy))
		if self.check == True:
			self.player = pygame.image.load("res/player gunner" + str(self.gun_type) + ".png")
		

	def change_weapon(self):
		if pygame.key.get_pressed()[K_z]:
			self.gun_type = 1
		if pygame.key.get_pressed()[K_x]:
			self.gun_type = 2

	def update(self):
		self.change_weapon()
		if self.check_change_gun != self.gun_type:
			self.check = True
			self.check_change_gun = self.gun_type
		else:
			self.check = False
		self.fire()
		self.bullet_posx = self.bullet.bullet_posx
		

	def fire(self):
		if pygame.key.get_pressed()[K_SPACE]:
			self.fire_bullet = True

		if self.fire_bullet == True:
			self.bullet.render()
			self.bullet.move()
		else:
			self.bullet.bullet_posx = 480

		if self.bullet.check_bullet() == True:
			self.fire_bullet = False
Пример #27
0
 def keyDown(self):
     if key == 's' or key == 'S':
         SpriteManager.spawn(Bullet(self.x, self.y, PVector(0, 10), 100))
     if key == ' ' or key == 'w':
         SpriteManager.spawn(Bullet(self.x, self.y, PVector(0, -10), 100))
         
     if keyCode == LEFT:
         self.left = True
     if keyCode == RIGHT:
         self.right = True
     if keyCode == UP:
         self.up = True
     if keyCode == DOWN:
         self.down = True
Пример #28
0
    def shoot(self):
        #Test if should be shooting
        if self.shooting and not self.equipped_primary_weapon.get_reloading():
            weapon_bullets_per_update = 3600 / int(
                self.equipped_primary_weapon.get_firerate())
            start_pos = self.pos

            if self.direction > 0:
                start_pos = [
                    self.pos[0] + self.size[0] +
                    self.equipped_primary_weapon.get_size()[0],
                    self.pos[1] + self.arm_height
                ]
            else:
                start_pos = [
                    self.pos[0] - self.equipped_primary_weapon.get_size()[0] -
                    20, self.pos[1] + self.arm_height
                ]
            #Test for which type of weapon: 0 == SMG, 1 == Assault Rifle, 2 == LMG, 3 == Shotgun, 4 == Sniper, 5 == Pistol
            if self.equipped_primary_weapon.get_type(
            ) == 0 or self.equipped_primary_weapon.get_type(
            ) == 1 or self.equipped_primary_weapon.get_type() == 2:
                if self.loop_count % weapon_bullets_per_update < 1:
                    bullet = Bullet(start_pos, [15, 3], (0, 0, 0),
                                    [15 * self.direction, 0.001],
                                    self.equipped_primary_weapon.get_damage())
                    self.equipped_primary_weapon.add_bullet(bullet)
                    self.equipped_primary_weapon.remove_current_ammo(1)

            elif self.equipped_primary_weapon.get_type(
            ) == 4 or self.equipped_primary_weapon.get_type() == 5:
                if not self.equipped_primary_weapon.get_shot():
                    bullet = Bullet(start_pos, [20, 3], (0, 0, 0),
                                    [30 * self.direction, 0.001],
                                    self.equipped_primary_weapon.get_damage())
                    self.equipped_primary_weapon.add_bullet(bullet)
                    self.equipped_primary_weapon.set_shot(True)
                    self.equipped_primary_weapon.remove_current_ammo(1)

            elif self.equipped_primary_weapon.get_type() == 3:
                if not self.equipped_primary_weapon.get_shot():
                    for x in range(0, 10):
                        bullet = Bullet(
                            [start_pos[0], start_pos[1]], [15, 3], (0, 0, 0),
                            [15 * self.direction, x - 5],
                            self.equipped_primary_weapon.get_damage())
                        self.equipped_primary_weapon.add_bullet(bullet)
                    self.equipped_primary_weapon.set_shot(True)
                    self.equipped_primary_weapon.remove_current_ammo(1)
Пример #29
0
def shoot():
    global power
    if power == 1:
        sound_pew.play()
        bullet = Bullet(player.rect.centerx, player.rect.centery)
        bullets.add(bullet)
        all_sprites.add(bullet)
    elif power == 2:
        sound_pew.play()
        bullet1 = Bullet(player.rect.centerx - 10, player.rect.centery)
        bullet2 = Bullet(player.rect.centerx + 10, player.rect.centery)
        bullets.add(bullet1)
        bullets.add(bullet2)
        all_sprites.add(bullet1)
        all_sprites.add(bullet2)
Пример #30
0
 def __init__(self, name, screen_x, screen_y, frames_per_second):
     Game.__init__(self, name, screen_x, screen_y)
     ship_position = Point(config.SCREEN_X/2, config.SCREEN_Y/2)
     self.ship = Ship(ship_position, config.SHIP_INITIAL_DIRECTION, config.SHIP_COLOR)
     self.bullet = Bullet(Point(0,0), config.BULLET_RADIUS, 0, config.BULLET_COLOR)
     self.stars = []
     for i in range(config.STAR_COUNT):
         s = Star()
         self.stars.append(s)
     self.rocks = []
     for i in range(config.ROCK_COUNT):
         (x,y) = random.randint(0, config.SCREEN_X), random.randint(0, config.SCREEN_Y)
         p = Point(x,y)
         r = Rock(p, random.uniform(0, 360.0), config.ROCK_COLOR, (random.uniform(0.0, config.ROCK_MAX_ROTATION_SPEED) * random.uniform(-1.0,1.0)), random.randint(0, config.ROCK_MAX_SPEED))
         self.rocks.append(r)
Пример #31
0
    def createBullet(self):
        """If it is possible (no collision with terrain or bounds) creates a new bullet and returns it.
        Returns none if the bullet was not created"""
        bulletPos = self.currPos[:]
        d = self.CTRLS.index(self.faceDirection)
        bulletPos[d > 2] += (d - (1 if d < 3 else 4))

        bullet = Bullet(self.map.currentBulletId, self.id, self.map,
                        bulletPos[0], bulletPos[1], self.faceDirection)
        if(bullet.checkCollision() == True):
            return None
        else:
            self.map.currentBulletId += 1
            self.bullets.append(bullet)
            return bullet
Пример #32
0
 def player_shoot_bullet(player):
     Entities.player_bullet.append(
         Bullet([
             player.draw_rect[0],
             player.draw_rect[1] - Constants.player_size,
             Constants.bullet_size, Constants.bullet_size
         ], [45, 50, 10, 50], Constants.bullet_image))
Пример #33
0
 def shot(self):
     if self.shot_cooldown <= 0:
         if self.last_direction < 0:
             self.image = self.shot_left
             right = False
             bullet = Bullet("bullet", self.x,
                             self.y + int(0.75 * self.height), right)
         else:
             self.image = self.shot_right
             right = True
             bullet = Bullet("bullet", self.x + self.width,
                             self.y + int(0.75 * self.height), right)
         self.shot_cooldown = 20
         return bullet
     else:
         return False
Пример #34
0
	def __init__(self, x, y, speedX, speedY, throwDistance):
		Bullet.__init__(self, x, y, speedX, speedY, "items-1small.png", None, Rect(110, 120, 9, 11))
		self.rect = Rect(x, y, 0, 0)
		self.speedX = speedX
		self.speedY = speedY

		# Important if you want pinpoint accuracy
		self.floatX = float(self.rect.x)
		self.floatY = float(self.rect.y)


		if throwDistance > MAX_THROW_DISTANCE:
			throwDistance = MAX_THROW_DISTANCE

		self.timeToStop = throwDistance / GRENADE_SPEED
		self.timeToBoom = TIME_TO_BOOM
Пример #35
0
 def createBullet(self, bullets, allSprites):
     self.fireSound.play()
     bullet = Bullet(self.rect.x + (self.image.get_width() / 2),
                     self.rect.y)
     bullets.add(bullet)
     allSprites.add(bullet)
     self.counter = 0
Пример #36
0
	def __init__(self, surface):
		self.gun_type = 1
		self.player = pygame.image.load("res/player gunner" + str(self.gun_type) + ".png")
		self.bullet = Bullet(surface, self.gun_type)
		self.surface = surface
		self.player_posx = 100
		self.player_posy = 400
		self.check_change_gun = 1
		self.check = False
		self.fire_bullet = False
		self.bullet_posx = 480
Пример #37
0
class Asteroids(Game):
    def __init__(self, name, screen_x, screen_y, frames_per_second):
        Game.__init__(self, name, screen_x, screen_y)
        ship_position = Point(config.SCREEN_X/2, config.SCREEN_Y/2)
        self.ship = Ship(ship_position, config.SHIP_INITIAL_DIRECTION, config.SHIP_COLOR)
        self.bullet = Bullet(Point(0,0), config.BULLET_RADIUS, 0, config.BULLET_COLOR)
        self.stars = []
        for i in range(config.STAR_COUNT):
            s = Star()
            self.stars.append(s)
        self.rocks = []
        for i in range(config.ROCK_COUNT):
            (x,y) = random.randint(0, config.SCREEN_X), random.randint(0, config.SCREEN_Y)
            p = Point(x,y)
            r = Rock(p, random.uniform(0, 360.0), config.ROCK_COLOR, (random.uniform(0.0, config.ROCK_MAX_ROTATION_SPEED) * random.uniform(-1.0,1.0)), random.randint(0, config.ROCK_MAX_SPEED))
            self.rocks.append(r)

    def game_logic(self, keys, newkeys):
        for s in self.stars:
            s.game_logic(keys, newkeys)
        self.ship.game_logic(keys, newkeys)
        for rock in self.rocks:
            rock.game_logic(keys, newkeys)
            if rock.isActive() == True:
                if self.ship.intersect(rock) == True:
                    self.ship.set_inactive()
                if self.bullet.intersect(rock) == True:
                    rock.set_inactive()
                    self.bullet.set_inactive()
        if pygame.K_SPACE in newkeys:
            if self.ship.isActive() == True:
                points = self.ship.getPoints()
                self.bullet.fire(points[0], self.ship.rotation)
        self.bullet.game_logic(keys,newkeys)

    def paint(self, surface):
        self.screen.fill(config.BACKGROUND_COLOR)
        for s in self.stars:
            s.paint(surface)
        self.ship.paint(surface)
        self.bullet.paint(surface)
        for rock in self.rocks:
            rock.paint(surface)
class PlayerShip(pygame.sprite.Sprite):
    """The player's own ship"""

    def __init__(self, pos):
        """Initializes the player ship.

        arguments:
        pos --  a list consisting of x and y coordinate of player ship
        """
        self.image = pygame.image.load("images/player-sprite.png")
        self.rect = self.image.get_rect()
        self.rect.move_ip(*pos)
        # The player bullet 
        self.bullet = Bullet([0,0],"UP", isEnemyBullet=False)

    def update(self,keys):
        """ Update the position of player ship based keys pressed

        arguments:
        keys -- A list consisting of keys preseed
        """
        if ( keys[pygame.K_LEFT] and self.rect.x > 30 ):
            self.rect.move_ip(-8,0)
        if ( keys[pygame.K_RIGHT] and self.rect.x < 550 ):
            self.rect.move_ip(8,0)

    def maybeShoot(self, keys):
        """ Shoots a bullet if the player pressed the trigger

        arguments:
        keys -- A list consisting of keys preseed
        """
        if ( keys[pygame.K_SPACE] and self.bullet.bulletFlag <= 0):
            self.bullet = Bullet([self.rect.x+self.rect.width/2,
                                 self.rect.y-10],"UP")
            audio.fire()
            self.bullet.run()
Пример #39
0
 def __init__(self, name, screen_x, screen_y, frames_per_second):
     Game.__init__(self, name, screen_x, screen_y)
     ship_position = Point(config.SCREEN_X/2, config.SCREEN_Y/2)
     self.ship = Ship(ship_position, config.SHIP_INITIAL_DIRECTION, config.SHIP_COLOR)
     self.bullet = Bullet(Point(0,0), config.BULLET_RADIUS, 0, config.BULLET_COLOR)
     self.stars = []
     for i in range(config.STAR_COUNT):
         s = Star()
         self.stars.append(s)
     self.rocks = []
     for i in range(config.ROCK_COUNT):
         (x,y) = random.randint(0, config.SCREEN_X), random.randint(0, config.SCREEN_Y)
         p = Point(x,y)
         r = Rock(p, random.uniform(0, 360.0), config.ROCK_COLOR, (random.uniform(0.0, config.ROCK_MAX_ROTATION_SPEED) * random.uniform(-1.0,1.0)), random.randint(0, config.ROCK_MAX_SPEED))
         self.rocks.append(r)
Пример #40
0
def deserializeBullet(bullet):
    retbullet = Bullet(bullet['location'], bullet['bounds'], bullet['direction'], bullet['velocity'])
    retbullet.id = bullet['id']
    return retbullet
Пример #41
0
    # UPDATE GAME

    AStar(survivor, total_frames, FPS)
    Zombie.spawn(total_frames, FPS)
    survivor.movement()

    # RENDING ACTIONS

    # draws either a Floor or a Wall tile
    for tile in Tile.list_:
        if tile.type == Tile.Type.FLOOR:
            screen.blit(floor_img, (tile.x, tile.y))
        elif tile.type == Tile.Type.WALL:
            screen.blit(wall_img, (tile.x, tile.y))

    Bullet.update(screen)
    Zombie.update(screen, survivor)
    survivor.draw(screen)
    display_health_bar()


    pygame.display.flip()

    clock.tick(FPS)
    total_frames += 1

display_end_game_screen()

sleep(PAUSE_TIME)
Пример #42
0
 def shoot(self):
     bullet = Bullet()
     bullet.rect.center = self.rect.center
     bullet.speed = 5
     return bullet
Пример #43
0
 for event in pygame.event.get():
     if event.type == QUIT:
         exit()
 if not player_ship.isDead():
     sinD = math.sin(math.radians(player_ship.direction))
     cosD = math.cos(math.radians(player_ship.direction))
     keys = pygame.key.get_pressed()
     if keys[K_w] or keys[K_UP]:
         player_ship.move()
         moved = True
     if keys[K_a] or keys[K_LEFT]:
         player_ship.turn_left()
     if keys[K_d] or keys[K_RIGHT]:
         player_ship.turn_right()
     if keys[K_SPACE] and player_ship.delay<=0:
         bullet = Bullet((x + dimy*sinD, y-dimy*cosD), (BULLET_SIZE, BULLET_SIZE), player_ship.direction, (BULLET_SPEED*sinD, -BULLET_SPEED*cosD), BULLET_DURATION)
         #bullet = (x + dimy*sinD, y-dimy*cosD, player_ship.direction, BULLET_DURATION)
         bulletList.append(bullet)
         player_ship.delay = SHOOT_DELAY
         player_ship.move_from_force_in_direction(player_ship.acceleration, player_ship.direction+180)
 
 player_ship.update()
 
 for n in wall_list:
     if player_ship.rect.colliderect(n) and not player_ship.isDead():
         player_ship.kill(DEATH_TIME)
         Display.death_animation(player_ship, debris, BLACK)
 
 camera.set_camera_loc((x, y))
 camera.bound_camera(map_dimensions)
     
Пример #44
0
def Game():

    #allows the gloabal variables to be changed
    global lastHit
    global done
    global isMuted

    #This funciton will define and call a funciton to get initals and print
    #them to the screen
    def endGame():
        def askForInitials():
            screen.fill((0,0,0))
            myfont = pygame.font.Font(None, 36)
            text = myfont.render("Please enter you initials", True, (180,0,16))
            text2= myfont.render((""+initials+blankInitials[count:]),True, (180,0,16))
            text_rect = text.get_rect()
            text2_rect = text2.get_rect()
            screen.blit(text,(screen_width/2-text_rect.width/2,screen_height/2-text_rect.height/2\
                          -text_rect.height-text_rect.height-text_rect.height-text_rect.height\
                          -text_rect.height))
            screen.blit(text2,(screen_width/2-text2_rect.width/2,screen_height/2-text_rect.height/2\
                          -text_rect.height-text_rect.height-text_rect.height-text_rect.height))
            pygame.display.flip()

        #Sets a flag for the while loop
        playAgain=False

        #sets variables for the intitials and blank spots that will get printed to
        #the screen when getting initials
        blankInitials="---"
        initials=""

        #Sets a flag for the loop that will allow it to be ran three times
        #This is needed because while loops work great with stopping pygame
        #code so nothing else runs(That is why a for loop didnt work)
        initialsEntered=False
        count=0

        #Loops to ask for initials and will only take the lower case letters
        #with the if for the ascii key numbers
        while not(initialsEntered):
            screen.fill((0,0,0))
            askForInitials()
            for event in pygame.event.get():
                if event.type == pygame.KEYDOWN:
                    if event.key>=97 and event.key<=122:
                        initials+=pygame.key.name(event.key).upper()

                        count+=1
                    if count==3:
                        askForInitials()
                        initialsEntered=True
                        break

        #Opens the HighScore file for reading
        highScore=open('HighScore.txt','r')

        fileLine=0
        firstline=""
        highScores={}
        #Reads in the file
        for line in highScore:
            #Reads in the header line
            if(fileLine==0):
                firstline=line
                fileLine+=1
                continue
            #Gets the name,level, and score of the players
            temp=[]
            #splits the info into 3 different parts then save them to
            #the dictionary
            split=line.split("\t\t")
            temp.append(split[1])
            temp.append(split[2])
            temp.append(int(split[3]))
            highScores[split[0]]=temp

        #closes the read on the highscore list
        highScore.close()
        playerStats=[]
        #makes a list of the current player stats so they can be comparied against
        #the list
        playerStats.append(initials)
        playerStats.append(str(player.level))
        playerStats.append(player.pikaScore)

        #goes through the dictionary and sees where the current player needs to get added
        #then will bump the person at the spot move down one
        for x in range((len(highScores))):
            if (highScores[str(len(highScores)-x)+")"][2]<player.pikaScore):
                highScores[str(len(highScores)-x+1)+")"]=highScores[str(len(highScores)-x)+")"]
                highScores[str(len(highScores)-x)+")"]=playerStats

        #Opens a high score list for writing that will delete the old list
        #then replace it with the new names that go on it
        highScore=open('HighScore.txt','w')
        highScore.write(firstline)
        for x in range(1,11):
            highScore.write(str(x)+")\t\t"+highScores[str(x)+")"][0]+"\t\t"\
                            +highScores[str(x)+")"][1]+"\t\t"+str(highScores[str(x)+")"][2])+"\t\t\n")

        #closes the high score list
        highScore.close()

        while playAgain==False:
            myfont = pygame.font.Font(None, 36)

            #makes four lines to print to the screen
            text = myfont.render("Game Over", True, (180,0,16))
            text1 = myfont.render(("Level: "+str(player.level)), True, (180,0,16))
            text2 = myfont.render(("Score: "+str(player.pikaScore)), True, (180,0,16))
            text3 = myfont.render("Press ENTER to play again", True, (180,0,16))

            text_rect = text.get_rect()
            text1_rect = text1.get_rect()
            text2_rect = text2.get_rect()
            text3_rect = text3.get_rect()

            text1x = screen.get_width()/2 - text1_rect.width/2
            text1y = screen.get_height()/2 - text1_rect.height

            textx=(text1x+text1_rect.width/2)-text_rect.width/2
            texty=text1y-text_rect.height
            text2x=(text1x+text1_rect.width/2)-text2_rect.width/2
            text2y=text1y+text1_rect.height
            text3x=(text1x+text1_rect.width/2)-text3_rect.width/2
            text3y=text2y+text2_rect.height

            screen.blit(text, (textx,texty))
            screen.blit(text1, (text1x,text1y))
            screen.blit(text2, (text2x,text2y))
            screen.blit(text3, (text3x,text3y))

            pygame.display.flip()

            for event in pygame.event.get():
                if event.type == pygame.QUIT: # If user clicked close
                    global done
                    done=True # Flag that shows game is over
                    playAgain=True #Flag that they entered something to get out of loop

                if event.type == pygame.KEYDOWN:
                    if event.key==pygame.K_RETURN:
                        playAgain=True #Flag to show they want to play again



        if done==False:
            Game()
    #Prints instructions to the screen
    def instructions():
        global done

        myfont = pygame.font.Font(None, 32)
        text1 = myfont.render("Pikachu vs. Zubats", True, (180,0,16))
        text2 = myfont.render("Instructions", True, (180,0,16))
        text3 = myfont.render("Arrow Keys: Move in Direction", True, (180,0,16))
        text4 = myfont.render("Space Bar: Shoots lightning bolt", True, (180,0,16))
        text5 = myfont.render("Press ENTER to continue", True, (180,0,16))

        text1_rect = text1.get_rect()
        text2_rect = text2.get_rect()
        text3_rect = text3.get_rect()
        text4_rect = text4.get_rect()
        text5_rect = text5.get_rect()

        text4x=screen_width/2-text4_rect.width/2
        text4y=screen_height/2-text4_rect.height/2

        text3x=screen_width/2-text3_rect.width/2
        text3y=screen_height/2-text3_rect.height/2-text4_rect.height

        text2x=screen_width/2-text2_rect.width/2
        text2y=screen_height/2-text2_rect.height/2-text4_rect.height-text3_rect.height

        text5x=screen_width/2-text5_rect.width/2
        text5y=screen_height/2-text5_rect.height/2+text4_rect.height+text4_rect.height

        text1x=screen_width/2-text1_rect.width/2
        text1y=screen_height/2-text1_rect.height/2-text4_rect.height-text3_rect.height-text2_rect.height\
                -text1_rect.height

        screen.blit(text1, (text1x,text1y))
        screen.blit(text2, (text2x,text2y))
        screen.blit(text3, (text3x,text3y))
        screen.blit(text4, (text4x,text4y))
        screen.blit(text5, (text5x,text5y))

        pygame.display.flip()
        while True:
            goToGame=False
            for event in pygame.event.get():
                if event.type == pygame.QUIT: # If user clicked close
                    done=True # Flag that shows game is over
                    goToGame=True
                if event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_RETURN:
                        goToGame=True
            if goToGame:
                break

    # Initialize Pygame
    pygame.init()

    # Set the height and width of the screen
    screen_width=700
    screen_height=500
    screen=pygame.display.set_mode([screen_width,screen_height])

    #Sets the game window title
    pygame.display.set_caption("Pikachu vs. Zubats")

    #calls the instructions which will print the instructions to the screen
    instructions()

    #creats the backgound then adds it to a background list
    background = Background()
    background.rect.width=screen_width
    background.rect.height=screen_height
    background.rect.y=-150
    background.rect.x=-150

    backgroundPlain = pygame.sprite.RenderPlain()
    backgroundPlain.add(background)

    #draws the background to the screen
    backgroundPlain.draw(screen)

    # This is a list of every sprite.
    all_sprites_list = pygame.sprite.RenderPlain()

    playerList= pygame.sprite.RenderPlain()

    # Create a pikachu player
    player = Pikachu()
    player.rect.x=(screen_width/2)-(player.rect.width/2)
    player.rect.y=(screen_height/2)-(player.rect.height/2)
    all_sprites_list.add(player)
    playerList.add(player)


    # Used to manage how fast the screen updates
    clock=pygame.time.Clock()

    #Creats a sprite list that will then be able to loop through
    bulletListRight= pygame.sprite.RenderPlain()
    bulletListLeft= pygame.sprite.RenderPlain()
    zubats=pygame.sprite.RenderPlain()

   

    while True:

        #Counts the number of zubats that were sent out in the current level
        numOfZubats=0

        #The max number of zubats for the level
        maxZubatsPerLevel=random.randrange((4*player.level),(7*player.level))

        #The to wait between when zubats will be sent out
        waitTime=random.randrange(10)/float(player.level)

        #the time on the clock to know when to send out the first zubat
        oldTime=time.clock()

        #Prints the level and then if repels effect wore off when the spawn time
        #is 0
        myfont = pygame.font.Font(None, 36)
        text = myfont.render(("Level "+str(player.level)), True, (180,0,16))
        text2 = myfont.render(("Repels' effect wore off..."), True, (180,0,16))

        text_rect = text.get_rect()
        text_rect2=text2.get_rect()
        textx = screen.get_width()/2 - text_rect.width/2
        texty = screen.get_height()/2 - text_rect.height/2
        text2x = screen.get_width()/2 - text_rect2.width/2
        text2y = screen.get_height()/2 - text_rect.height/2+text_rect.height
        screen.blit(text, (textx,texty))
        if waitTime==0:
            screen.blit(text2, (text2x,text2y))

        pygame.display.flip()
        time.sleep(2)

        # -------- Main Program Loop -----------
        while done==False:

            myfont = pygame.font.Font(None, 24)
            text = myfont.render(("Score: "+str(player.pikaScore))\
                                    , True, (180,0,16))
            text_rect = text.get_rect()
            textx = screen_width-text_rect.width
            texty = 1
            screen.blit(text, (textx,texty))

            pygame.display.flip()


            for event in pygame.event.get(): # User did something
                if event.type == pygame.QUIT: # If user clicked close
                    done=True # Flag that we are done so we exit this loop



                if event.type == pygame.KEYDOWN:
                    #The first four control the speed of the player based on direction key
                    if event.key == pygame.K_LEFT:
                        player.changespeed(-4,0)
                        lastHit=0
                    if event.key == pygame.K_RIGHT:
                        player.changespeed(4,0)
                        lastHit=1
                    if event.key == pygame.K_UP:
                        player.changespeed(0,-3)
                    if event.key == pygame.K_DOWN:
                        player.changespeed(0,3)

                    #Checks to see if space is pressed, if it is and the number of bullets in the direct is not
                    #already maxed out will shoot a bullet in the last direction pikachu was facing
                    if event.key == pygame.K_SPACE:
                        bullet=Bullet()
                        if lastHit==1:
                            bullet.speed=(5+(player.x_speed/2.0))
                            bullet.rect.x = player.rect.x+player.rect.width
                            bullet.rect.y = player.rect.y+(player.rect.height/4)+2
                            if len(bulletListRight)<5:
                                all_sprites_list.add(bullet)
                                bulletListRight.add(bullet)
                        else:
                            bullet.speed=(-5+(player.x_speed/2.0))
                            bullet.rect.x = player.rect.x-10
                            bullet.rect.y = player.rect.y+(player.rect.height/2)
                            if len(bulletListLeft)<5:
                                all_sprites_list.add(bullet)
                                bulletListLeft.add(bullet)
                    #Test code to check if zubats are working, or code if you just want to make the current level
                    #harder it will just add more zubats at a random point on the screen
                    if event.key == pygame.K_LALT:
                        z=Zubat()
                        z.rect.x = random.randrange(screen_width)
                        z.rect.y = random.randrange(screen_height)
                        zubats.add(z)
                        all_sprites_list.add(z)



                # Reset speed of pikachu when key is released
                if event.type == pygame.KEYUP:
                    if event.key == pygame.K_LEFT:
                        player.changespeed(4,0)
                    if event.key == pygame.K_RIGHT:
                        player.changespeed(-4,0)
                    if event.key == pygame.K_UP:
                        player.changespeed(0,3)
                    if event.key == pygame.K_DOWN:
                        player.changespeed(0,-3)
                    #checks to see if the game is paused or not and then does
                    #the oppisite, also it pauses the music while paused
                    if event.key == pygame.K_p:
                        pygame.mixer.music.pause()
                        myfont = pygame.font.Font(None, 36)
                        text = myfont.render(("Pause"), True, (180,0,16))
                        text_rect = text.get_rect()
                        textx = screen.get_width()/2 - text_rect.width/2
                        texty = screen.get_height()/2 - text_rect.height/2
                        screen.blit(text, (textx,texty))

                        pygame.display.flip()

                        while True:
                            unpause=False
                            for event in pygame.event.get():
                                if event.type == pygame.QUIT: # If user clicked close
                                    done=True # Flag that shows game is over
                                    unpause=True
                                if event.type == pygame.KEYUP:
                                    if event.key == pygame.K_p:
                                        unpause=True
                            if unpause:
                                pygame.mixer.music.unpause()
                                break
                    #Checks to see if the music is muted or unmuted then does the oppiset
                    if event.key == pygame.K_m:
                        if isMuted:
                            pygame.mixer.music.play(-1,.5)
                            isMuted=False
                        else:
                            pygame.mixer.music.stop()
                            isMuted=True

            #Spawns new zubats if the number of zubats is under the level max
            if(numOfZubats<maxZubatsPerLevel):
                currentTime=time.clock()-oldTime
                #Checks to see if the wait time was passed if it was will spawn a zubat on the edge of the screen
                if(currentTime>waitTime):
                    #sets the old time to the current time on the clock
                    oldTime=time.clock()
                    z=Zubat()
                    #decides what side of the screen to spawn from
                    temp=random.randrange(2)
                    if(temp==0):
                        z.rect.x=0-z.rect.width
                        z.rect.y = random.randrange(screen_height)
                    else:
                        z.rect.x=screen_width
                        z.rect.y = random.randrange(screen_height)
                    zubats.add(z)
                    all_sprites_list.add(z)
                    numOfZubats+=1
            #Checks the position of Pikachu, when Pikachu goes
            #off the screen he will loop around to the opposite end of the screen
            for player in playerList:
                if(player.rect.x <0-player.rect.width):
                    player.rect.x=screen_width
                if(player.rect.x >screen_width):
                    player.rect.x=0-player.rect.width
                if(player.rect.y < 0-player.rect.height):
                    player.rect.y = screen_height
                if(player.rect.y > screen_height):
                    player.rect.y=0-player.rect.height


            #Loops through zubat to move them and check if they hit pikachu or get hit by a lightning bolt
            for zubat in zubats:
                #checks the x postion of zubat and pikachu and moves zubat towards pikachu
                #also sets the speed which is used to flip the zubat picture opsite direction
                if(zubat.rect.x+(zubat.rect.width/2)>player.rect.x+(player.rect.width/2)):
                    zubat.rect.x-=2
                    zubat.speed=-1
                elif(zubat.rect.x+(zubat.rect.width/2)<player.rect.x+(player.rect.width/2)):
                    zubat.rect.x+=2
                    zubat.speed=1
                #checks the y postion of zubat and pikachu and moves zubat towards pikachu
                if(zubat.rect.y+(zubat.rect.height/2)>player.rect.y+(player.rect.height/2)):
                    zubat.rect.y-=1
                elif(zubat.rect.y+(zubat.rect.height/2)<player.rect.y+(player.rect.height/2)):
                    zubat.rect.y+=1
                #Checks to see if zubat kills(hit) pikachu
                if(pygame.sprite.collide_circle(player,zubat)):
                        #empyt the sprites list so nothing is on the screen
                        all_sprites_list.empty()
                        endGame()
                        done=True
                #These two loops checks to see if a zubat is hit by a bullet going either direction
                for bullet in bulletListRight:
                    if pygame.sprite.collide_rect(bullet,zubat):
                        bulletListRight.remove(bullet)
                        zubats.remove(zubat)
                        all_sprites_list.remove(bullet)
                        all_sprites_list.remove(zubat)
                        score=random.randrange(75,125)
                        player.pikaScore+=score
                for bullet in bulletListLeft:
                    if pygame.sprite.collide_rect(bullet,zubat):
                        bulletListLeft.remove(bullet)
                        zubats.remove(zubat)
                        all_sprites_list.remove(bullet)
                        all_sprites_list.remove(zubat)
                        score=random.randrange(75,125)
                        player.pikaScore+=score
                #Calls the update to move them and check to see if the picture needs flipping
                zubat.selectPicture()
            #These two for loops move the bullets o
            for bullet in bulletListRight:
                bullet.rect.x += bullet.speed
                if bullet.rect.x > screen_width:
                        bulletListRight.remove(bullet)

            for bullet in bulletListLeft:
                bullet.rect.x += bullet.speed
                if bullet.rect.x < 0-(bullet.rect.width):
                    bulletListLeft.remove(bullet)

            # Clear the screen
            screen.fill((0,0,0))
            player.selectPicture()
            backgroundPlain.draw(screen)
            # Draw all the spites
            all_sprites_list.draw(screen)

            # Limit to 20 frames per second
            clock.tick(20)

            # Updates Screen.
            pygame.display.flip()
            if(len(zubats)==0 and numOfZubats==maxZubatsPerLevel):
                break
        if(done==True):
            break
        else:
            player.level+=1

    pygame.quit()
Пример #45
0
    def updateEvents(self):
        
        #movement
        if self.event1 == True:
            #stop from leaving window
            #left edge
            if self.rect.left > 0:
                self.rect.x += self.xspeed
            elif self.xspeed < 0:
                self.stopX()
                self.rect.left = 0
            #right edge
            if self.rect.right < WINDOWWIDTH:
                self.rect.x += self.xspeed
            elif self.xspeed > 0:
                self.stopX()
                self.rect.right = WINDOWWIDTH
            #top edge
            if self.rect.top > 0:
                self.rect.y += self.yspeed
            elif self.yspeed < 0:
                self.stopY()
                self.rect.top = 0
            #bottom edge
            if self.rect.bottom < WINDOWHEIGHT:
                self.rect.y += self.yspeed
            elif self.yspeed > 0:
                self.stopY()
                self.rect.bottom = WINDOWHEIGHT
                
        #shooting (lvl 3)
        if self.event2 == True:
            #shoot a bullet
            if self.timer == 0:
                self.timer += 1
                bullet = Bullet(BLACK, 4, 8)
                bullet.convertToPic(BULLET_DGREY, 1)
                bullet.load(self, self.bullets)
                bullet.aim(90, 1)
                bullet.fire(18)

        #sprayer (lvl 2)
        if self.event3 == True:
            if self.timer == 0:
                self.timer += 1
                flame = FlameV2(YELLOW, 6, 6, 24, 24)
                flame.load(self, self.bullets, 'N')
                flame.aim(90, 30)
                flame.fire(5)
                flame.wiggle = True #--1
                flame = FlameV2(YELLOW, 6, 6, 24, 24)
                flame.load(self, self.bullets, 'N')
                flame.aim(100, 30)
                flame.fire(5)       #--2
                flame = FlameV2(YELLOW, 6, 6, 24, 24)
                flame.load(self, self.bullets, 'N')
                flame.aim(80, 30)
                flame.fire(5)       #--3
                flame = FlameV2(YELLOW, 6, 6, 24, 24)
                flame.load(self, self.bullets, 'N')
                flame.aim(95, 15)
                flame.fire(5)
                flame.wiggle = True #--4
                flame = FlameV2(YELLOW, 6, 6, 24, 24)
                flame.load(self, self.bullets, 'N')
                flame.aim(85, 15)
                flame.fire(5)
                flame.wiggle = True #--5

        #missile (lvl 2)
        if self.event4 == True:
            if self.timer == 0:
                self.timer += 1
                missile = MissileV3(windowSurface, MISSLE_BASIC, -90)
                missile.setUpdateGroup( self.bullets )
                self.bullets.add( missile )
                missile.setCenter(self.rect.center)
                missile.setDir( random.randint(87,93) )
                missile.setSpeed( random.randint(300,500)/100 )
                missile.setTrailStrength(1)

        #sprayer (lvl 3)
        if self.event5 == True:
            if self.timer == 0:
                self.timer += 1
                #shoot 5 different bullets
                side = random.randint(8,10)
                bullet = Bullet(DDBLUE, side,side)
                bullet.load(self, self.bullets)
                bullet.aim(90, 5)
                bullet.yaccel = 0.35
                bullet.special_01()
                bullet.fire(random.randint(10,14)) #--1
                side = random.randint(8,10)
                bullet = Bullet(DDBLUE, side,side)
                bullet.load(self, self.bullets)
                bullet.aim(87, 4)
                bullet.yaccel = 0.35
                bullet.special_01()
                bullet.fire(random.randint(10,14)) #--2
                side = random.randint(8,10)
                bullet = Bullet(DDBLUE, side,side)
                bullet.load(self, self.bullets)
                bullet.aim(83, 3)
                bullet.yaccel = 0.35
                bullet.special_01()
                bullet.fire(random.randint(10,14)) #--3
                side = random.randint(8,10)
                bullet = Bullet(DDBLUE, side,side)
                bullet.load(self, self.bullets)
                bullet.aim(93, 4)
                bullet.yaccel = 0.35
                bullet.special_01()
                bullet.fire(random.randint(10,14)) #--4
                side = random.randint(8,10)
                bullet = Bullet(DDBLUE, side,side)
                bullet.load(self, self.bullets)
                bullet.aim(97, 3)
                bullet.yaccel = 0.35
                bullet.special_01()
                bullet.fire(random.randint(10,14)) #--5

        #update target group for current minion
        if self.currMinion == None and self.baddies != None:
            self.currMinion.setTargetGroup(self.baddies)
Пример #46
0
    def shoot(self, bullets, baddies, fps):
        
        #    fyi...
        # Assuming fps=60 for comments mentioning
        # how long the alarm is set for.
        
        #shooter
        if self.selected == 0:
            
            #locked
            if self.unlocked[0] == 0:
                print("Warning: shooter is not unlocked yet")
                return -1
            
            #lvl 1
            elif self.unlocked[0] == 1:
                #allow a shot every 1/4 sec
                self.alarm = int(fps/4)
                #shoot a bullet
                if self.timer == 0:
                    self.timer += 1
                    bullet = Bullet(DGREY, 4, 8)
                    bullet.convertToPic(BULLET_LGREY, 1)
                    bullet.load(self, bullets)
                    bullet.aim(90, 5)
                    bullet.fire(6)

            #lvl 2
            elif self.unlocked[0] == 2:
                #allow a shot every 1/fps sec
                self.alarm = 1
                #shoot a bullet
                if self.timer == 0:
                    self.timer += 1
                    bullet = Bullet(DDGREY, 4, 8)
                    bullet.convertToPic(BULLET_GREY, 1)
                    bullet.load(self, bullets)
                    bullet.aim(90, 10)
                    bullet.fire(10)

            #lvl 3
            elif self.unlocked[0] == 3:
                #update bullet group for self
                self.bullets = bullets
                #allow a shot every 1/30 sec
                self.alarm = int(fps/30)
                #allow holding down to keep shooting
                self.event2 = True

            else:
                print("Error: player is trying to shoot with an incorrect upgrade selection")
                return -2
            
        #missile
        elif self.selected == 1:
            
            #locked
            if self.unlocked[1] == 0:
                print("Warning: missile is not unlocked yet")
                return -1
            
            #lvl 1
            elif self.unlocked[1] == 1:
                #allow a shot every 1 sec
                self.alarm = int(fps)
                #shoot a missile
                if self.timer == 0:
                    self.timer += 1
                    missile = MissileV3(windowSurface, MISSLE_BASIC, -90)
                    missile.setUpdateGroup( bullets )
                    bullets.add( missile )
                    missile.setCenter(self.rect.center)
                    missile.setDir( random.randint(87,93) )
                    missile.setSpeed( random.randint(300,500)/100 )
                    missile.setTrailStrength(1)
                    
            #lvl 2
            elif self.unlocked[1] == 2:
                #update bullet group for self
                self.bullets = bullets
                #allow a shot every 1/2 sec
                self.alarm = int(fps/2)
                #allow holding down to keep launching
                self.event4 = True

            #lvl 3
            elif self.unlocked[1] == 3:
                #allow a small missile every 1 sec
                self.alarm = int(fps*1)

                #25% chance for a large missile
                # ...
                #shoot 3 missiles
                if self.timer == 0:
                    self.timer += 1

                    #seeking bounds
                    bounds = [0,WINDOWWIDTH,self.rect.y,0]

                    special = random.randint(1,4)
                    if special == 1:
                        # 1 big seek missile
                        missile = MissileV3(windowSurface, MISSLE_HEAVY, -90)
                        missile.setUpdateGroup( bullets )
                        bullets.add( missile )
                        missile.setCenter(self.rect.center)
                        missile.setDir( 90 )
                        missile.setSpeed( random.randint(200,400)/100 )
                        missile.seek(baddies, 2, bounds)
                        missile.setTrailStrength(2)

                    # 2 small seek missiles
                    missile = MissileV3(windowSurface, MISSLE_BASIC, -90)
                    missile.setUpdateGroup( bullets )
                    bullets.add( missile )
                    missile.setCenter(self.rect.center)
                    missile.setDir( random.randint(82,88) )
                    missile.setSpeed( random.randint(400,600)/100 )
                    missile.seek(baddies, 5, bounds)
                    missile.setTrailStrength(0)
                    
                    missile = MissileV3(windowSurface, MISSLE_BASIC, -90)
                    missile.setUpdateGroup( bullets )
                    bullets.add( missile )
                    missile.setCenter(self.rect.center)
                    missile.setDir( random.randint(92,98) )
                    missile.setSpeed( random.randint(400,600)/100 )
                    missile.seek(baddies, 5, bounds)
                    missile.setTrailStrength(0)

            else:
                print("Error: player is trying to shoot with an incorrect upgrade selection")
                return -2
            
        #sprayer
        elif self.selected == 2:

            #locked
            if self.unlocked[2] == 0:
                print("Warning: sprayer is not unlocked yet")
                return -1
            
            #lvl 1
            elif self.unlocked[2] == 1:
                #allow a shot every 1 sec
                self.alarm = int(fps)
                #shoot 3 bullets, 4 fragments
                if self.timer == 0:
                    self.timer += 1
                    bullet = Bullet(DDGREY, 7, 7)
                    bullet.load(self, bullets)
                    bullet.aim(90, 4)
                    bullet.fire(16) #--1
                    bullet = Bullet(DDGREY, 7, 7)
                    bullet.load(self, bullets)
                    bullet.aim(95, 6)
                    bullet.fire(15) #--2
                    bullet = Bullet(DDGREY, 7, 7)
                    bullet.load(self, bullets)
                    bullet.aim(85, 6)
                    bullet.fire(15) #--3

            #lvl 2
            elif self.unlocked[2] == 2:
                #update bullet group for self
                self.bullets = bullets
                #allow a shot every 1/10 sec
                self.alarm = int(fps/10)
                #allow holding down to keep shooting
                self.event5 = True

            #lvl 3
            elif self.unlocked[2] == 3:
                #update bullet group for self
                self.bullets = bullets
                #allow a shot every 1/15 sec
                self.alarm = int(fps/15)
                #allow holding down to keep shooting
                self.event3 = True

            else:
                print("Error: player is trying to shoot with an incorrect upgrade selection")
                return -2
            
        #minions
        elif self.selected == 3:
            
            #locked
            if self.unlocked[3] == 0:
                print("Warning: minions are not unlocked yet")
                return -1
            
            #lvl 1
            elif self.unlocked[3] == 1:
                #allow a shot every 0.5 sec
                self.alarm = int(fps/2)
                    
                #create a random suicide minion
                if self.timer == 0:
                    self.timer += 1
                    suiciders = [MINION_1,MINION_2,MINION_3]
                    minion = Minion(windowSurface, random.choice(suiciders), -90)
                    minion.init()

                    #place minion randomly in front of self
                    # N,E,S,W
                    bounds = [self.rect.centery-80,self.rect.centerx+50,self.rect.y-10,self.rect.centerx-50]
                    cx = random.randint(bounds[3],bounds[1])
                    cy = random.randint(bounds[0],bounds[2])
                    minion.setCenter( (cx,cy) )
                    
                    #set type, update group, target group
                    minion.type = 1
                    minion.setUpdateGroup(bullets)
                    minion.setTargetGroup(baddies)

                    #load minion into update group
                    bullets.add(minion)

                    #set current minion
                    self.currMinion = minion

            #lvl 2
            elif self.unlocked[3] == 2:
                #allow a shot every 1/6 sec
                self.alarm = int(fps/6)

                #create a shooter minion
                if self.timer == 0:
                    self.timer += 1

                    #only if fewer than 2 shooter-minions are alive
                    if len(self.pop2) < 2:

                        # bounds: N,E,S,W
                        bounds = [self.rect.centery-35,self.rect.centerx+50,self.rect.y+15,self.rect.centerx-50]
                        cx = random.randint(bounds[3],bounds[1])
                        cy = random.randint(bounds[0],bounds[2])
                        
                        #pick a side this minion will be on (right/left)
                        if cx >= WINDOWWIDTH/2:
                            pic = MINION_4 #right
                            side = 1
                        else:
                            pic = MINION_5 #left
                            side = 2

                        #create a shooter minion
                        minion = Minion(windowSurface, pic, -90)
                        minion.init()
                        minion.side = side

                        #place minion randomly in front of self
                        minion.setCenter( (cx,cy) )
                        
                        #set type, alarm, update group, target group
                        minion.type = 2
                        minion.alarm = 60*2
                        minion.setUpdateGroup(bullets)
                        minion.setTargetGroup(baddies)

                        #load minion into update group, pop2
                        bullets.add(minion)
                        self.pop2.append(minion)

                        #set current minion
                        self.currMinion = minion

            #lvl 3
            elif self.unlocked[3] == 3:
                #allow a shot every 0.25 sec
                self.alarm = int(fps/4)

                #create an army minion
                if self.timer == 0:
                    self.timer += 1

                    #only if fewer than 8 army-minions are alive
                    if len(self.pop3) < 8:

                        #create a random army minion
                        armies = { 1 : ARMY_1,   #flames
                                   2 : ARMY_2,   #missiles
                                   3 : ARMY_3 }  #lasers
                        choice = random.randint(1,3)
                        minion = Minion(windowSurface, armies[choice], -90)
                        minion.init()

                        # bounds: N,E,S,W
                        bounds = [self.rect.centery-35,self.rect.centerx+50,self.rect.y+15,self.rect.centerx-50]
                        cx = random.randint(bounds[3],bounds[1])
                        cy = random.randint(bounds[0],bounds[2])

                        #place minion randomly in front of self
                        minion.setCenter( (cx,cy) )
                        
                        #set type, health, subtype, alarm, update group, target group, dir
                        minion.type = 3
                        minion.health = 40
                        if choice == 1:
                            minion.alarm = 60/6
                            minion.subtype = "red"
                        elif choice == 2:
                            minion.alarm = 60*2
                            minion.subtype = "blue"
                        elif choice == 3:
                            minion.alarm = 60/3
                            minion.subtype = "green"
                        minion.setUpdateGroup(bullets)
                        minion.setTargetGroup(baddies)
                        minion.setDir(90)

                        #load minion into update group, pop3
                        bullets.add(minion)
                        self.pop3.append(minion)

                        #set current minion
                        self.currMinion = minion

            else:
                print("Error: player is trying to shoot with an incorrect upgrade selection")
                return -2
        
        #bombs (NOTE*** attractor and reflector do not attract/reflect enemies)
        elif self.selected == 4:

            #locked
            if self.unlocked[4] == 0:
                print("Warning: bombs are not unlocked yet")
                return -1
            
            #lvl 1
            elif self.unlocked[4] == 1:
                #allow a shot every 1/2 sec
                self.alarm = int(fps/2)
                #throws 1 bomb
                if self.timer == 0:
                    self.timer += 1
                    bomb = Bomb(windowSurface, BOMB_SMALL)
                    bomb.initVars()
                    bomb.setCenter(self.rect.center)
                    bomb.setUpdateGroup(bullets)
                    bomb.setDensity(15)
                    bomb.setSmoke(5)
                    bomb.setAmt(10)
                    bullets.add(bomb)
                    bomb.dir = random.randint(60, 120)
                    bomb.speed = random.randint(115,190)/10
                    bomb.accel = -random.randint(5,7)/10

            #lvl 2
            elif self.unlocked[4] == 2:
                #allow a shot every 2 sec
                self.alarm = int(fps*2)
                #throws 1 reflector
                if self.timer == 0:
                    self.timer += 1
                    bomb = Bomb(windowSurface, BOMB_REFLECT)
                    bomb.initVars()
                    bomb.setCenter(self.rect.center)
                    bomb.setUpdateGroup(bullets)
                    bullets.add(bomb)
                    bomb.dir = 90
                    bomb.speed = 2
                    bomb.setReflect(0.8)

            #lvl 3
            elif self.unlocked[4] == 3:
                #allow a shot every 4 sec
                self.alarm = int(fps*4)
                #throws 1 attractor
                if self.timer == 0:
                    self.timer += 1

                    #seeking bounds
                    bounds = [0,WINDOWWIDTH,self.rect.y,0]

                    #attractor (also launches missiles)
                    bomb = Bomb(windowSurface, BOMB_ATTRACT)
                    bomb.initVars()
                    bomb.setCenter(self.rect.center)
                    bomb.setUpdateGroup(bullets)
                    bullets.add(bomb)
                    bomb.dir = 90
                    bomb.speed = 2
                    bomb.setAttract(0.7, baddies, bounds)

            else:
                print("Error: player is trying to shoot with an incorrect upgrade selection")
                return -2
            
        #error
        else:
            print("Error: player is trying to shoot with an incorrect weapon selection")
            return -2

        #if all goes well, return 0
        return 0
Пример #47
0
class PlayerBike(DirectObject):
    def __init__(self, cTrav):
        #create speed vars
        self.max_vel = 35
        self.accel = 2
        self.current_vel = 0
        self.cTrav = cTrav
        self.weapon = 0
        
        #vars for jumping
        self.tempHeading = 0
        self.temp_vel = 0
        self.count = 0
        self.first_time = False
        self.jump = False
        self.dz = 0
        
        #set HP
        self.hp = 10
        
        #invincible check
        self.invin = False
        self.invinCount = 0
        
        #Shotgun check
        self.shotgun = False
        self.p_up_timer = 0
        
        #healing powerup
        self.health_up = False
        
        #load all sound files
        self.singleShot = base.loader.loadSfx('M4A1.mp3')
        
        
        #create empty list for bullets and a task for updating the positions
        self.bullet = Bullet(cTrav)
        self.spreadshot = weapon1(cTrav)
        self.explode = weapon2(cTrav)
        self.wallshot = weapon3(cTrav)
        
        taskMgr.add(self.bullet.update, "bulletTask")
        taskMgr.add(self.spreadshot.update, "bulletTask")
        taskMgr.add(self.updatePowerup, "powerupTask")

    
        
        #load the bike actor and parent it to a physics node
        self.bike = Actor("moto2_actor.egg", {"move":"moto2_moveAnim.egg", "turnL":"moto2_blahblah.egg"})
        #self.bike.setScale(.5)
        #self.bike.setH(180)
        self.bike.reparentTo(render)
        
        self.dummy = Actor("temp_bullet.egg")
        self.dummy.reparentTo(render)
        
        #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}
        
        #setup a shoot check
        self.shootCheck = 0
        

        #setup a wall collision check
        self.wallCheck = False
        
        #pusher collision spheres
        #front
        collisionPusher = CollisionHandlerPusher()
        collisionPusher.setInPattern("p_bike-%in")
        cPushSphere = CollisionSphere((0,3.5,2),2)
        
        cNode1 = CollisionNode("p_bike_push")
        cNode1.addSolid(cPushSphere)
        cNode1.setIntoCollideMask(0x10)
        cNode1.setFromCollideMask(0x1)
        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("p_bike_push")
        cNode2.addSolid(cPushSphere)
        cNode2.setIntoCollideMask(0x10)
        cNode2.setFromCollideMask(0x1)
        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("p_bike_push")
        cNode3.addSolid(cPushSphere)
        cNode3.setIntoCollideMask(0x10)
        cNode3.setFromCollideMask(0x1)
        self.cNodePath3 = self.bike.attachNewNode(cNode3)
        
        #self.cNodePath3.show()
        
        collisionPusher.addCollider(self.cNodePath3, self.bike)
        self.cTrav.addCollider(self.cNodePath3, collisionPusher)
        
        #collision rays for faux-gravity
        #front wheel
        lifter = CollisionHandlerFloor()
        lifter.setMaxVelocity(9.8)
        
        cRay1 = CollisionRay(0, 3, 3, 0, 0, -1)
        cRayNode1 = CollisionNode('playerRay')
        cRayNode1.addSolid(cRay1)
        cRayNode1.setIntoCollideMask(BitMask32.allOff())
        cRayNode1.setFromCollideMask(2)
        cRayNodePath1 = self.bike.attachNewNode(cRayNode1)
        #cRayNodePath1.show()
         
        self.cTrav.addCollider(cRayNodePath1, lifter)
        lifter.addCollider(cRayNodePath1, self.bike)
        
        #setup and parent spotlights to the player
        self.spotlight = Spotlight("headlight")
        self.spotlight.setColor((1, 1, 1, 1))
        self.spotlight.setAttenuation(Point3(0,0,.001))
        lens = PerspectiveLens()
        #can change size of cone
        lens.setFov(20)
        self.spotlight.setLens(lens)
        self.spotlight.setExponent(100)
        lightNode = self.bike.attachNewNode(self.spotlight)
        render.setLight(lightNode)
        
    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, task):
        #check if space bar is pressed
        if self.shootCheck:

            #Check which weapon is being used
            #standard weapon
            if self.weapon == 0:
                #check if able to shoot
                if self.shotClock >= 25:
                    #print("Shooting a bullet!")
                    self.singleShot.play()
                    self.bullet.createBullet(self.bike)
                    self.shotClock = 0
                else:
                    self.shotClock += 1
            #Weapon 2 - Spreadshot/Shotgun
            elif self.weapon == 1:
                if self.shotClock >= 40:
                    #print("Shooting a bullet!")
                    self.singleShot.play()
                    self.spreadshot.createBullet(self.bike)
                    self.shotClock = 0
                else:
                    self.shotClock += 1 

        else:
            self.shotClock += 1
        return Task.cont
    
    def updatePowerup(self, task):
        #check powerup timers
        if self.invin == True:
            self.invinCount += 1
            #print self.invinCount 
        if self.invinCount == 400:
            self.invin = False
            self.invinCount = 0
        if self.shotgun == True:
            self.weapon = 1
            self.p_up_timer += 1
            #print self.p_up_timer
        if self.p_up_timer == 500:
            self.shotgun = False
            self.weapon = 0
        if self.health_up == True:
            self.hp += 2
            if self.hp > 10:
                self.hp = 10
            self.health_up = False
        return Task.cont
    def move(self, task):
        elapsed = task.time - self.prevTime
        
        self.dummy.setPos(self.bike.getX(), self.bike.getY(), 0.0)
        
        #keep track of all the bike's previous Pos and Hpr
        prevX = self.bike.getX()
        prevY = self.bike.getY()
        prevZ = self.bike.getZ()
        prevH = self.bike.getH()
        prevP = self.bike.getP()
        prevR = self.bike.getR()
        
        #check key map
        
        #check if at jump height
        if prevZ >= 2.00:
            #set jump check
            self.jump = True
            
            #check for when temp_vel needs to be increased instead of decreased
            if self.first_time == False:
                self.temp_vel -= 9.8
            if self.temp_vel <= 0 and self.first_time == False:
                self.first_time = True
                self.temp_vel += 9.8
            elif self.first_time == True:
                self.temp_vel += 9.8
                
            #make sure temp_vel doesn't increase too much
            if self.temp_vel > self.current_vel:
                self.temp_vel = self.current_vel
                
            #calculate dist for dy and dx normally, then do trig for dz
            dist = (self.current_vel + 11) * elapsed
            angle = deg2Rad(self.bike.getH())
            dy = dist * -math.cos(angle)
            dx = dist * math.sin(angle)
            self.dz = math.sqrt((dy*dy)+(dx*dx))
            
            #debug prints
            """print('new')
            print('dy', dy)
            print('dx', dx)
            print('dz', dz)
            print('angle', angle)
            print('bike heading', self.bike.getH())
            print('bike x', self.bike.getX())
            print('bike y', self.bike.getY())
            print('temp_vel', self.temp_vel)"""
            
            #use a count to determine when to decrease or increase the bike's Z
            if self.count < 30:
                self.bike.setPos(self.bike.getX() - dx, self.bike.getY() - dy, self.bike.getZ() + self.dz)
            else:
                self.bike.setPos(self.bike.getX() - dx, self.bike.getY() - dy, self.bike.getZ() - self.dz)
            self.count += 1
            
        else:
            #reset counters used in jumping
            self.first_time = False
            self.count = 0
            
            #check if turning
            if self.moveMap['left']:
                self.bike.setH(self.bike.getH() + elapsed * 150)
            if self.moveMap['right']:
                self.bike.setH(self.bike.getH() - elapsed * 150)
                
            #check keymap for forward motion
            #accelerate
            if self.moveMap['forward']:
                #print(prevZ)
                self.current_vel += self.accel
                self.temp_vel = self.current_vel
                if(self.current_vel > self.max_vel):
                    self.current_vel = self.max_vel
                dist = self.current_vel * elapsed
                angle = deg2Rad(self.bike.getH())
                dx = dist * math.sin(angle)
                dy = dist * -math.cos(angle)
                if self.jump == True:
                    self.bike.setPos(self.bike.getX() - dx, self.bike.getY() - dy, self.bike.getZ() - self.dz)
                    if self.bike.getZ() <= 0:
                        self.jump = False
                        self.bike.setZ(0)
                else:
                    self.bike.setPos(self.bike.getX() - dx, self.bike.getY() - dy, self.bike.getZ())
                
                
            else:
                #decelerate
                self.current_vel -= 20 * self.accel * elapsed
                self.temp_vel = self.current_vel
                if(self.current_vel < 0):
                    self.current_vel = 0
                dist = self.current_vel * elapsed
                angle = deg2Rad(self.bike.getH())
                dx = dist * math.sin(angle)
                dy = dist * -math.cos(angle)
                if self.jump == True:
                    self.bike.setPos(self.bike.getX() - dx, self.bike.getY() - dy, self.bike.getZ() - self.dz)
                    if self.bike.getZ() <= 0:
                        self.jump = False
                        self.bike.setZ(0)
                else:
                    self.bike.setPos(self.bike.getX() - dx, self.bike.getY() - dy, self.bike.getZ())
        
        #attempt to change pitch
        if self.bike.getZ() != prevZ:
            ang = math.atan2(self.bike.getY(), self.bike.getZ())
            self.bike.setP(ang)
            
        if self.moveMap['left'] or self.moveMap['right'] or self.moveMap['forward']:
            #print('heading', self.bike.getH())
            if self.isMoving == False:
                self.isMoving = True
                self.bike.loop("move")
        else:
            if self.isMoving:
                self.isMoving = False
                self.bike.stop()
                #self.bike.pose("walk", 4)
        
        self.prevTime = task.time
        #print(self.current_vel)
        return Task.cont
        
Пример #48
0
    def __init__(self, cTrav):
        #create speed vars
        self.max_vel = 35
        self.accel = 2
        self.current_vel = 0
        self.cTrav = cTrav
        self.weapon = 0
        
        #vars for jumping
        self.tempHeading = 0
        self.temp_vel = 0
        self.count = 0
        self.first_time = False
        self.jump = False
        self.dz = 0
        
        #set HP
        self.hp = 10
        
        #invincible check
        self.invin = False
        self.invinCount = 0
        
        #Shotgun check
        self.shotgun = False
        self.p_up_timer = 0
        
        #healing powerup
        self.health_up = False
        
        #load all sound files
        self.singleShot = base.loader.loadSfx('M4A1.mp3')
        
        
        #create empty list for bullets and a task for updating the positions
        self.bullet = Bullet(cTrav)
        self.spreadshot = weapon1(cTrav)
        self.explode = weapon2(cTrav)
        self.wallshot = weapon3(cTrav)
        
        taskMgr.add(self.bullet.update, "bulletTask")
        taskMgr.add(self.spreadshot.update, "bulletTask")
        taskMgr.add(self.updatePowerup, "powerupTask")

    
        
        #load the bike actor and parent it to a physics node
        self.bike = Actor("moto2_actor.egg", {"move":"moto2_moveAnim.egg", "turnL":"moto2_blahblah.egg"})
        #self.bike.setScale(.5)
        #self.bike.setH(180)
        self.bike.reparentTo(render)
        
        self.dummy = Actor("temp_bullet.egg")
        self.dummy.reparentTo(render)
        
        #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}
        
        #setup a shoot check
        self.shootCheck = 0
        

        #setup a wall collision check
        self.wallCheck = False
        
        #pusher collision spheres
        #front
        collisionPusher = CollisionHandlerPusher()
        collisionPusher.setInPattern("p_bike-%in")
        cPushSphere = CollisionSphere((0,3.5,2),2)
        
        cNode1 = CollisionNode("p_bike_push")
        cNode1.addSolid(cPushSphere)
        cNode1.setIntoCollideMask(0x10)
        cNode1.setFromCollideMask(0x1)
        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("p_bike_push")
        cNode2.addSolid(cPushSphere)
        cNode2.setIntoCollideMask(0x10)
        cNode2.setFromCollideMask(0x1)
        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("p_bike_push")
        cNode3.addSolid(cPushSphere)
        cNode3.setIntoCollideMask(0x10)
        cNode3.setFromCollideMask(0x1)
        self.cNodePath3 = self.bike.attachNewNode(cNode3)
        
        #self.cNodePath3.show()
        
        collisionPusher.addCollider(self.cNodePath3, self.bike)
        self.cTrav.addCollider(self.cNodePath3, collisionPusher)
        
        #collision rays for faux-gravity
        #front wheel
        lifter = CollisionHandlerFloor()
        lifter.setMaxVelocity(9.8)
        
        cRay1 = CollisionRay(0, 3, 3, 0, 0, -1)
        cRayNode1 = CollisionNode('playerRay')
        cRayNode1.addSolid(cRay1)
        cRayNode1.setIntoCollideMask(BitMask32.allOff())
        cRayNode1.setFromCollideMask(2)
        cRayNodePath1 = self.bike.attachNewNode(cRayNode1)
        #cRayNodePath1.show()
         
        self.cTrav.addCollider(cRayNodePath1, lifter)
        lifter.addCollider(cRayNodePath1, self.bike)
        
        #setup and parent spotlights to the player
        self.spotlight = Spotlight("headlight")
        self.spotlight.setColor((1, 1, 1, 1))
        self.spotlight.setAttenuation(Point3(0,0,.001))
        lens = PerspectiveLens()
        #can change size of cone
        lens.setFov(20)
        self.spotlight.setLens(lens)
        self.spotlight.setExponent(100)
        lightNode = self.bike.attachNewNode(self.spotlight)
        render.setLight(lightNode)
Пример #49
0
 def fireBullet(self):
     self.newBullet = Bullet("Bullets.gif",self.upperLeft.x + (self.get_width() / 2), self.upperLeft.y + (self.get_height() / 2), 30, 30, 3, 3, self.crosshair)
     self.newBullet.set_animation_frame(6)
     self.gun.addBullet(self.newBullet)
     self.attackFlag = moveDirection.ATTACK
     self.delay = 1
Пример #50
0
class Character(SpriteClass):
    def __init__(self, filename, x, y, width, height, columns, rows, xVelocity = 1, yVelocity = 1):
        SpriteClass.__init__(self, filename,x, y, width, height, columns, rows)
        self.characterModel = filename
        self.keyLeft = pygame.K_a
        self.keyRight = pygame.K_d
        self.keyUp = pygame.K_w
        self.keyDown = pygame.K_s
        self.keySpace = pygame.K_SPACE
        self.width = self.get_width()
        self.height = self.get_height()
        self.velocity = Point2D(xVelocity, yVelocity)
        self.keyboard = pygame.key.get_pressed()
        self.animationSwitchUpDown = False
        self.animationSwitchLeftRight = False
        self.isAlive = True    
        self.playerDirection = moveDirection.NULL
        self.attackFlag = moveDirection.NULL
        self.gun = Gun(True)
        self.newBullet = None
        self.leftMouseClick = (1,0,0)
        self.delay = 0
        self.firingRate = 10
        self.health = 100
        self.score = 0
        ###
        #variables for timer
        ###
        self.timer = 0 #timer to reset the path
        self.timingFlag = False #flag to set to make the path reset after the timer
        self.delay = 1000 #1 second
        self.setUpCrossHair()

    def damage(self, amount = 20):
        if self.health > 0:
            self.health -= amount
            
    def setUpSprite(self):
        self.set_image_color_key(255, 0, 255)
        self.set_animation_delay(500)
        self.play(True)  
            
    def moveUp(self):
        self.upperLeft.y  -= self.velocity.y
        self.updateLowerRight()
        
    def moveDown(self):
        self.upperLeft.y  += self.velocity.y
        self.updateLowerRight()
        
    def moveLeft(self):
        self.upperLeft.x  -= self.velocity.x
        self.updateLowerRight()
        
    def moveRight(self):
        self.upperLeft.x  += self.velocity.x
        self.updateLowerRight()
        

    def handleUpActions(self):
        self.set_animation_range(12, 16)
        self.moveUp()
        if(self.animationSwitchUpDown == False):
            self.set_animation_frame(12)
            self.animationSwitchUpDown = True
    
    def handleDownActions(self):
        self.set_animation_range(0, 4)
        self.moveDown()
        if(self.animationSwitchUpDown == False):
            self.set_animation_frame(0)
            self.animationSwitchUpDown = True
            
    def handleLeftActions(self):
        self.set_animation_range(4, 8)
        self.moveLeft()
        if(self.animationSwitchLeftRight == False):
            self.set_animation_frame(4)
            self.animationSwitchLeftRight = True
            
    def handleRightActions(self):
        self.set_animation_range(8, 12) 
        self.moveRight()
        if(self.animationSwitchLeftRight == False):
            self.set_animation_frame(8)  
            self.animationSwitchLeftRight = True
                    
    def handleInput(self):
        self.keyboard = pygame.key.get_pressed()
        if(self.keyboard[self.keyLeft]):
            self.handleLeftActions()
            self.playerDirection = moveDirection.LEFT
        
        elif(self.keyboard[self.keyRight]):
            self.handleRightActions()
            self.playerDirection = moveDirection.RIGHT

        if(not (self.keyboard[self.keyLeft] or self.keyboard[self.keyRight])):
            self.animationSwitchLeftRight = False
            

        if(self.keyboard[self.keyUp]):
            self.handleUpActions()
            self.playerDirection = moveDirection.UP
    
        elif(self.keyboard[self.keyDown]):
            self.handleDownActions()
            self.playerDirection = moveDirection.DOWN
            
        if(not (self.keyboard[self.keyUp] or self.keyboard[self.keyDown])):
            self.animationSwitchUpDown = False
        
        if(self.keyboard[self.keyLeft] == False) and (self.keyboard[self.keyRight] == False) and (self.keyboard[self.keyUp] == False) and (self.keyboard[self.keyDown] == False):
            self.playerDirection = moveDirection.NULL

    def setUpCrossHair(self):
        pygame.mouse.set_visible(False)
        self.crosshair = MouseCrosshair(Point2D(50,50), Point2D(30,30), "crosshair.bmp", 60, 30, 2, 1)
        self.crosshair.set_image_color_key(255, 255, 255)
        self.crosshair.set_animation_delay(200)
        self.crosshair.play(True)

    def handleAttack(self):
        if self.delay >= self.firingRate:
            self.delay = 0
        if(pygame.mouse.get_pressed() == self.leftMouseClick):
            if self.delay == 0:
                if(self.attackFlag != moveDirection.ATTACK):
                    self.fireBullet()
        else:
            self.attackFlag = moveDirection.NULL
        if self.delay != 0:
            self.delay += 1
            
    def fireBullet(self):
        self.newBullet = Bullet("Bullets.gif",self.upperLeft.x + (self.get_width() / 2), self.upperLeft.y + (self.get_height() / 2), 30, 30, 3, 3, self.crosshair)
        self.newBullet.set_animation_frame(6)
        self.gun.addBullet(self.newBullet)
        self.attackFlag = moveDirection.ATTACK
        self.delay = 1
            
            
    def checkScreenBounds(self):
        if(self.upperLeft.y <= 0):
            self.upperLeft.y = 1
        if(self.upperLeft.y + self.height >= screenHeight - 115):
            self.upperLeft.y = screenHeight - self.height - 115
        if(self.upperLeft.x <= 0):
            self.upperLeft.x = 1
        if(self.upperLeft.x + self.width >= screenWidth):
            self.upperLeft.x = screenWidth - self.width - 1
        self.updateLowerRight()
    
    def updateLowerRight(self):
        self.lowerRight.x = self.upperLeft.x + self.width
        self.lowerRight.y = self.upperLeft.y + self.height
        
    def update(self, screen, enemyList):
        if self.health > 0:
            self.handleInput()
            self.handleAttack()
            self.checkScreenBounds()
            self.gun.update(screen, enemyList)
            for enemy in enemyList:
                if(enemy.health == 0):
                    self.score += 1000
            self.crosshair.update(screen)