From: Skullheadx <704277@pdsb.net>
Date: Tue, 5 Jul 2022 19:03:40 +0000 (-0400)
Subject: Added everything
X-Git-Url: http://git.skullheadx.com/about.html?a=commitdiff_plain;h=1c5fc45fff3cabec389ab11e73177d307ac671db;p=Amongus-Bird.git

Added everything

moved this from my project folder on home computer
---

diff --git a/Amongus Bird.exe b/Amongus Bird.exe
new file mode 100644
index 0000000..109ccbc
Binary files /dev/null and b/Amongus Bird.exe differ
diff --git a/Amongus Bird.py b/Amongus Bird.py
new file mode 100644
index 0000000..ba2c8dd
--- /dev/null
+++ b/Amongus Bird.py	
@@ -0,0 +1,564 @@
+import os
+os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide"
+import pygame
+import math
+import random
+import time
+
+def format_number(num):
+    if num < 1000:
+        return num
+
+    out = ""
+    for i, val in enumerate((str(num)[::-1])):
+        out += val
+        if (i + 1) % 3 == 0 and i != len(str(num)) - 1:
+            out += ","
+    out = out[::-1]
+
+    return out
+
+
+def reset_game():
+    global game
+    game = Game()
+
+
+class Label:
+    horizontal_padding = 5
+    vertical_padding = 5
+    outline_thickness = 2
+
+    def __init__(self, x, y, text, font_size, text_colour=(0, 0, 0), antialias=True, fill_colour=(150, 150, 150),
+                 outline_colour=(0, 0, 0)):
+        self.position = pygame.Vector2(x, y)
+        self.font = pygame.font.Font("textures/MontserratBlack-ZVK6J.otf", font_size)
+        self.text_colour = text_colour
+        self.antialias = antialias
+        self.fill_colour = fill_colour
+        self.outline_colour = outline_colour
+        self.raw_text = text
+        self.text, self.width, self.height = self.create_text(self.raw_text)
+        self.centering = pygame.Vector2(0, 0)
+
+    def create_text(self, text):
+        out = []
+        max_width = 0
+        max_height = 0
+        for line in text:
+            text_surface = self.font.render(line, self.antialias, self.text_colour)
+            width = text_surface.get_width()
+            height = text_surface.get_height()
+            out.append((text_surface, width, height))
+            max_width = max(max_width, width)
+            max_height += height
+        return out, max_width, max_height
+
+    def update(self, delta, new_text=None, x=None, y=None, width=None, height=None, colour=None, font_size=None):
+        if new_text is not None:
+            self.text, self.width, self.height = self.create_text(new_text)
+        if font_size is not None:
+            self.font = pygame.font.Font("textures/MontserratBlack-ZVK6J.otf", font_size)
+            self.text, self.width, self.height = self.create_text(self.raw_text)
+        if x is not None:
+            self.position.x = x
+        if y is not None:
+            self.position.y = y
+        if width is not None:
+            self.width = width
+        if height is not None:
+            self.height = height
+        if colour is not None:
+            self.fill_colour = colour
+
+    def draw(self, surface, centered_x=True, centered_y=True, outlined=False, filled=False):
+        if centered_x:
+            self.centering.x = self.width / 2
+        if centered_y:
+            self.centering.y = self.height / 2
+        if filled:
+            r = pygame.Rect(
+                self.position - pygame.Vector2(self.horizontal_padding, self.vertical_padding) - self.centering,
+                pygame.Vector2(self.width + 2 * self.horizontal_padding,
+                               self.height + self.vertical_padding * 2))
+            pygame.draw.rect(surface, self.fill_colour, r)
+        if outlined:
+            r = pygame.Rect(
+                self.position - pygame.Vector2(self.horizontal_padding, self.vertical_padding) - self.centering,
+                pygame.Vector2(self.width + 2 * self.horizontal_padding,
+                               self.height + self.vertical_padding * 2))
+            pygame.draw.rect(surface, self.outline_colour, r, self.outline_thickness)
+
+        prev_height = 0
+        for line in self.text:
+            text_surface, width, height = line
+            surface.blit(text_surface, self.position - self.centering + pygame.Vector2(0, prev_height))
+            prev_height += height
+
+
+class Button(Label):
+
+    def __init__(self, x, y, text, font_size, text_colour=(0, 0, 0), antialias=True, fill_color=(150, 150, 150),
+                 outline_colour=(0, 0, 0)):
+        super().__init__(x, y, text, font_size, text_colour=text_colour, antialias=antialias, fill_colour=fill_color,
+                         outline_colour=outline_colour)
+
+    def is_touching_mouse_pointer(self):
+        mouse_x, mouse_y = pygame.mouse.get_pos()
+        if (self.position.x - self.centering.x <= mouse_x <= self.position.x + self.width - self.centering.x
+                and self.position.y - self.centering.y <= mouse_y <= self.position.y + self.height - self.centering.y):
+            return True
+        return False
+
+    def lighten(self):
+        self.fill_colour = (150, 150, 150)
+
+    def darken(self):
+        self.fill_colour = (170, 170, 170)
+
+    def update(self, delta, new_text=None, x=None, y=None, width=None, height=None, colour=None):
+        super().update(delta, new_text=new_text, x=x, y=y, width=width, height=height, colour=colour)
+        if self.is_touching_mouse_pointer():
+            self.lighten()
+        else:
+            self.darken()
+
+    def run_function(self, function):
+        return function()
+
+
+class Rectangle:
+    horizontal_padding = 12
+    vertical_padding = 12
+    outline_colour = (80, 80, 80)
+    outline_thickness = 5
+
+    def __init__(self, x, y, width, height, colour):
+        self.position = pygame.Vector2(x, y)
+        self.width = width
+        self.height = height
+        self.fill_colour = colour
+        self.centering = pygame.Vector2(0, 0)
+
+    def update(self, x=None, y=None, width=None, height=None, colour=None):
+        if x is not None:
+            self.position.x = x
+        if y is not None:
+            self.position.y = y
+        if width is not None:
+            self.width = width
+        if height is not None:
+            self.height = height
+        if colour is not None:
+            self.fill_colour = colour
+
+    def draw(self, surface, centered_x=True, centered_y=True, outlined=True):
+        if centered_x:
+            self.centering.x = self.width / 2
+        if centered_y:
+            self.centering.y = self.height / 2
+        r = pygame.Rect(self.position - pygame.Vector2(self.horizontal_padding, self.vertical_padding) - self.centering,
+                        pygame.Vector2(self.width + 2 * self.horizontal_padding, self.height + self.vertical_padding))
+        pygame.draw.rect(surface, self.fill_colour, r)
+        if outlined:
+            r = pygame.Rect(
+                self.position - pygame.Vector2(self.horizontal_padding, self.vertical_padding) - self.centering,
+                pygame.Vector2(self.width + 2 * self.horizontal_padding,
+                               self.height + self.vertical_padding))
+            pygame.draw.rect(surface, self.outline_colour, r, self.outline_thickness)
+
+
+class Player:
+    width = 40
+    height = 40
+    gravity = 0.0180
+    jump_strength = 0.35
+    speed = 0.215
+    jump_cooldown_length = 0
+    path = "textures/Among us bird/Layer 1_bird_updated_"
+    frames = []
+    for i in range(1, 5):
+        frames.append(pygame.image.load(path + str(i) + ".png"))
+    bird = frames[0]
+    crop = 2 * 40 / bird.get_width() * 1.75
+    bird = pygame.transform.scale(bird, (width, height))
+
+    def __init__(self, x, y):
+        self.position = pygame.Vector2(x, y)
+        self.velocity = pygame.Vector2(0, 0)
+        self.jump_cooldown = 200
+        self.collision_rect = pygame.Rect(self.position.x - self.width / 2,
+                                          (self.position.y - self.height / 2 + self.crop), self.width,
+                                          self.height - 2 * self.crop)
+        self.distance = 0
+        self.current_frame = 0
+        self.test = 0
+        self.display_bird = self.bird
+        self.direction = 0
+        self.no_jump = 0
+        self.help_label = Label(SCREEN_WIDTH/2, SCREEN_HEIGHT*4/5, ["Press SPACE to jump"], 20, (230,230,230))
+
+    def update(self, delta, is_game_over):
+        self.velocity *= self.no_jump
+        if self.no_jump == 0:
+            self.help_label.update(delta, y=SCREEN_HEIGHT * 4 /5 + 20 * math.sin(1.5 * time.time()))
+        self.test += delta
+        self.jump_cooldown -= delta
+
+        if self.test > 500 / len(self.frames):
+            self.bird = self.frames[self.current_frame]
+            self.bird = pygame.transform.scale(self.bird, (self.width, self.height))
+            self.current_frame += 1
+            self.current_frame %= len(self.frames)
+            self.test = 0
+            if self.velocity.x < 0:
+                self.bird = pygame.transform.flip(self.bird, True, True)
+
+        self.display_bird = self.bird
+        if self.velocity.y > 0.25:
+            self.display_bird = pygame.transform.rotate(self.bird, self.direction)
+            self.collision_rect = self.display_bird.get_rect(center=self.bird.get_rect(topleft=self.position).center)
+            self.direction -= delta / 16
+            self.direction = max(self.direction, -70)
+        else:
+            self.display_bird = self.bird
+            self.direction = 0
+
+        if not is_game_over:
+            pressed = pygame.key.get_pressed()
+            if pressed[pygame.K_SPACE] and self.jump_cooldown <= 0:
+                self.jump()
+
+        if self.is_out_of_bounds():
+            return False
+
+        self.position.x += self.velocity.x * delta
+        for wall in game.wall_manager.walls:
+            for collision_rect in wall.collision_rects:
+                if self.is_colliding(collision_rect):
+                    if self.position.x < wall.position.x + wall.width:
+                        self.position.x = wall.position.x - self.width
+                    else:
+                        self.position.x = wall.position.x + wall.width + self.width
+                    self.velocity.x *= -1
+                    return False
+        self.position.y += self.velocity.y * delta
+        for wall in game.wall_manager.walls:
+            for collision_rect in wall.collision_rects:
+                if self.is_colliding(collision_rect):
+                    if self.position.y < collision_rect.y + collision_rect.height:
+                        self.position.y = collision_rect.y - self.height
+                    else:
+                        self.position.y = collision_rect.y + collision_rect.height + self.height
+                    self.velocity.y *= -1
+                    return False
+
+        self.velocity.y += self.gravity
+        return True
+
+    def is_out_of_bounds(self):
+        if self.position.y + self.height < 0 or self.position.y - self.height > SCREEN_HEIGHT:
+            return True
+        return False
+
+    def is_colliding(self, rect):
+        self.collision_rect = pygame.Rect(self.position.x - self.width / 2,
+                                          self.position.y - self.height / 2 + self.crop, self.width,
+                                          self.height - 2 * self.crop)
+        if rect.colliderect(self.collision_rect):
+            return True
+        return False
+
+    def jump(self):
+        self.no_jump = 1
+        self.velocity.y = -self.jump_strength
+        self.jump_cooldown = self.jump_cooldown_length
+
+    def draw(self, surface):
+        # # pygame.draw.rect(surface, (255,255,0), self.collision_rect)
+        surface.blit(self.display_bird, self.position - pygame.Vector2(self.width / 2, self.height / 2))
+        if self.no_jump == 0:
+            self.help_label.draw(screen)
+
+
+class Wall:
+    fill_colour = (0, 255, 0)
+    hole_height = Player.height * 1.5
+    width = Player.width
+    pipe = pygame.image.load("textures/pipe.png")
+    pipe = pygame.transform.scale(pipe, (width, width))
+    end_pipe = pygame.image.load("textures/pipe_top.png")
+    end_pipe = pygame.transform.scale(end_pipe, (width, width))
+
+    def __init__(self, x, hole_y):
+        self.position = pygame.Vector2(x, -Player.height)
+        self.hole_y = hole_y
+        self.collision_rects = [pygame.Rect(self.position.x, self.position.y, self.width, self.hole_y),
+                                pygame.Rect(self.position.x, self.hole_y + self.hole_height, self.width,
+                                            SCREEN_HEIGHT - (
+                                                    self.hole_y + self.hole_height) + self.end_pipe.get_height())]
+        self.centering = pygame.Vector2(0, 0)
+        self.score_award = 1
+
+    def update(self, delta, x):
+        self.position.x -= x * delta
+        self.collision_rects = [pygame.Rect(self.position.x, self.position.y, self.width, self.hole_y),
+                                pygame.Rect(self.position.x, self.hole_y + self.hole_height, self.width,
+                                            SCREEN_HEIGHT - (self.hole_y + self.hole_height) + Player.height)]
+
+    def reset(self):
+        self.position.x += SCREEN_WIDTH * 2
+        self.hole_y = random.randint(round(self.hole_height * 0.5) + self.end_pipe.get_height() + Player.height,
+                                     round(SCREEN_HEIGHT - self.hole_height * 1.5))
+        self.score_award = 1
+
+    def award_score(self):
+        game.score += self.score_award
+        self.score_award = 0
+
+    def draw(self, surface):
+        # for r in self.collision_rects:
+        #     pygame.draw.rect(surface, self.fill_colour, r)
+        r = self.collision_rects[1]
+        surface.blit(self.end_pipe, (r.x, r.y))
+        for i in range(SCREEN_HEIGHT // self.pipe.get_height()):
+            if r.y + i * self.pipe.get_height() > SCREEN_HEIGHT:
+                break
+            surface.blit(self.pipe, (r.x, r.y + self.end_pipe.get_height() + i * self.pipe.get_height()))
+        transformed_end_pipe = pygame.transform.flip(self.end_pipe, False, True)
+        r = self.collision_rects[0]
+        surface.blit(transformed_end_pipe, (r.x, r.y + r.height - transformed_end_pipe.get_width()))
+        for i in range(1, SCREEN_HEIGHT // self.pipe.get_height()):
+            if r.y + r.height - i * self.pipe.get_height() < 0:
+                break
+            surface.blit(self.pipe,
+                         (r.x, r.y + r.height - transformed_end_pipe.get_height() - i * self.pipe.get_height()))
+
+
+class WallManager:
+
+    def __init__(self):
+        self.wall_separation_distance = SCREEN_WIDTH / 2
+        self.starting_position = SCREEN_WIDTH * 1.1
+        self.walls = []
+        for i in range(math.floor(SCREEN_WIDTH * 2/ self.wall_separation_distance)):
+            self.walls.append(Wall(self.starting_position + self.wall_separation_distance * i,
+                                   random.randint(round(Wall.hole_height * 0.5) + Player.height + Player.height,
+                                              round(SCREEN_HEIGHT - Wall.hole_height * 1.5))))
+
+
+    def update(self, delta, slow_down_effect):
+        for wall in self.walls:
+            wall.update(delta, Player.speed * slow_down_effect * game.player.no_jump)
+            if wall.position.x + wall.width < 0:
+                wall.reset()
+            if game.player.position.x > wall.position.x + wall.width:
+                wall.award_score()
+
+    def draw(self, surface):
+        for wall in self.walls:
+            wall.draw(surface)
+
+
+class Game:
+
+    def __init__(self):
+        self.wall_manager = WallManager()
+        self.player = Player(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2)
+        self.score = 0
+        self.score_label = Label(SCREEN_WIDTH, 0, [f"Score: {format_number(self.score)}"], 20, (200, 200, 200),
+                                 fill_colour=(50, 50, 50), outline_colour=(0, 0, 0))
+        self.is_game_over = False
+        self.slow_down_effect = 1.0
+        self.background = Background((15, 15, 15))
+
+    def update(self, delta):
+        self.background.update(delta)
+        self.wall_manager.update(delta, self.slow_down_effect)
+        self.score_label.update(delta, new_text=[f"Score: {format_number(self.score)}"],
+                                x=SCREEN_WIDTH - self.score_label.width - Label.horizontal_padding,
+                                y=Label.vertical_padding)
+        if not self.player.update(delta, self.is_game_over):
+            if not self.is_game_over:
+                self.game_over()
+        if self.is_game_over:
+            self.slow_down_effect /= delta
+            if self.player.is_out_of_bounds():
+                global game
+                game = GameOverScreen(self.score)
+
+    def game_over(self):
+        self.player.velocity.x = -Player.speed
+        self.is_game_over = True
+
+    def draw(self, screen):
+        self.background.draw(screen)
+        self.wall_manager.draw(screen)
+        self.score_label.draw(screen, centered_y=False, centered_x=False)
+        self.player.draw(screen)
+
+
+class GameOverScreen:
+
+    def __init__(self, score):
+        self.score = score
+        global highest_score
+        self.game_over_card = Rectangle(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, SCREEN_WIDTH * 2 / 3,
+                                        SCREEN_HEIGHT * 4 / 5, (50, 50, 50))
+        self.title = Label(SCREEN_WIDTH / 2, self.game_over_card.height / 5, [f"Game Over!"], 50,
+                           text_colour=(237, 37, 37))
+        if score > highest_score:
+            self.score_label = Label(SCREEN_WIDTH / 2, self.title.position.y + self.title.height,
+                                     [f"NEW HIGHSCORE: {format_number(self.score)}"], 30, text_colour=(200, 200, 200))
+            self.high_score_label = Label(SCREEN_WIDTH / 2, self.score_label.position.y + self.score_label.height,
+                                          [f""], 30, text_colour=(200, 200, 200))
+        else:
+            self.score_label = Label(SCREEN_WIDTH / 2, self.title.position.y + self.title.height,
+                                     [f"Your Score: {format_number(self.score)}"], 35, text_colour=(200, 200, 200))
+            self.high_score_label = Label(SCREEN_WIDTH / 2, self.score_label.position.y + self.score_label.height,
+                                          [f"Highscore: {format_number(highest_score)}"], 35,
+                                          text_colour=(200, 200, 200))
+        self.play_again = Button(SCREEN_WIDTH / 2,
+                                 (self.game_over_card.position.y + self.game_over_card.height / 2) * 4 / 5,
+                                 [f"   Play Again   "], 25, fill_color=(0, 0, 0), text_colour=(50, 50, 50))
+        highest_score = max(highest_score, self.score)
+        self.cooldown = 200
+
+    def update(self, delta):
+        if self.cooldown <= 0:
+            for event in pygame.event.get(pygame.MOUSEBUTTONUP, pump=True):
+                if event.button == 1:
+                    if self.play_again.is_touching_mouse_pointer():
+                        self.play_again.run_function(reset_game)
+            pressed = pygame.key.get_pressed()
+            if pressed[pygame.K_SPACE]:
+                self.play_again.run_function(reset_game)
+        # self.game_over_card.update(delta)
+        self.title.update(delta, font_size=50 + math.floor(2.5 * math.sin(4 * time.time())))
+        # self.score_label.update(delta)
+        # self.high_score_label.update(delta)
+        self.play_again.update(delta)
+        self.cooldown -= delta
+
+    def draw(self, surface):
+        self.game_over_card.draw(surface)
+        self.title.draw(surface)
+        self.score_label.draw(surface)
+        self.high_score_label.draw(surface)
+        self.play_again.draw(surface, outlined=True, filled=True)
+
+
+def sort_files(lis):
+    out = []
+    for item in lis:
+        item = item[4:-4]
+        out.append(int(item))
+    return sorted(out)
+
+
+class Start:
+
+    def __init__(self, path, game_name):
+        self.path = path
+        self.directory = os.listdir(self.path)
+        self.num = sort_files(self.directory)
+        self.current_frame = 0
+        self.current_file = None
+        self.game_name = game_name
+
+    def update(self, delta):
+        if self.current_frame >= len(self.directory) - 1:
+            pygame.time.wait(750)
+            global game
+            game = self.game_name()
+        self.current_file = pygame.image.load(
+            self.path + "/bruh" + str(self.num[math.floor(self.current_frame)]) + ".png")
+        self.current_file = pygame.transform.scale(self.current_file, (
+            self.current_file.get_width() * 5, self.current_file.get_height() * 5))
+        self.current_frame += 1.25 / delta
+
+    def draw(self, surface):
+        surface.fill((153, 100, 249))
+        surface.blit(self.current_file, (
+            SCREEN_WIDTH / 2 - self.current_file.get_width() / 2,
+            SCREEN_HEIGHT / 2 - self.current_file.get_height() / 2))
+
+
+class Star:
+
+    def __init__(self, x, y, size):
+        self.position = pygame.Vector2(x, y)
+        self.radius = size / 2
+        self.colour = [200, 200, 200]
+        self.n = random.random() * 365000
+
+    def update(self, delta):
+        # x = int(random.randint(-1,1) * random.random() * delta / 2)
+        x = round(75 * math.sin(self.n / 1000) + 180)
+        for i in range(3):
+            self.colour[i] = x
+        self.n += delta
+
+    def draw(self, screen):
+        # print(self.colour)
+        pygame.draw.circle(screen, self.colour, self.position, self.radius)
+
+
+class Background:
+
+    def __init__(self, background_colour):
+        self.background_colour = background_colour
+        self.stars = []
+        self.max_star_size = 4.25
+        self.max_stars = SCREEN_WIDTH * SCREEN_HEIGHT // 750
+        self.min_stars = SCREEN_WIDTH * SCREEN_HEIGHT // 900
+        self.add_stars(random.randint(self.min_stars, self.max_stars))
+
+    def add_stars(self, num):
+        for i in range(num):
+            self.stars.append(Star(random.random() * SCREEN_WIDTH, random.random() * SCREEN_HEIGHT,
+                                   random.random() * self.max_star_size))
+
+    def update(self, delta):
+        for star in self.stars:
+            star.update(delta)
+
+    def draw(self, surface):
+        screen.fill(self.background_colour)
+        for star in self.stars:
+            star.draw(screen)
+        # a = pygame.Color(255,0,0,100)
+        # pygame.draw.circle(screen, a, (SCREEN_WIDTH/2, SCREEN_HEIGHT/2), 50)
+
+
+pygame.init()
+
+SCREEN_HEIGHT = 480
+SCREEN_WIDTH = 540
+screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
+pygame.display.set_caption("Amongus Bird")
+icon = pygame.transform.scale(Player.bird, (32, 32))
+pygame.display.set_icon(icon)
+
+highest_score = 0
+
+game = Start("textures/logo", Game)
+
+fps_cap = 120
+clock = pygame.time.Clock()
+delta = 1000 // fps_cap
+
+is_running = True
+while is_running:
+
+    for event in pygame.event.get(pygame.QUIT):
+        if event.type == pygame.QUIT:
+            is_running = False
+
+    game.update(delta)
+    game.draw(screen)
+
+    pygame.display.update()
+    delta = clock.tick(fps_cap)
+
+pygame.quit()
diff --git a/Amongus Bird.zip b/Amongus Bird.zip
new file mode 100644
index 0000000..e5dc18e
Binary files /dev/null and b/Amongus Bird.zip differ
diff --git a/readme.txt b/readme.txt
new file mode 100644
index 0000000..936a125
--- /dev/null
+++ b/readme.txt
@@ -0,0 +1,23 @@
+Amongus Bird
+FAILURE Studios
+
+How To Play:
+- run the Amongus Bird.exe file
+OR
+- make a shortcut for the .exe file
+- select the shortcut and rename to Amongus Bird
+- click on properties
+- click on change icon
+- navigate through textures folder
+- click on "icon.ico"
+- click Ok
+- open the shortcut ot play
+
+Credits
+Lead Graphics Designer
+Andrew Montgomery
+Lead Graphic Designer
+Mark Loh
+FAILURE Studios logo & animation
+created by
+John Holwell
\ No newline at end of file
diff --git a/textures/Among us bird-2.zip b/textures/Among us bird-2.zip
new file mode 100644
index 0000000..a8f90b7
Binary files /dev/null and b/textures/Among us bird-2.zip differ
diff --git a/textures/Among us bird/Layer 1_bird_updated_1.png b/textures/Among us bird/Layer 1_bird_updated_1.png
new file mode 100644
index 0000000..6b43a66
Binary files /dev/null and b/textures/Among us bird/Layer 1_bird_updated_1.png differ
diff --git a/textures/Among us bird/Layer 1_bird_updated_2.png b/textures/Among us bird/Layer 1_bird_updated_2.png
new file mode 100644
index 0000000..b457fcd
Binary files /dev/null and b/textures/Among us bird/Layer 1_bird_updated_2.png differ
diff --git a/textures/Among us bird/Layer 1_bird_updated_3.png b/textures/Among us bird/Layer 1_bird_updated_3.png
new file mode 100644
index 0000000..1bb0ac6
Binary files /dev/null and b/textures/Among us bird/Layer 1_bird_updated_3.png differ
diff --git a/textures/Among us bird/Layer 1_bird_updated_4.png b/textures/Among us bird/Layer 1_bird_updated_4.png
new file mode 100644
index 0000000..b457fcd
Binary files /dev/null and b/textures/Among us bird/Layer 1_bird_updated_4.png differ
diff --git a/textures/Layer 1_bird_updated_1.ico b/textures/Layer 1_bird_updated_1.ico
new file mode 100644
index 0000000..0d2a9ad
Binary files /dev/null and b/textures/Layer 1_bird_updated_1.ico differ
diff --git a/textures/MontserratBlack-ZVK6J.otf b/textures/MontserratBlack-ZVK6J.otf
new file mode 100644
index 0000000..863403e
Binary files /dev/null and b/textures/MontserratBlack-ZVK6J.otf differ
diff --git a/textures/flappy.png b/textures/flappy.png
new file mode 100644
index 0000000..3ea8e96
Binary files /dev/null and b/textures/flappy.png differ
diff --git a/textures/icon.ico b/textures/icon.ico
new file mode 100644
index 0000000..0d2a9ad
Binary files /dev/null and b/textures/icon.ico differ
diff --git a/textures/logo/bruh1.png b/textures/logo/bruh1.png
new file mode 100644
index 0000000..8140eb5
Binary files /dev/null and b/textures/logo/bruh1.png differ
diff --git a/textures/logo/bruh11.png b/textures/logo/bruh11.png
new file mode 100644
index 0000000..b0b6e09
Binary files /dev/null and b/textures/logo/bruh11.png differ
diff --git a/textures/logo/bruh12.png b/textures/logo/bruh12.png
new file mode 100644
index 0000000..3f65f2b
Binary files /dev/null and b/textures/logo/bruh12.png differ
diff --git a/textures/logo/bruh13.png b/textures/logo/bruh13.png
new file mode 100644
index 0000000..b7efaa0
Binary files /dev/null and b/textures/logo/bruh13.png differ
diff --git a/textures/logo/bruh14.png b/textures/logo/bruh14.png
new file mode 100644
index 0000000..8b47f42
Binary files /dev/null and b/textures/logo/bruh14.png differ
diff --git a/textures/logo/bruh15.png b/textures/logo/bruh15.png
new file mode 100644
index 0000000..7c905f1
Binary files /dev/null and b/textures/logo/bruh15.png differ
diff --git a/textures/logo/bruh16.png b/textures/logo/bruh16.png
new file mode 100644
index 0000000..6dbf547
Binary files /dev/null and b/textures/logo/bruh16.png differ
diff --git a/textures/logo/bruh17.png b/textures/logo/bruh17.png
new file mode 100644
index 0000000..6dbf547
Binary files /dev/null and b/textures/logo/bruh17.png differ
diff --git a/textures/logo/bruh18.png b/textures/logo/bruh18.png
new file mode 100644
index 0000000..6dbf547
Binary files /dev/null and b/textures/logo/bruh18.png differ
diff --git a/textures/logo/bruh19.png b/textures/logo/bruh19.png
new file mode 100644
index 0000000..d0a6b04
Binary files /dev/null and b/textures/logo/bruh19.png differ
diff --git a/textures/logo/bruh2.png b/textures/logo/bruh2.png
new file mode 100644
index 0000000..8140eb5
Binary files /dev/null and b/textures/logo/bruh2.png differ
diff --git a/textures/logo/bruh21.png b/textures/logo/bruh21.png
new file mode 100644
index 0000000..788649d
Binary files /dev/null and b/textures/logo/bruh21.png differ
diff --git a/textures/logo/bruh22.png b/textures/logo/bruh22.png
new file mode 100644
index 0000000..d26dead
Binary files /dev/null and b/textures/logo/bruh22.png differ
diff --git a/textures/logo/bruh23.png b/textures/logo/bruh23.png
new file mode 100644
index 0000000..59a86d5
Binary files /dev/null and b/textures/logo/bruh23.png differ
diff --git a/textures/logo/bruh24.png b/textures/logo/bruh24.png
new file mode 100644
index 0000000..59a86d5
Binary files /dev/null and b/textures/logo/bruh24.png differ
diff --git a/textures/logo/bruh25.png b/textures/logo/bruh25.png
new file mode 100644
index 0000000..59a86d5
Binary files /dev/null and b/textures/logo/bruh25.png differ
diff --git a/textures/logo/bruh26.png b/textures/logo/bruh26.png
new file mode 100644
index 0000000..59a86d5
Binary files /dev/null and b/textures/logo/bruh26.png differ
diff --git a/textures/logo/bruh27.png b/textures/logo/bruh27.png
new file mode 100644
index 0000000..1eff711
Binary files /dev/null and b/textures/logo/bruh27.png differ
diff --git a/textures/logo/bruh28.png b/textures/logo/bruh28.png
new file mode 100644
index 0000000..cdd9d9d
Binary files /dev/null and b/textures/logo/bruh28.png differ
diff --git a/textures/logo/bruh29.png b/textures/logo/bruh29.png
new file mode 100644
index 0000000..2f319ad
Binary files /dev/null and b/textures/logo/bruh29.png differ
diff --git a/textures/logo/bruh3.png b/textures/logo/bruh3.png
new file mode 100644
index 0000000..8140eb5
Binary files /dev/null and b/textures/logo/bruh3.png differ
diff --git a/textures/logo/bruh31.png b/textures/logo/bruh31.png
new file mode 100644
index 0000000..2f319ad
Binary files /dev/null and b/textures/logo/bruh31.png differ
diff --git a/textures/logo/bruh32.png b/textures/logo/bruh32.png
new file mode 100644
index 0000000..2f319ad
Binary files /dev/null and b/textures/logo/bruh32.png differ
diff --git a/textures/logo/bruh34.png b/textures/logo/bruh34.png
new file mode 100644
index 0000000..2f319ad
Binary files /dev/null and b/textures/logo/bruh34.png differ
diff --git a/textures/logo/bruh35.png b/textures/logo/bruh35.png
new file mode 100644
index 0000000..2f319ad
Binary files /dev/null and b/textures/logo/bruh35.png differ
diff --git a/textures/logo/bruh36.png b/textures/logo/bruh36.png
new file mode 100644
index 0000000..2f319ad
Binary files /dev/null and b/textures/logo/bruh36.png differ
diff --git a/textures/logo/bruh4.png b/textures/logo/bruh4.png
new file mode 100644
index 0000000..8140eb5
Binary files /dev/null and b/textures/logo/bruh4.png differ
diff --git a/textures/logo/bruh5.png b/textures/logo/bruh5.png
new file mode 100644
index 0000000..8140eb5
Binary files /dev/null and b/textures/logo/bruh5.png differ
diff --git a/textures/logo/bruh6.png b/textures/logo/bruh6.png
new file mode 100644
index 0000000..8140eb5
Binary files /dev/null and b/textures/logo/bruh6.png differ
diff --git a/textures/logo/bruh7.png b/textures/logo/bruh7.png
new file mode 100644
index 0000000..8140eb5
Binary files /dev/null and b/textures/logo/bruh7.png differ
diff --git a/textures/logo/bruh8.png b/textures/logo/bruh8.png
new file mode 100644
index 0000000..36ea0ae
Binary files /dev/null and b/textures/logo/bruh8.png differ
diff --git a/textures/logo/bruh9.png b/textures/logo/bruh9.png
new file mode 100644
index 0000000..107040f
Binary files /dev/null and b/textures/logo/bruh9.png differ
diff --git a/textures/pipe.png b/textures/pipe.png
new file mode 100644
index 0000000..4eb035b
Binary files /dev/null and b/textures/pipe.png differ
diff --git a/textures/pipe_top.png b/textures/pipe_top.png
new file mode 100644
index 0000000..fbe4c09
Binary files /dev/null and b/textures/pipe_top.png differ