Das deutsche Python-Forum

Code: Alles auswählen

class Vogel:
    schwerkraft = 5 # Kraft, die Vogel runterzieht
    lift = -10 # Kraft, die Vogel hochzieht
    
    def __init__(self):
        self.y = 500 / 2
        self.x = 64
        self.geschwindigkeit = 0
    
    def hochfliegen(self):
        self.geschwindigkeit += Vogel.lift
    
    def show(self):
        fill(255)
        ellipse(self.x, self.y, 30, 30)
        
    def update(self):
        self.geschwindigkeit += Vogel.schwerkraft
        self.geschwindigkeit *= 0.9
        self.y += self.geschwindigkeit
        
        if self.y > height:
            self.y = height 
            self.geschwindigkeit = 0
            
        if self.y < 0:
            self.y = 0 

Code: Alles auswählen

from bird import *

vogel = Vogel()

def setup():
    size(500, 500)

def draw():
    background(51)
    vogel.show()
    if key == ' ':
        vogel.hochfliegen()
    vogel.update()
    

Code: Alles auswählen

function Bird() {
  this.y = height/2;
  this.x = 64;

  this.gravity = 0.7;
  this.lift = -12;
  this.velocity = 0;

  this.show = function() {
    fill(255);
    ellipse(this.x, this.y, 32, 32);
  }

  this.up = function() {
    this.velocity += this.lift;
  }

  this.update = function() {
    this.velocity += this.gravity;
    // this.velocity *= 0.9;
    this.y += this.velocity;

    if (this.y > height) {
      this.y = height;
      this.velocity = 0;
    }

    if (this.y < 0) {
      this.y = 0;
      this.velocity = 0;
    }

  }

}

Code: Alles auswählen

import pygame as pg
import random
from pygame.locals import *
import os

BLACK = [0, 0, 0]
WHITE = [255, 255, 255]
RED = [255, 0, 0]


class Bird:

    def __init__(self, canvas):
        self.canvas = canvas
        self.y = self.canvas.height // 2
        self.x = 64
        self.gravity = 0.5
        self.lift = -10
        self.velocity = 0

    def show(self):
        pg.draw.circle(self.canvas.screen, BLACK, [int(self.x), int(self.y)], 10, 0)

    def up(self):
        self.velocity += self.lift

    def update(self):
        self.velocity += self.gravity
        self.velocity *= 0.9
        self.y += self.velocity
        if self.y > self.canvas.height:
            self.y = self.canvas.height
            self.velocity = 0
        if self.y < 0:
            self.y = 0
            self.velocity = 0
        self.y = int(self.y)


class Pipe:

    def __init__(self, canvas):
        self.canvas = canvas
        self.top = random.randint(100, self.canvas.height - 200)
        self.bottom = self.top + random.randint(100, 150)
        self.x = self.canvas.width + 10
        self.w = 20
        self.speed = 1
        self.highlight = False

    def hits(self, bird):
        if not self.highlight:
            if (bird.y <= self.top) or (bird.y >= self.bottom):
                if self.x <= bird.x <= self.x + 1:
                    self.highlight = True
                    return True

    def show(self):
        col = BLACK
        if self.highlight:
            col = RED
        pg.draw.rect(self.canvas.screen, col, [self.x, 0, self.w, self.top], 0)
        pg.draw.rect(self.canvas.screen, col, [self.x, self.bottom, self.w, self.canvas.height], 0)

    def update(self):
        self.x -= self.speed

    def offscreen(self):
        return self.x < 0 - self.w


class Canvas:

    def __init__(self, fullhd=False, width=800, height=800, mode=0):
        self.fullhd = fullhd
        self.width = width
        self.height = height
        self.mode = mode

        os.environ['SDL_VIDEO_CENTERED'] = '1'
        pg.init()
        self.clock = pg.time.Clock()
        if not self.fullhd:
            pg.display.set_caption('Flappy Bird')
            # icon_img = pg.image.load_extended('.\\icon.png')   # if there´s an icon
            # pg.display.set_icon(icon_img)
        self.screen = pg.display.set_mode([width, height], mode)
        self.screen.fill(WHITE)
        pg.display.update()
        # pg.key.set_repeat(0)    # set key repeat rate


