コード例 #1
0
    class Coin(pygame.sprite.Sprite):
        def __init__(self):
            self.animation = Animation(
                ["Sprites/coin/0.png", "Sprites/coin/1.png"], 150, True)
            self.x, self.y = 500, 330
            self.speed = 100  # PPS
            self.scale = .5

        def update(self, deltatime):
            self.animation.update(deltatime)
            self.rect = self.animation.getScaledImage(self.scale).get_rect()
            self.rect.x = self.x
            self.rect.y = self.y
            self.x -= deltatime / 1000.0 * self.speed

            # scale(Surface, (width, height), DestSurface=None) -> Surface
            self.rect.x = self.x
            self.rect.y = self.y
            self.mask = pygame.mask.from_surface(
                self.animation.getScaledImage(self.scale))

            if self.x < 0:
                self.x = (2000)

        def draw(self, screen):
            img = self.animation.getScaledImage(self.scale)
            screen.blit(
                pygame.transform.scale(img, (int(img.get_rect().width * .9),
                                             int(img.get_rect().height * .7))),
                (self.x, 330))
コード例 #2
0
 def __init__(self):
     self.animation = Animation([
         "Sprites/idle/idle_1.png", "Sprites/idle/idle_2.png",
         "Sprites/idle/idle_3.png", "Sprites/idle/idle_4.png",
         "Sprites/idle/idle_5.png", "Sprites/idle/idle_6.png"
     ], 150, True)
     self.scale = .4
     self.x, self.y = 3000, 310
     self.speed = 200  # PPS
コード例 #3
0
 def __init__(self):
     self.animation = Animation([
         'traps/robot/hit_1.png',
         'traps/robot/hit_2.png',
         'traps/robot/hit_3.png',
         'traps/robot/hit_4.png',
         'traps/robot/hit_5.png',
         'traps/robot/hit_6.png',
         'traps/robot/hit_7.png',
     ], 150, True)
     self.scale = .3
     self.x, self.y = 700, 310
     self.speed = 200  # PPS
コード例 #4
0
 def __init__(self, x, y):
     pygame.sprite.Sprite.__init__(self)
     self.image = Animation([
         "fireball/fire6.png",
         "fireball/fire7.png",
     ], 100, True)
     self.scale = .4
     self.rect = self.image.get_rect()
     self.y = y
     self.x = x
     self.speed = 8
     self.burning = True
     self.count = 0
     self.radius = self.rect.width / 2
     self.mask = pygame.mask.from_surface(
         self.image.getCurrentFrame(self.scale))
コード例 #5
0
class Fireball(pygame.sprite.Sprite, Animation):
    def __init__(self, x, y):
        pygame.sprite.Sprite.__init__(self)
        self.image = Animation([
            "fireball/fire6.png",
            "fireball/fire7.png",
        ], 100, True)
        self.scale = .4
        self.rect = self.image.get_rect()
        self.y = y
        self.x = x
        self.speed = 8
        self.burning = True
        self.count = 0
        self.radius = self.rect.width / 2
        self.mask = pygame.mask.from_surface(
            self.image.getCurrentFrame(self.scale))

    def update(self, dt):
        self.image.update(dt)
        self.rect = self.image.getCurrentFrame(self.scale).get_rect()
        self.mask = pygame.mask.from_surface(
            self.image.getCurrentFrame(self.scale))

        self.x -= self.speed
        if self.x < 0 - self.rect.width:
            self.kill()

    def draw(self, screen):
        img = self.image.getScaledImage(self.scale)
        screen.blit(img, (self.x, self.y))