def main():
    canvas = Canvas()  # windowed mode
    # canvas = Canvas(fullhd=True, width=1920, height=1080, mode=FULLSCREEN)  # fullscreen mode

    # mouse_pos = [0, 0]  #  not used in this game

    bird = Bird(canvas)
    pipes = [Pipe(canvas)]

    frame_count = 0
    pause = main_exit = False
    while not main_exit:
        canvas.clock.tick(60)  # set fps rate
        for event in pg.event.get():
            if event.type == QUIT:
                main_exit = pause = True
                break
            elif event.type == KEYDOWN:
                if event.key == K_ESCAPE:
                    main_exit = pause = True
                if event.key == K_UP or event.key == K_w:
                    bird.up()
                # if event.key == K_DOWN or event.key == K_s:
                #     pass
                # if event.key == K_LEFT or event.key == K_a:
                #     pass
                # if event.key == K_RIGHT or event.key == K_d:
                #     pass
                if event.key == K_p:
                    pause = not pause   # pause the action
            # elif event.type == KEYUP:
            #     pass
            # elif event.type == MOUSEMOTION:
            #     mouse_pos = pg.mouse.get_pos()
            #     button1, button2, button3 = pg.mouse.get_pressed()
            #     if button1:
            #         pass
            #     if button2:
            #         pass
            #     if button3:
            #         pass
            # elif event.type == MOUSEBUTTONDOWN:
            #     if event.button == 3:  # right mouse button
            #         pass
            #     if event.button == 4:  # mouse scroll up
            #         pass
            #     if event.button == 5:  # mouse scroll down
            #         pass

        # button1, button2, button3 = pg.mouse.get_pressed()
        # if button1:
        #     pass
        # if button2:
        #     pass
        # if button3:
        #     pass

        if not pause:
            frame_count += 1
            canvas.screen.fill(WHITE)  # clear surface

            for i in range(len(pipes)):
                pipes[i].show()
                pipes[i].update()
                if pipes[i].hits(bird):
                    print(" HIT")

            if pipes[0].offscreen():
                pipes = pipes[1:]

            bird.update()
            bird.show()

            if frame_count % 300 == 0:
                pipes.append(Pipe(canvas))

            pg.display.update()

    pg.quit()

if __name__ == '__main__':
    main()

Code: Alles auswählen

#!/usr/bin/env python3
import os
import random
from collections import deque

import pygame as pg
from pygame.locals import *

BLACK = [0, 0, 0]
WHITE = [255, 255, 255]
RED = [255, 0, 0]


def create_canvas(fullhd=False, width=800, height=800, mode=0):
    os.environ['SDL_VIDEO_CENTERED'] = '1'
    pg.init()
    if not fullhd:
        pg.display.set_caption('Flappy Bird')
    screen = pg.display.set_mode([width, height], mode)
    screen.fill(WHITE)
    pg.display.update()
    return screen


class Bird:
    
    GRAVITY = 0.5
    LIFT = -10

    def __init__(self, canvas):
        self.canvas = canvas
        self.y = self.canvas.get_height() // 2
        self.x = 64
        self.velocity = 0

    def show(self):
        pg.draw.circle(self.canvas, BLACK, [self.x, self.y], 10, 0)

    def up(self):
        self.velocity += self.LIFT

    def update(self):
        self.velocity = (self.velocity + self.GRAVITY) * 0.9
        self.y = int(self.y + self.velocity)
        if self.y > self.canvas.get_height():
            self.y = self.canvas.get_height()
            self.velocity = 0
        if self.y < 0:
            self.y = 0
            self.velocity = 0


class Pipe:
    
    WIDTH = 20
    SPEED = 1
    
    def __init__(self, canvas):
        self.canvas = canvas
        self.top = random.randint(100, self.canvas.get_height() - 200)
        self.bottom = self.top + random.randint(100, 150)
        self.x = self.canvas.get_width() + self.WIDTH // 2
        self.highlight = False

    def hits(self, bird):
        if (
            not self.highlight
            and not self.top <= bird.y < self.bottom
            and self.x <= bird.x <= self.x + 1
        ):
            self.highlight = True
            return True
        return False

    def show(self):
        color = RED if self.highlight else BLACK
        pg.draw.rect(self.canvas, color, [self.x, 0, self.WIDTH, self.top], 0)
        pg.draw.rect(
            self.canvas,
            color,
            [self.x, self.bottom, self.WIDTH, self.canvas.get_height()],
            0
        )

    def update(self):
        self.x -= self.SPEED

    def is_offscreen(self):
        return self.x < -self.WIDTH


def main():
    canvas = create_canvas()  # windowed mode
    # canvas = create_canvas(
    #     fullhd=True, width=1920, height=1080, mode=FULLSCREEN
    # )  # fullscreen mode

    bird = Bird(canvas)
    pipes = deque([Pipe(canvas)])

    clock = pg.time.Clock()
    frame_count = 0
    pause = main_exit = False
    while not main_exit:
        clock.tick(60)  # set fps rate
        for event in pg.event.get():
            if event.type == QUIT:
                main_exit = pause = True
                break
            elif event.type == KEYDOWN:
                if event.key == K_ESCAPE:
                    main_exit = pause = True
                if event.key == K_UP or event.key == K_w:
                    bird.up()
                if event.key == K_p:
                    pause = not pause   # pause the action

        if not pause:
            frame_count += 1
            canvas.fill(WHITE)  # clear surface

            for pipe in pipes:
                pipe.update()
                pipe.show()
                if pipe.hits(bird):
                    print(' HIT')

            if pipes[0].is_offscreen():
                pipes.popleft()

            bird.update()
            bird.show()

            if frame_count % 300 == 0:
                pipes.append(Pipe(canvas))

            pg.display.update()

    pg.quit()


if __name__ == '__main__':
    main()