コード例 #6
0
    class Snake(pygame.sprite.Sprite):
        def __init__(self):
            self.animation = Animation([
                "Sprites/idle/idle_1.png", "Sprites/idle/idle_2.png",
                "Sprites/idle/idle_3.png", "Sprites/idle/idle_4.png",
                "Sprites/idle/idle_5.png", "Sprites/idle/idle_6.png"
            ], 150, True)
            self.scale = .4
            self.x, self.y = 3000, 310
            self.speed = 200  # PPS

        def update(self, deltatime):
            self.animation.update(deltatime)
            self.rect = self.animation.getScaledImage(self.scale).get_rect()
            self.rect.x = self.x
            self.rect.y = self.y

            self.mask = pygame.mask.from_surface(
                self.animation.getScaledImage(self.scale))

            self.x -= deltatime / 1000.0 * self.speed
            if self.x < 0:
                list = [20000, 1500, 700, 5000]
                self.x = list[0 or 1 or 2 or 3]

        def draw(self, screen):
            img = self.animation.getScaledImage(self.scale)

            screen.blit(
                pygame.transform.scale(img, (int(img.get_rect().width * .9),
                                             int(img.get_rect().height * .7))),
                (self.x, self.y - 10))
            self.animation.getScaledImage(self.scale).get_rect()
コード例 #7
0
 def __init__(self, *groups):
     self.animation = Animation([
         'Sprites/Run (1).png',
         'Sprites/Run (2).png',
         'Sprites/Run (3).png',
         'Sprites/Run (4).png',
         'Sprites/Run (5).png',
         'Sprites/Run (6).png',
         'Sprites/Run (7).png',
         'Sprites/Run (8).png',
     ], 100, True)
     self.jumpSpeed = 130.0
     self.scale = .2
     self.isJumping = False
     self.isFalling = True
     self.y = ground
     self.gscore = 10
     self.glife = 20
     self.SCORE = pygame.font.SysFont("calibri", 32)
コード例 #8
0
 def __init__(self, x):
     pygame.sprite.Sprite.__init__(self)
     self.image = {
         "idle":
         Animation([
             "robot/idle/idle_1.png",
             "robot/idle/idle_2.png",
             "robot/idle/idle_3.png",
             "robot/idle/idle_4.png",
             "robot/idle/idle_5.png",
         ], 100, True),
         "die":
         Animation([
             "robot/die/die_1.png",
             "robot/die/die_2.png",
             "robot/die/die_3.png",
             "robot/die/die_4.png",
             "robot/die/die_5.png",
             "robot/die/die_6.png",
             "robot/die/die_7.png",
             "robot/die/die_8.png",
             "robot/die/die_9.png",
         ], 100, True)
     }
     self.state = self.image["idle"]
     self.scale = .4
     self.rect = self.state.getScaledImage(self.scale).get_rect()
     self.x = x
     # self.y = 450 - self.rect.height
     self.y = 250
     self.speed = 3
     self.last_shot = 100
     self.isdead = False
     self.dead_count = 0
     self.shooting = False
     self.life = 5
     self.shoot_timer = 0
     self.mask = pygame.mask.from_surface(
         self.state.getCurrentFrame(self.scale))
コード例 #9
0
 def __init__(self):
     pygame.sprite.Sprite.__init__(self)
     # Create states for the Player - run, idle, throw, jump, fall etc
     self.image = {
         "idle":
         Animation([
             "png/Idle__000.png",
             "png/Idle__001.png",
             "png/Idle__002.png",
             "png/Idle__003.png",
             "png/Idle__004.png",
             "png/Idle__005.png",
             "png/Idle__006.png",
             "png/Idle__007.png",
             "png/Idle__008.png",
             "png/Idle__009.png",
         ], 100, True),
         "run":
         Animation([
             "png/Run__000.png",
             "png/Run__001.png",
             "png/Run__002.png",
             "png/Run__003.png",
             "png/Run__004.png",
             "png/Run__005.png",
             "png/Run__006.png",
             "png/Run__007.png",
             "png/Run__008.png",
             "png/Run__009.png",
         ], 100, True),
         "throw":
         Animation([
             "png/Throw__000.png",
             "png/Throw__001.png",
             "png/Throw__002.png",
             "png/Throw__003.png",
             "png/Throw__004.png",
             "png/Throw__005.png",
             "png/Throw__006.png",
             "png/Throw__007.png",
             "png/Throw__008.png",
             "png/Throw__009.png",
         ], 100, True),
         "jump":
         Animation([
             "png/Jump__000.png",
             "png/Jump__001.png",
             "png/Jump__002.png",
             "png/Jump__003.png",
             "png/Jump__004.png",
             "png/Jump__005.png",
         ], 100, True),
         "fall":
         Animation([
             "png/Jump__006.png",
             "png/Jump__007.png",
             "png/Jump__008.png",
             "png/Jump__009.png",
         ], 100, True),
         "die":
         Animation([
             "png/Dead__000.png",
             "png/Dead__001.png",
             "png/Dead__002.png",
             "png/Dead__003.png",
             "png/Dead__004.png",
             "png/Dead__005.png",
             "png/Dead__006.png",
             "png/Dead__007.png",
             "png/Dead__008.png",
             "png/Dead__009.png",
         ], 100, True),
         "attack":
         Animation([
             "png/Attack__000.png",
             "png/Attack__001.png",
             "png/Attack__002.png",
             "png/Attack__003.png",
             "png/Attack__004.png",
             "png/Attack__005.png",
             "png/Attack__006.png",
             "png/Attack__007.png",
             "png/Attack__008.png",
             "png/Attack__009.png",
         ], 100, True)
     }
     self.state = self.image["die"]
     self.state.get_mask()
     self.jumpSpeed = 100.0
     self.scale = .39
     self.isJumping = False
     self.isFalling = True
     self.rect = self.state.getScaledImage(self.scale).get_rect()
     self.x = 50
     self.y = 450 - self.rect.height
     self.flip = False
     self.jumpAcceleration = 800
     self.jumpVelocity = 0
     self.last_shot = 100
     self.dead = False
     self.dead_count = 0
     self.radius = self.rect.width / 2
     self.life = 8
     self.isAttacking = False
     self.speed = 3
     self.score = 0
コード例 #10
0
 def __init__(self):
     pygame.sprite.Sprite.__init__(self)
     self.image = {
         "life":
         Animation([
             "life/Bronze_11.png",
             "life/Bronze_12.png",
             "life/Bronze_13.png",
             "life/Bronze_14.png",
             "life/Bronze_15.png",
             "life/Bronze_16.png",
             "life/Bronze_17.png",
             "life/Bronze_18.png",
             "life/Bronze_19.png",
             "life/Bronze_20.png",
         ], 100, True),
         "bronze":
         Animation([
             "score1/Bronze_1.png",
             "score1/Bronze_2.png",
             "score1/Bronze_3.png",
             "score1/Bronze_4.png",
             "score1/Bronze_5.png",
             "score1/Bronze_6.png",
             "score1/Bronze_7.png",
             "score1/Bronze_8.png",
             "score1/Bronze_9.png",
             "score1/Bronze_10.png",
         ], 150, True),
         "silver":
         Animation([
             "score2/Silver_0.png",
             "score2/Silver_1.png",
             "score2/Silver_2.png",
             "score2/Silver_3.png",
             "score2/Silver_4.png",
             "score2/Silver_5.png",
             "score2/Silver_6.png",
             "score2/Silver_7.png",
             "score2/Silver_8.png",
             "score2/Silver_9.png",
         ], 150, True),
         "gold":
         Animation([
             "score3/Gold_1.png",
             "score3/Gold_2.png",
             "score3/Gold_3.png",
             "score3/Gold_4.png",
             "score3/Gold_5.png",
             "score3/Gold_6.png",
             "score3/Gold_7.png",
             "score3/Gold_8.png",
             "score3/Gold_9.png",
             "score3/Gold_10.png",
         ], 150, True)
     }
     self.types = [
         self.image["life"], self.image["gold"], self.image['silver'],
         self.image["bronze"]
     ]
     self.state = random.choice(self.types)
     self.scale = .1
     self.rect = self.state.getScaledImage(self.scale).get_rect()
     self.y = 450 - self.rect.height
     self.x = random.randint(3000, 5000)
     self.speed = 8
     self.count = 0
コード例 #11
0
 def __init__(self):
     self.animation = Animation(
         ["Sprites/coin/0.png", "Sprites/coin/1.png"], 150, True)
     self.x, self.y = 500, 330
     self.speed = 100  # PPS
     self.scale = .5
コード例 #12
0
    class Player(pygame.sprite.Sprite):
        def __init__(self, *groups):
            self.animation = Animation([
                'Sprites/Run (1).png',
                'Sprites/Run (2).png',
                'Sprites/Run (3).png',
                'Sprites/Run (4).png',
                'Sprites/Run (5).png',
                'Sprites/Run (6).png',
                'Sprites/Run (7).png',
                'Sprites/Run (8).png',
            ], 100, True)
            self.jumpSpeed = 130.0
            self.scale = .2
            self.isJumping = False
            self.isFalling = True
            self.y = ground
            self.gscore = 10
            self.glife = 20
            self.SCORE = pygame.font.SysFont("calibri", 32)
            #self.score = self.SCORE.render("Score:%s" % (self.gscore), True, (0, 0, 0))

        def input(self, key):
            print "Jumping=%s,falling=%s" % (self.isJumping, self.isFalling)
            if key == pygame.K_w and (not self.isJumping
                                      and not self.isFalling):
                self.isJumping = True

        def update(self, deltatime):
            self.score = self.SCORE.render("Score:%s" % (self.gscore), True,
                                           (0, 0, 0))
            self.life = self.SCORE.render("Life:%s" % (self.glife), True,
                                          (0, 0, 0))

            if not (self.isJumping or self.isFalling):
                self.animation.update(deltatime)
            self.rect = self.animation.getScaledImage(self.scale).get_rect()
            self.mask = pygame.mask.from_surface(
                self.animation.getScaledImage(self.scale))

            self.rect.x = 200
            if self.y > ground:
                self.y = ground
                self.isFalling = False
                self.isJumping = False
            if self.y < ground - self.rect.height:
                self.isFalling = True
                self.isJumping = False
                #pygame.transform.rotate(self.animation, 360)

            if self.isJumping:
                self.y -= self.jumpSpeed * deltatime / 600.0
            elif self.isFalling:
                self.y += self.jumpSpeed * deltatime / 600.0

            self.rect.y = self.y

            if player.glife <= 0:
                #from Font import fmain
                player.fmain()
                pygame.time.wait((main), 100000)

        def draw(self, screen):
            img = self.animation.getScaledImage(self.scale)
            img_rect = img.get_rect()
            screen.blit(self.score, (10, 10))
            screen.blit(self.life, (600, 10))
            screen.blit(img, (200, self.y))
            #screen.blit(self.yscore,(20,20))

        def fmain(self):
            white = 255, 255, 255
            screen = pygame.display.set_mode((700, 400))
            background = pygame.image.load("bg.png")
            font = pygame.font.SysFont("calibri", 30)
            font1 = pygame.font.SysFont("comicsansms", 45)
            text = font.render("Start Game", True, (0, 0, 0))
            te_re = text.get_rect()
            text1 = font.render("About", True, (0, 0, 0))
            katanga = font1.render("Katanga Run!!!", True, (0, 0, 0))
            quit = font.render("Quit", True, (255, 0, 0))

            gmae = font.render("Game Over!, Press Esc to restart", True,
                               (255, 0, 0))
            yscore = font.render("Your score is:%s" % (player.gscore), True,
                                 (0, 0, 0))

            texts = ([
                font.render("Start Game", True, (0, 0, 0)),
                font.render("About", True, (0, 0, 0)),
                font.render("Quit", True, (255, 0, 0))
            ])
            while True:
                for event in pygame.event.get():
                    if event.type == pygame.QUIT:
                        exit()
                    if event.type == pygame.KEYDOWN:
                        if event.key == K_ESCAPE:
                            main()

                screen.fill(WHITE)
                screen.blit(gmae, (200, 180))
                screen.blit(yscore, (200, 240))
                pygame.display.update()