diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..cfa7ec8 --- /dev/null +++ b/.gitignore @@ -0,0 +1,18 @@ +# Ignore pycache +images/__pycache__/ +gui/__pycache__/ +game/__pycache__/ +sounds/__pycache__/ +__pycache__/ + +# Ignore VSCode config dir +.vscode/ + +# Ignore PyCharm dir +.idea/ + +# Ignore Obsidian config dir +.obsidan/ + +# for testing purposes +/game/test_mask_overlap.py \ No newline at end of file diff --git a/.obsidian/app.json b/.obsidian/app.json new file mode 100644 index 0000000..9e26dfe --- /dev/null +++ b/.obsidian/app.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/.obsidian/appearance.json b/.obsidian/appearance.json new file mode 100644 index 0000000..c8c365d --- /dev/null +++ b/.obsidian/appearance.json @@ -0,0 +1,3 @@ +{ + "accentColor": "" +} \ No newline at end of file diff --git a/.obsidian/core-plugins-migration.json b/.obsidian/core-plugins-migration.json new file mode 100644 index 0000000..5c13490 --- /dev/null +++ b/.obsidian/core-plugins-migration.json @@ -0,0 +1,29 @@ +{ + "file-explorer": true, + "global-search": true, + "switcher": true, + "graph": true, + "backlink": true, + "canvas": true, + "outgoing-link": true, + "tag-pane": true, + "page-preview": true, + "daily-notes": true, + "templates": true, + "note-composer": true, + "command-palette": true, + "slash-command": false, + "editor-status": true, + "bookmarks": true, + "markdown-importer": false, + "zk-prefixer": false, + "random-note": false, + "outline": true, + "word-count": true, + "slides": false, + "audio-recorder": false, + "workspaces": false, + "file-recovery": true, + "publish": false, + "sync": false +} \ No newline at end of file diff --git a/.obsidian/core-plugins.json b/.obsidian/core-plugins.json new file mode 100644 index 0000000..9405bfd --- /dev/null +++ b/.obsidian/core-plugins.json @@ -0,0 +1,20 @@ +[ + "file-explorer", + "global-search", + "switcher", + "graph", + "backlink", + "canvas", + "outgoing-link", + "tag-pane", + "page-preview", + "daily-notes", + "templates", + "note-composer", + "command-palette", + "editor-status", + "bookmarks", + "outline", + "word-count", + "file-recovery" +] \ No newline at end of file diff --git a/.obsidian/hotkeys.json b/.obsidian/hotkeys.json new file mode 100644 index 0000000..9e26dfe --- /dev/null +++ b/.obsidian/hotkeys.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/.obsidian/workspace.json b/.obsidian/workspace.json new file mode 100644 index 0000000..52beaf4 --- /dev/null +++ b/.obsidian/workspace.json @@ -0,0 +1,154 @@ +{ + "main": { + "id": "8445fb092835941a", + "type": "split", + "children": [ + { + "id": "b58397fac2efd451", + "type": "tabs", + "children": [ + { + "id": "5fc49d43e2804e0c", + "type": "leaf", + "state": { + "type": "markdown", + "state": { + "file": "README.md", + "mode": "source", + "source": false + } + } + } + ] + } + ], + "direction": "vertical" + }, + "left": { + "id": "bfdce2ad38d38eed", + "type": "split", + "children": [ + { + "id": "cd9492099e21fcdd", + "type": "tabs", + "children": [ + { + "id": "89f8b50f92f50073", + "type": "leaf", + "state": { + "type": "file-explorer", + "state": { + "sortOrder": "alphabetical" + } + } + }, + { + "id": "1c18f75009cbd66d", + "type": "leaf", + "state": { + "type": "search", + "state": { + "query": "", + "matchingCase": false, + "explainSearch": false, + "collapseAll": false, + "extraContext": false, + "sortOrder": "alphabetical" + } + } + }, + { + "id": "eeb33e840466e5ba", + "type": "leaf", + "state": { + "type": "bookmarks", + "state": {} + } + } + ] + } + ], + "direction": "horizontal", + "width": 300 + }, + "right": { + "id": "643fe1bfd851892f", + "type": "split", + "children": [ + { + "id": "619dc1d6feffe37d", + "type": "tabs", + "children": [ + { + "id": "9288a5d9ca6bb612", + "type": "leaf", + "state": { + "type": "backlink", + "state": { + "file": "README.md", + "collapseAll": false, + "extraContext": false, + "sortOrder": "alphabetical", + "showSearch": false, + "searchQuery": "", + "backlinkCollapsed": false, + "unlinkedCollapsed": true + } + } + }, + { + "id": "271fe66f65a58a49", + "type": "leaf", + "state": { + "type": "outgoing-link", + "state": { + "file": "README.md", + "linksCollapsed": false, + "unlinkedCollapsed": true + } + } + }, + { + "id": "3bbb82858aa2033c", + "type": "leaf", + "state": { + "type": "tag", + "state": { + "sortOrder": "frequency", + "useHierarchy": true + } + } + }, + { + "id": "8abebd45c0b7f8b1", + "type": "leaf", + "state": { + "type": "outline", + "state": { + "file": "README.md" + } + } + } + ] + } + ], + "direction": "horizontal", + "width": 300, + "collapsed": true + }, + "left-ribbon": { + "hiddenItems": { + "switcher:Open quick switcher": false, + "graph:Open graph view": false, + "canvas:Create new canvas": false, + "daily-notes:Open today's daily note": false, + "templates:Insert template": false, + "command-palette:Open command palette": false + } + }, + "active": "5fc49d43e2804e0c", + "lastOpenFiles": [ + "README.md.md", + "README.md" + ] +} \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..dd94179 --- /dev/null +++ b/README.md @@ -0,0 +1,36 @@ +## About :bookmark_tabs: + +Py-Planes is a Python written offline game where the player takes the control of a airplane and fight against enemies. The game consists of two separate components -> Launcher (Main Menu) written in Qt Framework and the game itself made with PyGame. + +The Launcher is made with few different files, the logic is separated and there are relations between the files managing the execution of the specific menu, based on the player's actions. + +The PyGame files are running the game itself, initializing the levels, the players, the enemies and the surrounding objects. + +Py-Planes is executed as one game, but in the back-end are actually two separated applications running simultaneously and communicating one with another. + +The user and game settings are stored in a JSON files which contents are being read and submitted to specific object in the front-end. The settings are also used for the PyGame logic giving the user's plane specific abilities as damage, health, armor, etc. and setting the game fps. + +## Guideline :book: + +## Tech-Stack :building_construction: + +* Python 3.10 > +* [PyQt5 - Qt Framework](https://www.qt.io/product/framework) library ported for Python +* [PyGame](https://www.pygame.org/news) +* [Pixilart](https://www.pixilart.com/) +* [Git](https://git-scm.com/) +* [GitHub](https://github.com/) & [GitHub Projects](https://github.com/Stake-And-Rope/py-planes/projects?query=is%3Aopen) +* [Obisidan](https://obsidian.md/) + +## Team-Project :woman_factory_worker: :factory_worker: :mechanic: + +Py-Planes is a hobby-project created by students and professionals, aiming to create an environment for training and gaining new skills. + +## Contributors :mechanic: + +[rayapetkova](https://github.com/rayapetkova) + +[kumchovylcho](https://github.com/orgs/Stake-And-Rope/people/kumchovylcho) + +[karastoyanov](https://github.com/karastoyanov) + diff --git a/fonts/American Captain.otf b/fonts/American Captain.otf new file mode 100644 index 0000000..9e73224 Binary files /dev/null and b/fonts/American Captain.otf differ diff --git a/fonts/American Captain.ttf b/fonts/American Captain.ttf new file mode 100644 index 0000000..bc53cb7 Binary files /dev/null and b/fonts/American Captain.ttf differ diff --git a/fonts/American Captain.txt b/fonts/American Captain.txt new file mode 100644 index 0000000..927c1c3 --- /dev/null +++ b/fonts/American Captain.txt @@ -0,0 +1,19 @@ +UPDATE: American Captain is ready for BUY NOW & IMMEDIATE DOWNLOAD via secure paypal checkout. +http://thefontry.com/americancaptain + +UPDATE TO LANGUAGE SUPPORT: This freeware version now includes uppercase GREEK and CYRILLIC letters. + +UPDATE: American Captain is now available in commercial form as a 6-FONT FAMILY with complete character sets and language support for Central European characters, Cyrillic, Greek and Hebrew. OpenType features include: small caps, fractions, stylistic sets, glyph replacements, etc. Now back to our freebie ... + +American Captain by Michael G. Adkins + +So here we go with the descriptions again. To describe my new font, American Captain, the boring part of my brain tells me to use staid words like narrow and bold, sharp yet blunt, heavy and tall; but deep within the creative side of my brain, there's a smouldering nugget of inspiration that tells me this font deserves something more. Why bother to explain things you can clearly see with your own eyes, when what you might not be aware of is this font's unique origins. What you might not know is that it dates back to at least the 1940s. It's even possible you don't understand how this font has been reborn and revamped and revitalized by generations of sign-painters and hand-letterers and determined font guys like myself who just can't let this thing go. + +This font represents the unparalleled strength of one man who saved an entire world from the crushing yoke of tyranny. This man was an outstanding captain of men, an American patriot of unquestionable calibre. And within this font is captured his fighting spirit, his unyielding determination. This face is dedicated to him, the captain America knows and respects, the captain America font designers like myself strive to symbolize in their work. So enjoy the power that is the font I call, American Captain. + +For commercial use please feel free to contact us for price, links and details at: +the_fontry@yahoo.com + +or visit the Fontry website +http://www.thefontry.com/ + diff --git a/fonts/PersonalUseEULA.txt b/fonts/PersonalUseEULA.txt new file mode 100644 index 0000000..b7496e7 --- /dev/null +++ b/fonts/PersonalUseEULA.txt @@ -0,0 +1,48 @@ +You have downloaded the files for the font American Captain. The following is the personal use EULA. For commercial usage, please contact the Fontry at the_fontry@yahoo.com or visit the Fontry website http://www.thefontry.com. Look for the full version to be available in future. This and other Fontry fonts are available at Fonts.com and MyFonts.com keyword search fontry. + +Thank You from the Fontry. + +By downloading this file, you are agreeing to be bound by the terms of this Agreement. This Agreement constitutes the complete agreement between you and the Fontry / Fontry West. + +1. Allowed uses + +You may use the licensed fonts to create images on any surface such as computer screens, paper, web pages, photographs, movie credits, printed material, T-shirts, and other surfaces where the image is a fixed size as long as the resulting items are not for sale for a commercial entity or business. + +You may use the licensed fonts to create EPS files or other scalable drawings provided that such files are only used by the person licensing the font. + +Examples of personal uses permitted by this license include: family birthday or party invitations, school work, personal scrapbooking, personal garage sale flyers, personal stationary, personal web sites. + +2. Number of users + +There can be any number of simultaneous users providing that all users belong to the same company or household downloading the font. + +3. Third parties + +You may not provide the font or make it accessible to any third parties. + +4. Embedding + +You may embed the licensed fonts into any document you send to third parties. Such documents may be viewed and printed (but not edited) by the recipients. + +You may not under any circumstances embed the licensed fonts into software or hardware products in which the fonts will be used by the purchasers of such products. Such use requires a different license which may be offered by the Fontry / Fontry West. Please contact thefontry@yahoo.com for further information. + +5. Modifications + +You may import characters from the font as graphical objects into a drawing program and modify such graphical objects. + +You may not modify, adapt, translate, reverse engineer, decompile, disassemble, or create derivative works based on the licensed font itself without Foundry's prior written consent. + +6. Copyright + +The font and the accompanying materials are copyrighted and contain proprietary information and trade secrets belonging to the Fontry / Fontry West. Unauthorized copying of the Product even if modified, merged, or included with other software, or of the written materials, is expressly forbidden. You may be held legally responsible for any infringement of the Fontry / Fontry West intellectual property rights that is caused or encouraged by your failure to abide by the terms of this Agreement. + +7. Termination + +This Agreement is effective until terminated. This Agreement will terminate automatically without notice from the Fontry / Fontry West if you fail to comply with any provision contained herein. Upon termination, you must destroy the written materials, the Product, and all copies of them, in part and in whole, including modified copies, if any. + + +8. Product Upgrades + +The Fontry / Fontry West may, from time to time, update the Product. Product upgrade pricing may apply. + + diff --git a/game/__init__.py b/game/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/game/background_loop.py b/game/background_loop.py new file mode 100644 index 0000000..09cf466 --- /dev/null +++ b/game/background_loop.py @@ -0,0 +1,36 @@ +from pygame import image + +from game.helpers import get_background_roll_speed + + +class BackgroundLoop: + def __init__(self, fps: int): + self.background = image.load('../images/environment/ocean.png').convert_alpha() + self.background_rect = self.background.get_rect() + + self.background_y_1 = 0 + self.x = 0 + + self.background_y_2 = self.background_rect.height + + self.roll_speed = get_background_roll_speed(fps) + + def update(self): + self.background_y_1 += self.roll_speed + self.background_y_2 += self.roll_speed + + rect_height = self.background_rect.height + + if self.background_y_1 >= rect_height: + self.background_y_1 = -rect_height + + if self.background_y_2 >= rect_height: + self.background_y_2 = -rect_height + + def render(self, window): + window.blit(self.background, (self.x, self.background_y_1)) + window.blit(self.background, (self.x, self.background_y_2)) + + def loop_background(self, window): + self.update() + self.render(window) \ No newline at end of file diff --git a/game/bar.py b/game/bar.py new file mode 100644 index 0000000..56bd137 --- /dev/null +++ b/game/bar.py @@ -0,0 +1,36 @@ +import pygame + + +class Bar: + def __init__(self, x, y, width, height, max_value, top_colour, bottom_colour): + self.x = x + self.y = y + self.width = width + self.current_width = width + self.height = height + self.max_value = max_value + self.current_value = max_value + self.top_colour = top_colour + self.bottom_colour = bottom_colour + + def draw_bar(self, window, hide_bar_when_empty=False): + if self.current_value <= 0 and hide_bar_when_empty: + return + + pygame.draw.rect(window, self.bottom_colour, (self.x, self.y, self.width, self.height), border_radius=3) + pygame.draw.rect(window, self.top_colour, (self.x, self.y, self.current_width, self.height), border_radius=3) + + def reduce_bar(self, damage_value): + self.current_value -= damage_value + self.lower_upper_bar_width() + + def increase_bar(self, increase_value): + self.current_value += increase_value + + def lower_upper_bar_width(self): + result_width = (self.current_value / self.max_value) * self.width + + if result_width <= 0: + self.current_width = 0 + else: + self.current_width = result_width diff --git a/game/bullets/__init__.py b/game/bullets/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/game/bullets/__pycache__/__init__.cpython-311.pyc b/game/bullets/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000..d86fcef Binary files /dev/null and b/game/bullets/__pycache__/__init__.cpython-311.pyc differ diff --git a/game/bullets/__pycache__/bullet.cpython-311.pyc b/game/bullets/__pycache__/bullet.cpython-311.pyc new file mode 100644 index 0000000..b12c709 Binary files /dev/null and b/game/bullets/__pycache__/bullet.cpython-311.pyc differ diff --git a/game/bullets/__pycache__/enemy_bullet.cpython-311.pyc b/game/bullets/__pycache__/enemy_bullet.cpython-311.pyc new file mode 100644 index 0000000..5bd9e0c Binary files /dev/null and b/game/bullets/__pycache__/enemy_bullet.cpython-311.pyc differ diff --git a/game/bullets/__pycache__/user_bullet.cpython-311.pyc b/game/bullets/__pycache__/user_bullet.cpython-311.pyc new file mode 100644 index 0000000..9b55dee Binary files /dev/null and b/game/bullets/__pycache__/user_bullet.cpython-311.pyc differ diff --git a/game/bullets/bullet.py b/game/bullets/bullet.py new file mode 100644 index 0000000..c34e283 --- /dev/null +++ b/game/bullets/bullet.py @@ -0,0 +1,37 @@ +from abc import (ABC, + abstractmethod + ) + +import pygame +from pygame import image + +from game.helpers import get_bullet_speed +from settings.settings_handler import get_game_settings + +from game.float_rect import FloatRect + + +fps = int(get_game_settings().get("fps")) +bullet_speed = get_bullet_speed(fps) + + +class Bullet(ABC): + image = image.load("../images/user_plane_images/user_bullet.png").convert_alpha() + bullet_speed = get_bullet_speed(fps) + + def __init__(self, bullet_x: float, bullet_y: float): + self.bullet_x = bullet_x + self.bullet_y = bullet_y + self.regular_rect = self.image.get_rect() + self.image_width = self.regular_rect[2] + self.image_height = self.regular_rect[3] + self.float_rect = FloatRect(bullet_x, bullet_y, self.image_width, self.image_height) + self.bullet_mask = pygame.mask.from_surface(self.image) + + @property + def get_bullet_pos(self): + return self.bullet_x, self.bullet_y + + @abstractmethod + def move_bullet(self): + pass diff --git a/game/bullets/enemy_bullet.py b/game/bullets/enemy_bullet.py new file mode 100644 index 0000000..e202a19 --- /dev/null +++ b/game/bullets/enemy_bullet.py @@ -0,0 +1,13 @@ +from game.bullets.bullet import Bullet +from pygame import image + + +class EnemyBullet(Bullet): + image = image.load("../images/enemy_plane_images/enemy_bullet.png").convert_alpha() + + def __init__(self, bullet_x: float, bullet_y: float): + super().__init__(bullet_x, bullet_y) + + def move_bullet(self): + self.bullet_y += self.bullet_speed + self.float_rect.y += self.bullet_speed diff --git a/game/bullets/tower_bullet.py b/game/bullets/tower_bullet.py new file mode 100644 index 0000000..cc0c55f --- /dev/null +++ b/game/bullets/tower_bullet.py @@ -0,0 +1,31 @@ +import math + +from game.bullets.bullet import Bullet +from pygame import image + + +class TowerBullet(Bullet): + image = image.load("../images/enemy_plane_images/enemy_bullet.png").convert_alpha() + + def __init__(self, + bullet_x: float, + bullet_y: float, + target + ): + super().__init__(bullet_x, bullet_y) + self.target_x = target.x_pos + self.target_y = target.y_pos + self.target_rect = target.float_rect + self.direction_radians = self.calculate_direction() + + def calculate_direction(self): + return math.atan2(self.target_y + (self.target_rect.height // 2) - self.bullet_y, + self.target_x + (self.target_rect.width // 2) - self.bullet_x + ) + + def move_bullet(self): + self.bullet_x += self.bullet_speed * math.cos(self.direction_radians) + self.bullet_y += self.bullet_speed * math.sin(self.direction_radians) + + self.float_rect.x += self.bullet_speed * math.cos(self.direction_radians) + self.float_rect.y += self.bullet_speed * math.sin(self.direction_radians) diff --git a/game/bullets/user_bullet.py b/game/bullets/user_bullet.py new file mode 100644 index 0000000..69d52fd --- /dev/null +++ b/game/bullets/user_bullet.py @@ -0,0 +1,11 @@ +from game.bullets.bullet import Bullet + + +class UserBullet(Bullet): + + def __init__(self, bullet_x: float, bullet_y: float): + super().__init__(bullet_x, bullet_y) + + def move_bullet(self): + self.bullet_y -= self.bullet_speed + self.float_rect.y -= self.bullet_speed diff --git a/game/collision.py b/game/collision.py new file mode 100644 index 0000000..d0602da --- /dev/null +++ b/game/collision.py @@ -0,0 +1,71 @@ +from game.float_rect import float_rects_collide + + +def collision(curr_enemy, curr_plane): + not_collided_bullets = [] + + for bullet in curr_enemy.bullets: + if float_rects_collide(bullet.float_rect, curr_plane.float_rect): + bullet_mask = bullet.bullet_mask + user_plane_mask = curr_plane.plane_mask + + if not user_plane_mask.overlap(bullet_mask, + (int(bullet.float_rect.x) - int(curr_plane.float_rect.x), int(bullet.float_rect.y) - int(curr_plane.float_rect.y))): + not_collided_bullets.append(bullet) + else: + not_collided_bullets.append(bullet) + + if len(not_collided_bullets) < len(curr_enemy.bullets): + len_all_enemy_bullets, len_all_not_collided_bullets = len(curr_enemy.bullets), len(not_collided_bullets) + curr_enemy.bullets = not_collided_bullets + return len_all_enemy_bullets - len_all_not_collided_bullets + + return False + + +def check_user_plane_collision(all_enemies, c_user_plane): + REDUCE_TIMES_USER_PLANE = 1 + + for enemy_plane in all_enemies.enemy_planes: + enemy_planes_damage = collision(enemy_plane, c_user_plane) + + if c_user_plane.armor_bar.current_width == 0: + c_user_plane.health_bar.reduce_bar(1 * enemy_planes_damage) + else: + c_user_plane.armor_bar.reduce_bar(1 * enemy_planes_damage) + + for enemy_tower in all_enemies.towers: + towers_damage = collision(enemy_tower, c_user_plane) + + if c_user_plane.armor_bar.current_width == 0: + c_user_plane.health_bar.reduce_bar(REDUCE_TIMES_USER_PLANE * towers_damage) + else: + c_user_plane.armor_bar.reduce_bar(REDUCE_TIMES_USER_PLANE * towers_damage) + + +def check_enemy_collision(all_enemies, c_user_plane): + REDUCE_TIMES_ENEMY_OR_TOWER = 5 + + for enemy_plane in all_enemies.enemy_planes: + damage = collision(c_user_plane, enemy_plane) + + enemy_plane.enemy_health_bar.reduce_bar(REDUCE_TIMES_ENEMY_OR_TOWER * damage) + + for enemy_tower in all_enemies.towers: + damage = collision(c_user_plane, enemy_tower) + + enemy_tower.enemy_health_bar.reduce_bar(REDUCE_TIMES_ENEMY_OR_TOWER * damage) + + +def check_user_plane_and_enemies_collision(all_enemies, c_user_plane): + curr_enemies = all_enemies.enemy_planes + all_enemies.towers + + for enemy_plane in curr_enemies: + if float_rects_collide(enemy_plane.float_rect, c_user_plane.float_rect): + enemy_plane_mask = enemy_plane.plane_mask + user_plane_mask = c_user_plane.plane_mask + + if user_plane_mask.overlap(enemy_plane_mask, + (int(enemy_plane.float_rect.x) - int(c_user_plane.float_rect.x), + int(enemy_plane.float_rect.y) - int(c_user_plane.float_rect.y))): + return True \ No newline at end of file diff --git a/game/extra_bullets_powerup.py b/game/extra_bullets_powerup.py new file mode 100644 index 0000000..ee5ca52 --- /dev/null +++ b/game/extra_bullets_powerup.py @@ -0,0 +1,41 @@ +from random import randint + +from pygame import Surface + +from game import float_rect as rect +from helpers import get_screen_dimensions + +SCREEN_WIDTH, _ = get_screen_dimensions() + + +class ExtraBulletsPowerUp: + + def __init__(self, image: Surface): + self.image = image + self.rect = self.image.get_rect() + + self.start_x = self.random_x_spawn() + self.start_y = -self.rect.height + + self.float_rect = rect.FloatRect(x=self.start_x, + y=self.start_y, + width=self.rect.width, + height=self.rect.height + ) + + self.drop_speed = 3 + + def random_x_spawn(self): + return randint(0, SCREEN_WIDTH - self.rect.width) + + def reset_position(self): + self.float_rect.x = self.start_x + self.float_rect.y = self.start_y + + def render(self, screen): + self.float_rect.y += self.drop_speed + + screen.blit(self.image, (self.float_rect.x, self.float_rect.y)) + + def collide(self, plane): + return rect.float_rects_collide(self.float_rect, plane.float_rect) \ No newline at end of file diff --git a/game/float_rect.py b/game/float_rect.py new file mode 100644 index 0000000..29e2f85 --- /dev/null +++ b/game/float_rect.py @@ -0,0 +1,13 @@ +class FloatRect: + def __init__(self, x, y, width, height): + self.x = x + self.y = y + self.width = width + self.height = height + + +def float_rects_collide(rect1, rect2): + return (rect1.x < rect2.x + rect2.width and + rect2.x < rect1.x + rect1.width and + rect1.y < rect2.y + rect2.height and + rect2.y < rect1.y + rect1.height) diff --git a/game/helpers.py b/game/helpers.py new file mode 100644 index 0000000..26f6675 --- /dev/null +++ b/game/helpers.py @@ -0,0 +1,68 @@ +import random + + +def get_plane_speed(fps: int) -> float: + plane_speed = { + 45: 4.5, + 60: 3.5, + 75: 2.5, + } + + return plane_speed.get(fps) + + +def get_enemy_plane_speed(fps: int) -> float: + plane_speed = { + 45: 0.667, + 60: 0.5, + 75: 0.4, + } + + return plane_speed.get(fps) + + +def get_bullet_speed(fps: int) -> float: + bullet_speed = { + 45: 4.5, + 60: 3.5, + 75: 2.5, + } + + return bullet_speed.get(fps) + + +def get_background_roll_speed(fps: int) -> float: + looping_speed = { + 45: 2, + 60: 1.6, + 75: 1.2, + } + + return looping_speed.get(fps) + + +def calculate_center(main_obj_width, child_obj_width): + """ + run this code to visually see how it is being calculated + -- pygame.draw.rect(screen, (255, 0, 0), (window_size[0] // 2, 0, 1, window_size[1]), 1) -- + -- pg .draw.rect(screen, (255, 0, 0), (window_size[0] // 2, 0, 1, window_size[1]), 1) -- + + :return: int(pixels) of the X position where the child object must be placed + """ + middle_of_main_obj = main_obj_width // 2 + middle_of_child_obj = child_obj_width // 2 + + + return middle_of_main_obj - middle_of_child_obj + + +def get_screen_dimensions() -> tuple: + return 900, 800 + + +def random_enemy_plane_coordinates(): + return random.randint(0, 736 - 1), -64 + + +def get_random_image_of_enemy_planes(planes: list): + return planes[random.randint(0, len(planes) - 1)] \ No newline at end of file diff --git a/game/planes/__init__.py b/game/planes/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/game/planes/__pycache__/__init__.cpython-311.pyc b/game/planes/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000..8c69d59 Binary files /dev/null and b/game/planes/__pycache__/__init__.cpython-311.pyc differ diff --git a/game/planes/__pycache__/base_plane.cpython-311.pyc b/game/planes/__pycache__/base_plane.cpython-311.pyc new file mode 100644 index 0000000..0fb37c8 Binary files /dev/null and b/game/planes/__pycache__/base_plane.cpython-311.pyc differ diff --git a/game/planes/__pycache__/enemy_plane.cpython-311.pyc b/game/planes/__pycache__/enemy_plane.cpython-311.pyc new file mode 100644 index 0000000..2d90d66 Binary files /dev/null and b/game/planes/__pycache__/enemy_plane.cpython-311.pyc differ diff --git a/game/planes/__pycache__/user_plane.cpython-311.pyc b/game/planes/__pycache__/user_plane.cpython-311.pyc new file mode 100644 index 0000000..9d5d947 Binary files /dev/null and b/game/planes/__pycache__/user_plane.cpython-311.pyc differ diff --git a/game/planes/base_plane.py b/game/planes/base_plane.py new file mode 100644 index 0000000..3d92739 --- /dev/null +++ b/game/planes/base_plane.py @@ -0,0 +1,135 @@ +#!/usr/bin/python3 +from abc import (ABC, + abstractmethod, + ) + +import pygame as pg +from pygame import Surface + +from game import helpers +from game.helpers import get_screen_dimensions +from settings.settings_handler import get_game_settings + +SCREEN_WIDTH, SCREEN_HEIGHT = get_screen_dimensions() +from game.float_rect import FloatRect +from game.bar import Bar + + +class BasePlane(ABC): + GAME_FPS = int(get_game_settings().get("fps")) + plane_speed = helpers.get_plane_speed(GAME_FPS) + + def __init__(self, model: Surface, health: int, armor: int, damage: int): + self.model = model + self.plane_mask = pg.mask.from_surface(model) + self.regular_rect = self.model.get_rect() + self.height = self.regular_rect.height + self.width = self.regular_rect.width + self.float_rect = FloatRect(None, None, self.width, self.height) + self.x_pos = None + self.y_pos = None + + self.health = health + self.armor = armor + self.damage = damage + + self.enemy_bar_width = self.width // 1.2 + self.enemy_bar_height = 10 + + self.shoot_bullets_amount = 2 + self.shooting_cooldown = 0 + self.bullets = [] + + @property + @abstractmethod + def get_weapons_locations(self): + pass + + @property + @abstractmethod + def get_shoot_cd(self): + pass + + @property + def can_shoot_bullet(self): + return self.shooting_cooldown <= 0 + + @property + def get_plane_pos(self): + """ + returns tuple (x, y) to make it easier to image blit + """ + return self.x_pos, self.y_pos + + @abstractmethod + def set_spawn_point(self, x_pos: int, y_pos: int): + pass + + @abstractmethod + def remove_out_of_boundary_bullets(self): + pass + + def auto_create_enemy_health_bar(self): + bar = Bar(x=helpers.calculate_center(self.width, self.enemy_bar_width) + self.x_pos, + y=self.y_pos - self.enemy_bar_height, + width=self.enemy_bar_width, + height=self.enemy_bar_height, + max_value=self.health, + top_colour=(0, 153, 0), + bottom_colour=(128, 128, 128), + ) + setattr(self, "enemy_health_bar", bar) + setattr(self, "enemy_gap_on_both_ends_of_bar", bar.x - self.x_pos) + + def auto_create_enemy_armor_bar(self): + bar = Bar(x=helpers.calculate_center(self.width, self.enemy_bar_width) + self.x_pos, + y=self.y_pos - self.enemy_bar_height, + width=self.enemy_bar_width, + height=self.enemy_bar_height, + max_value=self.armor, + top_colour=(21, 43, 79), + bottom_colour=(128, 128, 128), + ) + setattr(self, "enemy_armor_bar", bar) + + def create_user_bar(self, + bar_type: str, + x: float, + y: float, + width: int, + height: int, + max_value: int, + top_color: tuple, + bottom_color: tuple): + bar = Bar(x=x, + y=y, + width=width, + height=height, + max_value=max_value, + top_colour=top_color, + bottom_colour=bottom_color, + ) + setattr(self, bar_type, bar) + + def lower_shoot_cooldown(self): + self.shooting_cooldown -= 1 / self.GAME_FPS + + if self.can_shoot_bullet: + self.shooting_cooldown = 0 + + def update_shot_bullets(self, screen): + """ + 1. looping through all the bullets on the screen + 2. updating the shot bullet + 3. displaying each bullet on screen + 4. removing the bullets which went out of the screen + """ + + for bullet in self.bullets: + bullet.move_bullet() + screen.blit(bullet.image, bullet.get_bullet_pos) + + self.remove_out_of_boundary_bullets() + + def display_plane(self, window): + window.blit(self.model, self.get_plane_pos) diff --git a/game/planes/control_enemies.py b/game/planes/control_enemies.py new file mode 100644 index 0000000..712c810 --- /dev/null +++ b/game/planes/control_enemies.py @@ -0,0 +1,38 @@ +from game.helpers import random_enemy_plane_coordinates +from game.planes.enemy_plane import EnemyPlane +from game.planes.enemy_tower import Tower + + +class EnemyController: + + def __init__(self): + self.enemy_planes = [] + self.towers = [] + + def add_enemy(self, enemy): + random_x_spawn = random_enemy_plane_coordinates() + enemy.set_spawn_point(*random_x_spawn) + enemy.auto_create_enemy_health_bar() + enemy.auto_create_enemy_armor_bar() + + if isinstance(enemy, EnemyPlane): + self.enemy_planes.append(enemy) + + elif isinstance(enemy, Tower): + self.towers.append(enemy) + + def update_planes(self, screen): + for plane in self.enemy_planes: + plane.functionality() + plane.enemy_health_bar.draw_bar(window=screen, hide_bar_when_empty=True) + # TODO: add armor logic + plane.display_plane(screen) + plane.update_shot_bullets(screen) + + def update_towers(self, screen, user_plane): + for tower in self.towers: + tower.enemy_health_bar.draw_bar(window=screen, hide_bar_when_empty=True) + # TODO: add armor logic + tower.display_plane(screen) + tower.functionality(screen, user_plane) + tower.update_shot_bullets(screen) \ No newline at end of file diff --git a/game/planes/enemy_plane.py b/game/planes/enemy_plane.py new file mode 100644 index 0000000..a68f869 --- /dev/null +++ b/game/planes/enemy_plane.py @@ -0,0 +1,132 @@ +import random + +from game.bullets.enemy_bullet import EnemyBullet +from game.helpers import (get_screen_dimensions, + get_enemy_plane_speed, + ) +from game.planes.base_plane import BasePlane + +SCREEN_WIDTH, SCREEN_HEIGHT = get_screen_dimensions() + + +class EnemyPlane(BasePlane): + plane_speed = get_enemy_plane_speed(BasePlane.GAME_FPS) + + def __init__(self, model, health, armor, damage): + super().__init__(model, health, armor, damage) + self.x_direction = 0 + self.distance_until_next_direction = 0 + self.change_direction_every_traveled_pixels = 300 + + @property + def get_shoot_cd(self): + return 1.5 + + @property + def get_weapons_locations(self): + """ + :return: ( + (left_outer_weapon, plane_y), + (right_outer_weapon, plane_y), + (left_inner_weapon, plane_y), + (right_inner_weapon, plane_y) + ) + """ + + y_pos = self.y_pos + self.height - 6 + + inner_weapons_pos = ((self.x_pos + 11, y_pos), (self.x_pos + 50, y_pos)) + outer_weapons_pos = ((self.x_pos + 6, y_pos), (self.x_pos + 56, y_pos)) + + return outer_weapons_pos + inner_weapons_pos + + @property + def is_below_screen(self): + return self.y_pos > SCREEN_HEIGHT + + @property + def can_change_direction(self): + return self.distance_until_next_direction <= 0 + + def random_enemy_plane_direction(self): + direction = random.choice( + (self.plane_speed, -self.plane_speed) + ) + + self.x_direction = direction + + def handle_x_direction(self): + self.distance_until_next_direction -= abs(self.x_direction) + self.plane_speed + + if self.can_change_direction: + self.random_enemy_plane_direction() + self.distance_until_next_direction = self.change_direction_every_traveled_pixels + + def set_spawn_point(self, x_pos: int, y_pos: int): + error_message = "" + if y_pos != -self.height: + error_message = f"Plane must be spawned at {-self.height} pixels of Y coordinate." + + if x_pos < 0 or x_pos > SCREEN_WIDTH - self.width: + error_message = f"Plane X coordinates must be between 0 and {SCREEN_WIDTH - self.width} pixels." + + if any(not isinstance(x, int) for x in (x_pos, y_pos)): + error_message = "Coordinates must be integer values." + + if error_message: + raise ValueError(error_message) + + self.x_pos = x_pos + self.y_pos = y_pos + + self.float_rect.x = x_pos + self.float_rect.y = y_pos + + def check_plane_boundaries(self): + right_border = SCREEN_WIDTH - self.float_rect.width + + if self.x_pos < 0: + self.x_pos = 0 + self.float_rect.x = 0 + self.enemy_health_bar.x = self.enemy_gap_on_both_ends_of_bar + self.enemy_armor_bar.x = self.enemy_gap_on_both_ends_of_bar + + elif self.x_pos >= right_border: + self.x_pos = right_border + self.float_rect.x = right_border + self.enemy_health_bar.x = right_border + self.enemy_gap_on_both_ends_of_bar + self.enemy_armor_bar.x = right_border + self.enemy_gap_on_both_ends_of_bar + + def functionality(self): + self.y_pos += self.plane_speed + self.x_pos += self.x_direction + + self.float_rect.y += self.plane_speed + self.float_rect.x += self.x_direction + + self.enemy_health_bar.x += self.x_direction + self.enemy_health_bar.y += self.plane_speed + + self.enemy_armor_bar.x += self.x_direction + self.enemy_armor_bar.y += self.plane_speed + + if self.can_shoot_bullet: + self.shoot_bullet() + + if not self.can_shoot_bullet: + self.lower_shoot_cooldown() + + self.check_plane_boundaries() + self.handle_x_direction() + + def shoot_bullet(self): + for wep_x, wep_y in self.get_weapons_locations[:self.shoot_bullets_amount]: + create_bullet = EnemyBullet(wep_x, wep_y) + + self.bullets.append(create_bullet) + + self.shooting_cooldown = self.get_shoot_cd + + def remove_out_of_boundary_bullets(self): + self.bullets = [bullet for bullet in self.bullets if bullet.float_rect.height + bullet.bullet_y < SCREEN_HEIGHT] + diff --git a/game/planes/enemy_tower.py b/game/planes/enemy_tower.py new file mode 100644 index 0000000..38358a4 --- /dev/null +++ b/game/planes/enemy_tower.py @@ -0,0 +1,120 @@ +import math +import pygame as pg + +from game.bullets.tower_bullet import TowerBullet +from game.helpers import (get_screen_dimensions, + calculate_center, + get_enemy_plane_speed + ) +from game.planes.base_plane import BasePlane + +SCREEN_WIDTH, SCREEN_HEIGHT = get_screen_dimensions() + + +class Tower(BasePlane): + plane_speed = get_enemy_plane_speed(BasePlane.GAME_FPS) + + def __init__(self, tower_img, health, armor, damage): + super().__init__(tower_img, health, armor, damage) + self.shoot_bullets_amount = 1 + self.weapon_width = 8 + self.weapon_length = 40 + + @property + def get_weapons_locations(self): + center_x = calculate_center(self.width, self.weapon_width) + self.x_pos + self.weapon_width // 2 + center_y = calculate_center(self.height, self.weapon_width) + self.y_pos + self.weapon_width // 2 + return center_x, center_y + + + @property + def get_shoot_cd(self): + return 1.3 + + def set_spawn_point(self, x_pos: int, y_pos: int): + error_message = "" + if y_pos != -self.height: + error_message = f"Tower must be spawned at {-self.height} pixels of Y coordinate." + + if x_pos < 0 or x_pos > SCREEN_WIDTH - self.width: + error_message = f"Tower X coordinates must be between 0 and {SCREEN_WIDTH - self.width} pixels." + + if any(not isinstance(x, int) for x in (x_pos, y_pos)): + error_message = "Coordinates must be integer values." + + if error_message: + raise ValueError(error_message) + + self.x_pos = x_pos + self.y_pos = y_pos + + self.float_rect.x = x_pos + self.float_rect.y = y_pos + + def get_fire_bullet_exit_point(self, user_plane): + tower_x, tower_y = self.get_weapons_locations + + direction = (user_plane.x_pos + (user_plane.float_rect.width // 2) - tower_x, + user_plane.y_pos + (user_plane.float_rect.height // 2) - tower_y) + + distance = math.sqrt(direction[0] ** 2 + direction[1] ** 2) + + normalized_direction = (direction[0] / distance, direction[1] / distance) + + scaled_direction = (normalized_direction[0] * self.weapon_length, normalized_direction[1] * self.weapon_length) + + line_endpoint = (tower_x + scaled_direction[0], tower_y + scaled_direction[1]) + + return line_endpoint + + def functionality(self,screen, user_plane): + self.y_pos += self.plane_speed + self.float_rect.y += self.plane_speed + + self.enemy_health_bar.y += self.plane_speed + self.enemy_armor_bar.y += self.plane_speed + + if self.can_shoot_bullet: + self.shoot_bullet(user_plane) + + if not self.can_shoot_bullet: + self.lower_shoot_cooldown() + + pg.draw.line(screen, + (0, 0, 0), # color + self.get_weapons_locations, # start of line + self.get_fire_bullet_exit_point(user_plane), # end of line + self.weapon_width # line thickness + ) + + def shoot_bullet(self, user_plane): + bullet_x, bullet_y = self.get_fire_bullet_exit_point(user_plane) + + bullet = TowerBullet(bullet_x=bullet_x, + bullet_y=bullet_y, + target=user_plane, + ) + + self.bullets.append(bullet) + + self.shooting_cooldown = self.get_shoot_cd + + def remove_out_of_boundary_bullets(self): + on_screen_bullets = [] + + for bullet in self.bullets: + if bullet.bullet_x > SCREEN_WIDTH: + continue + + if bullet.bullet_x + bullet.float_rect.width < 0: + continue + + if bullet.bullet_y + bullet.float_rect.height < 0: + continue + + if bullet.bullet_y > SCREEN_HEIGHT: + continue + + on_screen_bullets.append(bullet) + + self.bullets = on_screen_bullets \ No newline at end of file diff --git a/game/planes/user_plane.py b/game/planes/user_plane.py new file mode 100644 index 0000000..ef29144 --- /dev/null +++ b/game/planes/user_plane.py @@ -0,0 +1,176 @@ +#!/usr/bin/python3 + +import pygame as pg + +from game.bullets.user_bullet import UserBullet +from game.helpers import get_screen_dimensions +from game.planes.base_plane import BasePlane + +SCREEN_WIDTH, SCREEN_HEIGHT = get_screen_dimensions() + +class UserPlane(BasePlane): + LEFT_RIGHT_KEYS = ("a", "d") + UP_DOWN_KEYS = ("w", "s") + SHOOT_BUTTON = " " + + def __init__(self, model, health, armor, damage): + super().__init__(model, health, armor, damage) + + self.extra_bullets_duration = 20 + self.duration_left = 0 + + @property + def get_shoot_cd(self): + return 0.5 + + @property + def get_weapons_locations(self): + """ + :return: ( + (left_outer_weapon, plane_y), + (right_outer_weapon, plane_y), + (left_inner_weapon, plane_y), + (right_inner_weapon, plane_y) + ) + """ + + inner_weapons_pos = ((self.x_pos + 11, self.y_pos), (self.x_pos + 50, self.y_pos)) + outer_weapons_pos = ((self.x_pos + 6, self.y_pos), (self.x_pos + 56, self.y_pos)) + + return outer_weapons_pos + inner_weapons_pos + + @property + def middle_screen_border(self): + return SCREEN_HEIGHT // 2.5 + + @property + def move_directions(self): + """ + map to get the buttons and the direction + """ + return { + pg.key.key_code(self.LEFT_RIGHT_KEYS[0]): -self.plane_speed, + pg.key.key_code(self.LEFT_RIGHT_KEYS[1]): self.plane_speed, + pg.key.key_code(self.UP_DOWN_KEYS[0]): -self.plane_speed, + pg.key.key_code(self.UP_DOWN_KEYS[1]): self.plane_speed, + } + + def set_spawn_point(self, + x_pos: int, + y_pos: int): + """ + sets the x and y coordinates if the given args are integers + raises value error if one of the args is not integer or if the args are with invalid destination + """ + + if any(not isinstance(value, int) for value in (x_pos, y_pos)): + raise ValueError("Values must be integers.") + + if y_pos < self.middle_screen_border: + raise ValueError(f"y_pos cannot be between 0 and {self.middle_screen_border} pixels.") + + screen_width, screen_height = get_screen_dimensions() + + if y_pos > screen_height - self.height: + raise ValueError(f"y_pos must be between {self.middle_screen_border} and {screen_height - self.height} pixels.") + + + if x_pos > screen_width - self.width or x_pos < 0: + raise ValueError(f"x_pos must be between 0 and {screen_width - self.width} pixels.") + + + self.x_pos = x_pos + self.y_pos = y_pos + + self.float_rect.x = x_pos + self.float_rect.y = y_pos + + def check_plane_boundaries(self): + """ + this method checks the following borders: + + 1. left border (trying to get out of the screen from the left side) + 2. right border (trying to get out of the screen from the right side) + 3. bottom border (trying to get out of the screen from the bottom side) + 4. middle border (trying to get above the invisible border in the middle) + + if out of border, the plane will get returned in the border. + """ + + right_border = SCREEN_WIDTH - self.width + bottom_border = SCREEN_HEIGHT - self.height + + if self.x_pos < 0: + self.x_pos = 0 + self.float_rect.x = 0 + + elif self.x_pos > right_border: + self.x_pos = right_border + self.float_rect.x = right_border + + if self.y_pos < self.middle_screen_border: + self.y_pos = self.middle_screen_border + self.float_rect.y = self.middle_screen_border + + elif self.y_pos > bottom_border: + self.y_pos = bottom_border + self.float_rect.y = bottom_border + + def functionality(self): + """ + updates the coordinates of the plane if the correct keys are pressed + shoots bullets if the correct button is pressed and if there is no cooldown + """ + + button_press = pg.key.get_pressed() + + for button in self.move_directions: + if button_press[button] and pg.key.name(button) in self.LEFT_RIGHT_KEYS: + self.x_pos += self.move_directions[button] + self.float_rect.x += self.move_directions[button] + + if button_press[button] and pg.key.name(button) in self.UP_DOWN_KEYS: + self.y_pos += self.move_directions[button] + self.float_rect.y += self.move_directions[button] + + self.check_plane_boundaries() + + if button_press[pg.key.key_code(self.SHOOT_BUTTON)] and self.can_shoot_bullet: + self.shoot_bullet() + + if not self.can_shoot_bullet: + self.lower_shoot_cooldown() + + self.lower_extra_bullets_duration() + + def shoot_bullet(self): + """ + 1. loops through the sliced tuple with the coordinates of the plane weapons + 2. creates a bullet for each weapon + 3. adds shoot cooldown after the bullets are fired + """ + + for wep_x, wep_y in self.get_weapons_locations[:self.shoot_bullets_amount]: + create_bullet = UserBullet(wep_x, wep_y) + + self.bullets.append(create_bullet) + + self.shooting_cooldown = self.get_shoot_cd + + def remove_out_of_boundary_bullets(self): + self.bullets = [bullet for bullet in self.bullets if bullet.bullet_y > 0] + + def receive_extra_bullets(self): + self.shoot_bullets_amount = 4 + self.duration_left = self.extra_bullets_duration + + def extra_bullets_fade_away(self): + self.shoot_bullets_amount = 2 + + def lower_extra_bullets_duration(self): + if self.duration_left > 0: + self.duration_left -= 1 / self.GAME_FPS + + if self.duration_left <= 0: + self.duration_left = 0 + self.extra_bullets_fade_away() diff --git a/game/powerup_controller.py b/game/powerup_controller.py new file mode 100644 index 0000000..5f5e64e --- /dev/null +++ b/game/powerup_controller.py @@ -0,0 +1,15 @@ +class PowerupController: + + def __init__(self): + self.extra_bullets = None + + def render_extra_bullets(self, screen, user_plane): + if self.extra_bullets is None: + return + + self.extra_bullets.render(screen=screen) + + if self.extra_bullets.collide(plane=user_plane): + self.extra_bullets.reset_position() + user_plane.receive_extra_bullets() + self.extra_bullets = None \ No newline at end of file diff --git a/game/run_game.py b/game/run_game.py new file mode 100755 index 0000000..3c9f6c3 --- /dev/null +++ b/game/run_game.py @@ -0,0 +1,137 @@ +#!/usr/bin/python3 +import pygame as pg + +import game.float_rect +from game.extra_bullets_powerup import ExtraBulletsPowerUp +from game.powerup_controller import PowerupController + +pg.init() + +import sys +from game.background_loop import BackgroundLoop +from settings.settings_handler import get_game_settings +from game import helpers + +window_size = helpers.get_screen_dimensions() +screen = pg.display.set_mode(window_size) +pg.display.set_caption("py-planes") + +from game.planes.user_plane import UserPlane +from game.planes.enemy_plane import EnemyPlane +from game.planes.control_enemies import EnemyController +from game.planes.enemy_tower import Tower +from game.collision import check_user_plane_collision, check_enemy_collision, check_user_plane_and_enemies_collision + +sys.path.append(r'..') + +user_settings = get_game_settings() + +fps = int(user_settings.get("fps")) + +user_plane_image = pg.image.load('../images/user_plane_images/user_plane_1.png').convert_alpha() # TODO: image must come from json +user_plane = UserPlane(user_plane_image, health=100, armor=100, damage=20) # TODO: hardcoded values must come from json +user_plane.set_spawn_point( + helpers.calculate_center(window_size[0], user_plane.model.get_width()), + 650 + ) +user_plane.create_user_bar( + bar_type="health_bar", # creates instance attr with that name + x=500, + y=760, + width=145, + height=25, + max_value=user_plane.health, + top_color=(21, 43, 79), + bottom_color=(110, 137, 181) + ) +user_plane.create_user_bar( + bar_type="armor_bar", # creates instance attr with that name + x=740, + y=760, + width=145, + height=25, + max_value=user_plane.armor, + top_color=(21, 43, 79), + bottom_color=(110, 137, 181) + ) + +background = BackgroundLoop(fps) +clock = pg.time.Clock() + +SPAWN_ENEMY_PLANE = pg.USEREVENT + 1 +pg.time.set_timer(SPAWN_ENEMY_PLANE, 5_000) + +SPAWN_TOWER = pg.USEREVENT + 2 +pg.time.set_timer(SPAWN_TOWER, 8_000) + +EXTRA_BULLETS_POWERUP = pg.USEREVENT + 3 +pg.time.set_timer(EXTRA_BULLETS_POWERUP, 30_000) + +enemy_planes_surface_objects = [ + pg.image.load(f"../images/enemy_plane_images/enemy_plane_{i}.png").convert_alpha() for i in range(1, 4) +] +tower_img = pg.image.load("../images/buildings/tower_1.png").convert_alpha() + +enemies = EnemyController() + +extra_bullets_powerup = ExtraBulletsPowerUp(image=pg.image.load("../images/power_ups/powerup_x2.png").convert_alpha()) +powers_controller = PowerupController() + +collision_with_enemy = False +font_text = pg.font.SysFont('freesansbold.ttf', 35) + + +def new_window(): + background.loop_background(screen) + text = font_text.render('You lose!', True, (250, 0, 0)) + screen.blit(text, text.get_rect(center=(450, 400))) + + +running = True +while running: + clock.tick(fps) + + for event in pg.event.get(): + if event.type == pg.QUIT: + running = False + + elif event.type == SPAWN_TOWER: + enemies.add_enemy(Tower(tower_img, 100, 100, 20)) # TODO: hardcoded values must come from json + + elif event.type == SPAWN_ENEMY_PLANE: + random_image = helpers.get_random_image_of_enemy_planes(enemy_planes_surface_objects) + enemies.add_enemy(EnemyPlane(random_image, 100, 100, 20)) # TODO: hardcoded values must come from json + + elif event.type == EXTRA_BULLETS_POWERUP: + powers_controller.extra_bullets = extra_bullets_powerup + + if collision_with_enemy: + new_window() + pg.display.flip() + continue + + background.loop_background(screen) + + keys_pressed = pg.key.get_pressed() + + enemies.update_planes(screen) + enemies.update_towers(screen, user_plane) + + user_plane.functionality() + user_plane.display_plane(screen) + user_plane.update_shot_bullets(screen) + + powers_controller.render_extra_bullets(screen=screen, user_plane=user_plane) + + check_user_plane_collision(enemies, user_plane) + check_enemy_collision(enemies, user_plane) + + if check_user_plane_and_enemies_collision(enemies, user_plane): + collision_with_enemy = True + + user_plane.armor_bar.draw_bar(screen) + user_plane.health_bar.draw_bar(screen) + + pg.display.flip() + +pg.quit() diff --git a/gui/choose_a_plane_menu.py b/gui/choose_a_plane_menu.py new file mode 100755 index 0000000..0b85152 --- /dev/null +++ b/gui/choose_a_plane_menu.py @@ -0,0 +1,175 @@ +import sys +from collections import deque + +from PyQt5.QtCore import * +from PyQt5.QtGui import * +from PyQt5.QtWidgets import * + +sys.path.append(r'.') +from gui import display_plane_info +from gui import main_menu + +sys.path.append(r"..") +from settings import settings_handler + + + +global current_gold, current_rank +current_gold = 100 + +class PlanesMenu(QWidget): + def __init__(self): + super().__init__() + self.setWindowTitle("Planes Menu") + self.setWindowIcon(QIcon(r"images/menu/plane_icon.jpg")) + self.setGeometry(200, 150, 600, 500) + self.setMaximumWidth(600) + self.setMaximumHeight(500) + + """READ THE PLANES SETTINGS""" + ps = settings_handler.get_planes_settings() + + def plane_info_display(curr_plane_name): + # plane_info_groupbox.hide() + current_groupbox = display_plane_info.plane_info_return_groupbox(read_plane_stats(curr_plane_name)) + bottom_grid_layout.itemAtPosition(0, 0).widget().setParent(None) + bottom_grid_layout.addWidget(current_groupbox, 0, 0) + + + def open_plane_info(plane_name): + return lambda: plane_info_display(plane_name) + + """ADD CUSTOM FONTS""" + font = QFontDatabase.addApplicationFont(r'fonts/American Captain.ttf') + if font < 0: + print('Error loading fonts!') + fonts = QFontDatabase.applicationFontFamilies(font) + + """BACKGROUND PICTURE GROUPBOX""" + bg_image_groupbox = QGroupBox() + bg_image_groupbox.setProperty("class", "choose_plane_background") + + """MAKE A HORIZONTAL LAYOUT FOR THE GOLD""" + top_gold_layout = QHBoxLayout() + + gold_icon = QLabel() + gold_icon.setFixedSize(50, 50) + gold_icon.setScaledContents(True) + gold_icon.setPixmap(QPixmap(f"images/menu/gold_icon.png")) + + gold_value = QLabel() + gold_value.setProperty("class", "settings_text") + gold_value.setText(f"{current_gold} Gold") + gold_value.setFont(QFont(fonts[0], 16)) + + top_gold_layout.addWidget(gold_icon) + top_gold_layout.addWidget(gold_value) + + """ADD THE LAYOUTS - ONE AT THE TOP, ONE AT THE BOTTOM AND ONE MAIN LAYOUT FOR BOTH""" + top_layout = QVBoxLayout() + bottom_layout = QVBoxLayout() + bottom_layout.addStretch() + bottom_layout.addSpacing(10) + + planes_menu_main_layout = QVBoxLayout() + + bottom_grid_layout = QGridLayout() + + """ADDED A TOP GRID LAYOUT, WHICH WE WILL PUT IN THE TOP LAYOUT""" + top_grid_layout = QGridLayout() + top_grid_layout.setSpacing(30) # spacing between the cells in the gird layout + + all_planes = deque(['user_plane_1', 'user_plane_2', 'user_plane_3', 'user_plane_4', 'user_plane_5', 'user_plane_6']) + + for row in range(2): + for col in range(3): + curr_name_plane = all_planes.popleft() + plane_image = f"images/user_plane_images/{curr_name_plane}.png" + + plane_button = QPushButton() + plane_button.setProperty("class", "planes") + plane_button.setIcon(QIcon(plane_image)) + plane_button.setIconSize(QSize(150, 150)) + plane_button.setFixedSize(140, 140) + plane_button.setCursor(QCursor(Qt.CursorShape.PointingHandCursor)) + plane_button.clicked.connect(open_plane_info(curr_name_plane)) + + + top_grid_layout.addWidget(plane_button, row, col) + + top_layout.addLayout(top_grid_layout) + top_layout.addStretch() + top_layout.addSpacing(10) + + """MAKE THE LAYOUT FOR THE PLANE'S INFO LABEL""" + layout_for_plane_info_name = QVBoxLayout() + plane_info_name_label = QLabel() + plane_info_name_label.setText("Plane's info") + plane_info_name_label.setFont(QFont(fonts[0], 12)) + layout_for_plane_info_name.addWidget(plane_info_name_label) + layout_for_plane_info_name.addSpacing(-25) + + """MAKE THE BUTTONS FOR THE BOTTOM LAYOUT""" + plane_info_groupbox = QGroupBox() + # plane_info_groupbox.setProperty("class", "plane_info_panel") + plane_info_groupbox.setFixedWidth(300) + plane_info_groupbox.setFixedHeight(120) + + back_to_main_menu_button = QPushButton() + back_to_main_menu_button.setProperty("class", "menu_button") + back_to_main_menu_button.setText("Main Menu") + back_to_main_menu_button.setFont(QFont(fonts[0], 15)) + back_to_main_menu_button.setFixedWidth(175) + back_to_main_menu_button.setFixedHeight(50) + back_to_main_menu_button.setCursor(QCursor(Qt.CursorShape.PointingHandCursor)) + back_to_main_menu_button.clicked.connect(lambda: back_to_main_menu()) + + start_button = QPushButton() + start_button.setProperty("class", "menu_button") + start_button.setText("Start") + start_button.setFont(QFont(fonts[0], 15)) + start_button.setFixedWidth(80) + start_button.setFixedHeight(50) + start_button.setCursor(QCursor(Qt.CursorShape.PointingHandCursor)) + + bottom_grid_layout.addWidget(plane_info_groupbox, 0, 0) + bottom_grid_layout.addWidget(back_to_main_menu_button, 0, 1) + bottom_grid_layout.addWidget(start_button, 0, 2) + bottom_grid_layout.setVerticalSpacing(-20) + + bottom_layout.addLayout(bottom_grid_layout) + bottom_layout.addStretch(10) + bottom_layout.addSpacing(2) + top_layout.addStretch(10) + top_layout.addSpacing(0) + + planes_menu_main_layout.addLayout(top_gold_layout) + planes_menu_main_layout.addLayout(top_layout) + # planes_menu_main_layout.addLayout(layout_for_plane_info_name) + planes_menu_main_layout.addLayout(bottom_layout) + bg_image_groupbox.setLayout(planes_menu_main_layout) + + main_layout = QVBoxLayout() + main_layout.setContentsMargins(0, 0, 0, 0) + main_layout.addWidget(bg_image_groupbox) + self.setLayout(main_layout) + self.show() + + def read_plane_stats(plane): + plane_stats = ps.get(plane) + global result + result = [] + for k,v in plane_stats.items(): + cur_res = k + " --> " + v + result.append(cur_res) + return result + +def start_plane_menu_window(): + global plane_menu + plane_menu = PlanesMenu() + plane_menu.show() + +def back_to_main_menu(): + global plane_menu + plane_menu.hide() + main_menu.open_main_menu() \ No newline at end of file diff --git a/gui/credits_menu.py b/gui/credits_menu.py new file mode 100755 index 0000000..d916ff5 --- /dev/null +++ b/gui/credits_menu.py @@ -0,0 +1,145 @@ +#!/usr/bin/python3 + +"""IMPORT PyQt5 ENGINE""" +from PyQt5.QtWidgets import (QWidget, + QPushButton, + QLabel, + QGroupBox, + QVBoxLayout, + QGraphicsDropShadowEffect, + QTextEdit, + ) +from PyQt5.QtGui import * +from PyQt5.QtCore import * +import sys, webbrowser +sys.path.append(r'.') +from gui import main_menu +sys.path.append(r'..') + + + +class CreditsMenu(QWidget): + def __init__(self): + super().__init__() + self.setWindowTitle("Py Planes") + self.setWindowIcon(QIcon(r'images/menu/plane_icon.jpg')) + self.setGeometry(200, 150, 600, 500) + self.setMaximumWidth(600) + self.setMaximumHeight(500) + + + """CREATE SHADOW EFFECTS""" + title_shadow = QGraphicsDropShadowEffect() + title_shadow.setBlurRadius(10) + title_shadow.setOffset(2, 5) + title_shadow.setColor(QColor(0, 0, 0)) + + description_shadow = QGraphicsDropShadowEffect() + description_shadow.setBlurRadius(2) + description_shadow.setOffset(2, 3) + description_shadow.setColor(QColor(200, 8, 8)) + + """ADD CUSTOM FONTS""" + font = QFontDatabase.addApplicationFont(r'fonts/American Captain.ttf') + if font < 0: + print('Error loading fonts!') + fonts = QFontDatabase.applicationFontFamilies(font) + + """BACKGROUND PICTURE GROUPBOX""" + bg_image_groupbox = QGroupBox() + bg_image_groupbox.setProperty("class", "credits_background") + + """TITLE LAYOUT""" + title_layout = QVBoxLayout() + title_layout.setSpacing(2) + + title_area = QLabel() + title_area.setText("Py-Planes") + title_area.setProperty("class", "title_area") + title_area.setFont(QFont(fonts[0], 30)) + title_area.setFixedSize(300, 50) + title_area.setAlignment(Qt.AlignCenter) + title_area.setGraphicsEffect(title_shadow) + + version_area = QLabel() + version_area.setText("Version 1.0") + version_area.setProperty("class", "title_area") + version_area.setFont(QFont(fonts[0], 15)) + version_area.setAlignment(Qt.AlignCenter) + + title_layout.addWidget(title_area) + title_layout.addWidget(version_area) + title_layout.setAlignment(Qt.AlignCenter) + + """DESCRIPTION LAYOUT""" + description_layout = QVBoxLayout() + description_layout.addStretch(10) + + description_area = QTextEdit() + description_area.setProperty("class", "description_area") + description_area.setText("Python game written in Qt Framework and PyGame") + description_area.setFont(QFont(fonts[0], 18)) + description_area.setAlignment(Qt.AlignCenter) + description_area.setDisabled(True) + description_area.viewport().setAutoFillBackground(False) + description_area.setGraphicsEffect(description_shadow) + + description_layout.addWidget(description_area) + + + """INFO LAYOUT""" + info_layout = QVBoxLayout() + + github_button = QPushButton() + github_button.setProperty("class", "github_button") + github_button.setText("GitHub Project") + github_button.setFont(QFont(fonts[0], 15)) + github_button.setFixedSize(150, 25) + github_button.clicked.connect(lambda: open_webbrowser()) + + info_layout.setAlignment(Qt.AlignCenter) + info_layout.addWidget(github_button) + + """MAIN BUTTONS""" + buttons_layout = QVBoxLayout() + buttons_layout.setAlignment(Qt.AlignCenter) + + back_button = QPushButton() + back_button.setText("main menu") + back_button.setFont(QFont(fonts[0], 20)) + back_button.setProperty("class", "menu_button") + back_button.setFixedSize(200, 50) + back_button.clicked.connect(lambda: open_main_menu()) + + buttons_layout.addWidget(back_button) + + main_credits_layout = QVBoxLayout() + main_credits_layout.addLayout(title_layout) + main_credits_layout.addLayout(description_layout) + main_credits_layout.addLayout(info_layout) + main_credits_layout.addLayout(buttons_layout) + + bg_image_groupbox.setLayout(main_credits_layout) + + main_layout = QVBoxLayout() + main_layout.setContentsMargins(0, 0, 0, 0) + main_layout.addWidget(bg_image_groupbox) + self.setLayout(main_layout) + self.show() + + + + def open_webbrowser(): + # if you want please remember to check its valid url or not + url = str('https://github.com/Stake-And-Rope/py-planes') + webbrowser.open(url) + + +def open_credits(): + global credits_window + credits_window = CreditsMenu() + credits_window.show() + +def open_main_menu(): + credits_window.hide() + main_menu.open_main_menu() \ No newline at end of file diff --git a/gui/display_plane_info.py b/gui/display_plane_info.py new file mode 100644 index 0000000..7f3fd57 --- /dev/null +++ b/gui/display_plane_info.py @@ -0,0 +1,39 @@ +from PyQt5.QtWidgets import QGroupBox, QPushButton, QVBoxLayout, QPlainTextEdit, QLabel +from PyQt5.QtGui import * +from PyQt5.QtCore import * + + + +def plane_info_return_groupbox(curr_plane_stats): + + + """ADD CUSTOM FONTS""" + font = QFontDatabase.addApplicationFont(r'fonts/American Captain.ttf') + if font < 0: + print('Error loading fonts!') + fonts = QFontDatabase.applicationFontFamilies(font) + + print(curr_plane_stats) + curr_plane_info_groupbox = QGroupBox() + curr_plane_info_groupbox.setProperty("class", "plane_info_panel") + curr_plane_info_groupbox.setFixedWidth(300) + curr_plane_info_groupbox.setFixedHeight(200) + + plane_info_layout = QVBoxLayout() + plane_info_layout.addStretch(-10) + plane_info_layout.addSpacing(-10) + + for i in curr_plane_stats: + current_label = QLabel() + current_label.setProperty('class', 'settings_text') + current_label.setText(str(i)) + current_label.setFont(QFont(fonts[0], 20)) + + + plane_info_layout.addWidget(current_label) + + curr_plane_info_groupbox.setLayout(plane_info_layout) + curr_plane_info_groupbox.setContentsMargins(0,0,0,0) + + return curr_plane_info_groupbox + diff --git a/gui/main_menu.py b/gui/main_menu.py new file mode 100755 index 0000000..31d086d --- /dev/null +++ b/gui/main_menu.py @@ -0,0 +1,171 @@ +#!/usr/bin/python3 + +"""IMPORT PyQt5 ENGINE""" +from PyQt5.QtWidgets import (QApplication, + QWidget, + QPushButton, + QGridLayout, + QLabel, + QFrame, + QGroupBox, + QLineEdit, + QMessageBox, + QPlainTextEdit, + QHBoxLayout, + QVBoxLayout, + QGraphicsDropShadowEffect, + QGraphicsOpacityEffect, + QSizePolicy + ) +from PyQt5.QtGui import * +from PyQt5.QtCore import * +import sys, os +from collections import deque +from pathlib import Path + + +sys.path.append(r'.') +from gui import choose_a_plane_menu +from gui import settings_menu +from gui import credits_menu +sys.path.append(r'..') +from sounds.sounds import main_menu_music +song = r'sounds/music/main_menu_music_cut.wav' + + + +# Modify this variable to receive dynamically value from the JSON file +global current_gold, current_rank +current_gold = 100 +current_rank = "Airman" + +class MainMenu(QWidget): + def __init__(self): + super().__init__() + self.setWindowTitle("Py Planes") + self.setWindowIcon(QIcon(r'images/menu/plane_icon.jpg')) + self.setGeometry(200, 150, 600, 500) + self.setMaximumWidth(600) + self.setMaximumHeight(500) + + """BACKGROUND PICTURE GROUPBOX""" + bg_image_groupbox = QGroupBox() + bg_image_groupbox.setProperty("class", "background") + + """ADD CUSTOM FONTS""" + font = QFontDatabase.addApplicationFont(r'fonts/American Captain.ttf') + if font < 0: + print('Error loading fonts!') + fonts = QFontDatabase.applicationFontFamilies(font) + + """DISPLAY THE USER'S GOLD""" + gold_layout = QVBoxLayout() + # gold_layout.addStretch() + gold_layout.addSpacing(0) + + gold_horizontal_layout = QHBoxLayout() + + gold_icon = QLabel() + gold_icon.setFixedSize(50, 50) + gold_icon.setScaledContents(True) + gold_icon.setPixmap(QPixmap(r"images/menu/gold_icon.png")) + + gold_value = QLabel() + gold_value.setText(f"{current_gold} Gold") + gold_value.setFont(QFont(fonts[0], 20)) + + gold_horizontal_layout.addWidget(gold_icon) + gold_horizontal_layout.addWidget(gold_value) + + gold_layout.addLayout(gold_horizontal_layout) + + """DISPLAY USER RANK""" + rank_layout = QVBoxLayout() + # rank_layout.addStretch() + # rank_layout.addSpacing(10) + + rank_horizontal_layout = QHBoxLayout() + + # Read the rank dynamically from the JSON file + rank_icon = QLabel() + rank_icon.setFixedSize(50, 50) + rank_icon.setScaledContents(True) + rank_icon.setPixmap(QPixmap(r"images/ranks/airman_rank.png")) + + rank_value = QLabel() + rank_value.setText(f"{current_rank}") + rank_value.setFont(QFont(fonts[0], 20)) + + rank_horizontal_layout.addWidget(rank_icon) + rank_horizontal_layout.addWidget(rank_value) + + rank_layout.addLayout(rank_horizontal_layout) + rank_layout.addStretch() + + """BUTTONS LAYOUT""" + main_buttons_layout = QVBoxLayout() + main_buttons_layout.setAlignment(Qt.AlignCenter) + buttons = deque(["Start Game", "Settings", "Credits", "Quit Game"]) + + for i in range(4): + current_button = QPushButton() + current_button.setProperty("class", "menu_button") + button = buttons.popleft() + current_button.setText(button) + current_button.setFont(QFont(fonts[0], 20)) + current_button.setFixedSize(200, 50) + if button == "Start Game": + current_button.clicked.connect(lambda: self.start_game_button_func()) + if button == "Settings": + current_button.clicked.connect(lambda: open_settings_menu()) + if button == "Credits": + current_button.clicked.connect(lambda: open_credits_menu()) + if button == "Quit Game": + current_button.clicked.connect(lambda: app.quit()) + + + main_buttons_layout.addWidget(current_button) + main_buttons_layout.addStretch(10) + main_buttons_layout.addSpacing(20) + + main_menu_layout = QVBoxLayout() + # main_menu_layout.addStretch() + # main_menu_layout.addSpacing(0) + main_menu_layout.addLayout(gold_layout) + main_menu_layout.addLayout(rank_layout) + main_menu_layout.addLayout(main_buttons_layout) + bg_image_groupbox.setLayout(main_menu_layout) + + main_layout = QVBoxLayout() + main_layout.setContentsMargins(0, 0, 0, 0) + main_layout.addWidget(bg_image_groupbox) + self.setLayout(main_layout) + self.show() + + def start_game_button_func(self): + choose_a_plane_menu.start_plane_menu_window() + self.hide() + + +def init_app(): + global app + app = QApplication(sys.argv) + app.setStyleSheet(Path('gui/main_menu.qss').read_text()) + global main_window + main_window = MainMenu() + main_window.show() + # app.exec() # Keep this line commented for now. The app is initiated by the main_menu_music function + main_menu_music(song, app) + +def open_main_menu(): + main_window.show() + +global open_settings_menu +def open_settings_menu(): + main_window.hide() + settings_menu.open_settings() + +global open_credits_menu +def open_credits_menu(): + main_window.hide() + credits_menu.open_credits() \ No newline at end of file diff --git a/gui/main_menu.qss b/gui/main_menu.qss new file mode 100644 index 0000000..74e2669 --- /dev/null +++ b/gui/main_menu.qss @@ -0,0 +1,117 @@ +.planes { + background-image: url(images/menu/planes_background.png); + background-position: center; + background-repeat: no-repeat; + /* background-color: #56ba77; */ + color: #bfbfbf; + border-radius: 10px; + border: 1px solid #bfbfbf; + border-bottom: 3px solid #000000; + border-right: 3px solid #000000; + padding: 2px 2px; + margin-top: 2px; + outline: 0px; +} + +.planes:hover { + background-color: #fd6500; +} + +.background { + background-image: url(images/menu/main_menu_background2.jpg); + background-position: right center; + background-repeat: no-repeat; + margin: 0px; + border: 0px; +} + +.settings_background { + background-image: url(images/menu/settings_background.jpg); + background-position: top center; + background-repeat: no-repeat; + margin: 0px; + border: 0px; +} + +.credits_background { + background-image: url(images/menu/credits_menu_background.jpg); + background-position: bottom center; + background-repeat: no-repeat; + margin: 0px; + border: 0px; +} + +.settings_text { + color: #bfbfbf; + +} + +.title_area { + color: #bfbfbf; + +} + +.description_area { + border: 0px; + color: #bfbfbf; +} + + +.choose_plane_background { + background-image: url(images/menu/planes_menu_background.jpg); + background-position: bottom; + background-repeat: no-repeat; + margin: 0px; + border: 0px; +} + +.menu_button { + background-image: url(images/menu/button_background.png); + background-position: center; + background-repeat: no-repeat; + color: #bfbfbf; + border-radius: 2px; + border: 4px solid #bfbfbf; + border-bottom: 0px solid #000000; + border-right: 0px solid #000000; + padding: -10px -10px; + margin: -10px; + outline: -10px; +} + +.menu_button:hover { + background-image: url(images/menu/button_background_hover.png); + background-position: center; + background-repeat: no-repeat; + color: #bfbfbf; +} + +.menu_button:pressed { + border: 200px; + background-color: #000000; +} + + +.github_button { + background-image: url(images/menu/button_background2_hover.png); + background-position: center; + background-repeat: no-repeat; + color: #bfbfbf; + border-radius: 2px; + border: 4px solid #bfbfbf; + border-bottom: 0px solid #000000; + border-right: 0px solid #000000; + padding: -10px -10px; + margin: -10px; + outline: -10px; +} + +.github_button:hover { + background-image: url(images/menu/button_background2.png); + background-position: center; + background-repeat: no-repeat; + color: #ffffff; +} + + + diff --git a/gui/settings_menu.py b/gui/settings_menu.py new file mode 100755 index 0000000..49b0756 --- /dev/null +++ b/gui/settings_menu.py @@ -0,0 +1,181 @@ +#!/usr/bin/python3 + +"""IMPORT PyQt5 ENGINE""" +from PyQt5.QtWidgets import (QWidget, + QPushButton, + QLabel, + QSlider, + QGroupBox, + QLineEdit, + QComboBox, + QHBoxLayout, + QVBoxLayout, + QMessageBox + ) +from PyQt5.QtGui import * +from PyQt5.QtCore import * +import sys, os, json +from pathlib import Path + +sys.path.append(r".") +from gui import main_menu +sys.path.append('..') +from settings import settings_handler +from sounds import sounds + + +class SettingsMenu(QWidget): + def __init__(self): + super().__init__() + self.setWindowTitle("Py Planes") + self.setWindowIcon(QIcon(r'images/menu/plane_icon.jpg')) + self.setGeometry(200, 150, 600, 500) + self.setMaximumWidth(600) + self.setMaximumHeight(500) + + """READ THE SETTINGS FROM THE JSONs""" + gs = settings_handler.get_game_settings() + us = settings_handler.get_user_settings() + + """BACKGROUND PICTURE GROUPBOX""" + bg_image_groupbox = QGroupBox() + bg_image_groupbox.setProperty("class", "settings_background") + + """ADD CUSTOM FONTS""" + font = QFontDatabase.addApplicationFont(r'fonts/American Captain.ttf') + if font < 0: + print('Error loading fonts!') + fonts = QFontDatabase.applicationFontFamilies(font) + + """MAIN HORIZONTAL LAYOUT""" + main_horizontal_layout = QHBoxLayout() + main_horizontal_layout.addStretch() + main_horizontal_layout.addSpacing(-250) + # main_horizontal_layout.setAlignment(Qt.AlignCenter) + + """LEFT VERTICAL LAYOUT""" + left_vertrical_layout = QVBoxLayout() + left_vertrical_layout.setAlignment(Qt.AlignCenter) + + fps_label = QLabel() + fps_label.setText('FPS') + fps_label.setProperty("class", "settings_text") + fps_label.setFont(QFont(fonts[0], 20)) + fps_label.setAlignment(Qt.AlignCenter) + + music_vol_label = QLabel() + music_vol_label.setText("Music Volume") + music_vol_label.setProperty("class", "settings_text") + music_vol_label.setFont(QFont(fonts[0], 20)) + music_vol_label.setAlignment(Qt.AlignCenter) + + effects_vol_label = QLabel() + effects_vol_label.setText("Effects Volume") + effects_vol_label.setProperty("class", "settings_text") + effects_vol_label.setFont(QFont(fonts[0], 20)) + effects_vol_label.setAlignment(Qt.AlignCenter) + + user_name_label = QLabel() + user_name_label.setProperty("class", "settings_text") + user_name_label.setAlignment(Qt.AlignCenter) + user_name_label.setText("Username") + user_name_label.setFont(QFont(fonts[0], 20)) + + left_vertrical_layout.addWidget(fps_label) + left_vertrical_layout.addWidget(music_vol_label) + left_vertrical_layout.addWidget(effects_vol_label) + left_vertrical_layout.addWidget(user_name_label) + + """RIGHT VERTICAL LAYOUT""" + right_vertrical_layout = QVBoxLayout() + right_vertrical_layout.setAlignment(Qt.AlignCenter) + + fps_menu = QComboBox() + fps_menu.addItems(["45", "60", "75"]) + fps_menu.setFont(QFont(fonts[0], 18)) + fps_menu.setFixedSize(70, 30) + fps_menu.setCurrentText(gs.get('fps')) + + + music_vol_slider = QSlider(Qt.Horizontal) + music_vol_slider.setValue(int(gs.get('music'))) + music_vol_slider.setTickInterval(20) + music_vol_slider.setFocusPolicy(Qt.StrongFocus) + music_vol_slider.setTickPosition(QSlider.TicksBothSides) + music_vol_slider.setSingleStep(1) + music_vol_slider.setFixedWidth(200) + # print(music_vol_slider.value()) + + effects_vol_slider = QSlider(Qt.Horizontal) + effects_vol_slider.setValue(int(gs.get('effects'))) + effects_vol_slider.setTickInterval(20) + effects_vol_slider.setFocusPolicy(Qt.StrongFocus) + effects_vol_slider.setTickPosition(QSlider.TicksBothSides) + effects_vol_slider.setSingleStep(1) + effects_vol_slider.setFixedWidth(200) + + user_name_textbox = QLineEdit() + user_name_textbox.setText(us.get("username")) + user_name_textbox.setFont(QFont(fonts[0], 18)) + user_name_textbox.setFixedSize(200, 30) + user_name_textbox.setAlignment(Qt.AlignCenter) + + right_vertrical_layout.addWidget(fps_menu) + right_vertrical_layout.addWidget(music_vol_slider) + right_vertrical_layout.addWidget(effects_vol_slider) + right_vertrical_layout.addWidget(user_name_textbox) + + main_horizontal_layout.addLayout(left_vertrical_layout) + main_horizontal_layout.addLayout(right_vertrical_layout) + + + """BUTTONS LAYOUT""" + main_buttons_layout = QVBoxLayout() + main_buttons_layout.addStretch() + main_buttons_layout.addSpacing(10) + main_buttons_layout.setAlignment(Qt.AlignCenter) + + save_settings_button = QPushButton() + save_settings_button.setProperty("class", "menu_button") + save_settings_button.setText("Save Settings") + save_settings_button.setFont(QFont(fonts[0], 18)) + save_settings_button.setFixedSize(200, 50) + save_settings_button.clicked.connect(lambda: save_settings()) + + back_button = QPushButton() + back_button.setProperty("class", "menu_button") + back_button.setText("Main Menu") + back_button.setFont(QFont(fonts[0], 18)) + back_button.setFixedSize(200, 50) + back_button.clicked.connect(lambda: back_to_main_menu()) + + main_buttons_layout.addWidget(save_settings_button) + main_buttons_layout.addWidget(back_button) + + main_settings_layout = QVBoxLayout() + main_settings_layout.addStretch() + main_settings_layout.addSpacing(20) + main_settings_layout.addLayout(main_horizontal_layout) + main_settings_layout.addLayout(main_buttons_layout) + bg_image_groupbox.setLayout(main_settings_layout) + + main_layout = QVBoxLayout() + main_layout.setContentsMargins(0, 0, 0, 0) + main_layout.addWidget(bg_image_groupbox) + self.setLayout(main_layout) + self.show() + + def save_settings(): + settings_handler.overwrite_game_settings(**{"fps":fps_menu.currentText(), "music":str(music_vol_slider.value()), "effects": str(effects_vol_slider.value())}) + settings_handler.overwrite_user_settings(**{"username":user_name_textbox.text()}) + sounds.change_volume() + +def open_settings(): + global settings_window + settings_window = SettingsMenu() + settings_window.show() + +def back_to_main_menu(): + global settings_window + settings_window.hide() + main_menu.open_main_menu() \ No newline at end of file diff --git a/images/__init__.py b/images/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/images/buildings/tower_1.pixil b/images/buildings/tower_1.pixil new file mode 100644 index 0000000..ad0059e --- /dev/null +++ b/images/buildings/tower_1.pixil @@ -0,0 +1 @@ +{"application":"pixil","type":".pixil","version":"2.7.0","website":"pixilart.com","author":"https://www.pixilart.com","contact":"support@pixilart.com","width":64,"height":64,"colors":{"default":["000000","ffffff","f44336","E91E63","9C27B0","673AB7","3F51B5","2196F3","03A9F4","00BCD4","009688","4CAF50","8BC34A","CDDC39","FFEB3B","FFC107","FF9800","FF5722","795548","9E9E9E","607D8B","ffebee","ffcdd2","ef9a9a","e57373","ef5350","e53935","d32f2f","c62828","b71c1c","ff8a80","ff5252","ff1744","d50000","fce4ec","f8bbd0","f48fb1","f06292","ec407a","e91e63","d81b60","c2185b","ad1457","880e4f","ff80ab","ff4081","f50057","c51162","f3e5f5","e1bee7","ce93d8","ba68c8","ab47bc","9c27b0","8e24aa","7b1fa2","6a1b9a","4a148c","ea80fc","e040fb","d500f9","aa00ff","ede7f6","d1c4e9","b39ddb","9575cd","7e57c2","673ab7","5e35b1","512da8","4527a0","311b92","b388ff","7c4dff","651fff","6200ea","e8eaf6","c5cae9","9fa8da","7986cb","5c6bc0","3f51b5","3949ab","303f9f","283593","1a237e","8c9eff","536dfe","3d5afe","304ffe","e3f2fd","bbdefb","90caf9","64b5f6","42a5f5","2196f3","1e88e5","1976d2","1565c0","0d47a1","82b1ff","448aff","2979ff","2962ff","e1f5fe","b3e5fc","81d4fa","4fc3f7","29b6f6","03a9f4","039be5","0288d1","0277bd","01579b","80d8ff","40c4ff","00b0ff","0091ea","e0f7fa","b2ebf2","80deea","4dd0e1","26c6da","00bcd4","00acc1","0097a7","00838f","006064","84ffff","18ffff","00e5ff","00b8d4","e0f2f1","b2dfdb","80cbc4","4db6ac","26a69a","009688","00897b","00796b","00695c","004d40","a7ffeb","64ffda","1de9b6","00bfa5","e8f5e9","c8e6c9","a5d6a7","81c784","66bb6a","4caf50","43a047","388e3c","2e7d32","1b5e20","b9f6ca","69f0ae","00e676","00c853","f1f8e9","dcedc8","c5e1a5","aed581","9ccc65","8bc34a","7cb342","689f38","558b2f","33691e","ccff90","b2ff59","76ff03","64dd17","f9fbe7","f0f4c3","e6ee9c","dce775","d4e157","cddc39","c0ca33","afb42b","9e9d24","827717","f4ff81","eeff41","c6ff00","aeea00","fffde7","fff9c4","fff59d","fff176","ffee58","ffeb3b","fdd835","fbc02d","f9a825","f57f17","ffff8d","ffff00","ffea00","ffd600","fff8e1","ffecb3","ffe082","ffd54f","ffca28","ffc107","ffb300","ffa000","ff8f00","ff6f00","ffe57f","ffd740","ffc400","ffab00","fff3e0","ffe0b2","ffcc80","ffb74d","ffa726","ff9800","fb8c00","f57c00","ef6c00","e65100","ffd180","ffab40","ff9100","ff6d00","fbe9e7","ffccbc","ffab91","ff8a65","ff7043","ff5722","f4511e","e64a19","d84315","bf360c","ff9e80","ff6e40","ff3d00","dd2c00","efebe9","d7ccc8","bcaaa4","a1887f","8d6e63","795548","6d4c41","5d4037","4e342e","3e2723","fafafa","f5f5f5","eeeeee","e0e0e0","bdbdbd","9e9e9e","757575","616161","424242","212121","eceff1","cfd8dc","b0bec5","90a4ae","78909c","607d8b","546e7a","455a64","37474f","263238"],"simple":["ffffff","d4d4d4","a1a1a1","787878","545454","303030","000000","edc5c5","e68383","ff0000","de2424","ad3636","823737","592b2b","f5d2ee","eb8dd7","f700b9","bf1f97","9c277f","732761","4f2445","e2bcf7","bf79e8","9d00ff","8330ba","6d3096","502c69","351b47","c5c3f0","736feb","0905f7","2e2eb0","2d2d80","252554","090936","c7e2ed","6ac3e6","00bbff","279ac4","347c96","2d5b6b","103947","bbf0d9","6febb3","00ff88","2eb878","349166","2b694c","0c3d25","c2edc0","76ed70","0dff00","36c72c","408c3b","315c2e","144511","d6edbb","b5eb73","8cff00","89c93a","6f8f44","4b632a","2a400c","f1f2bf","eef069","ffff00","baba30","91913f","5e5e2b","3b3b09","ffdeb8","f2ae61","ff8400","c48037","85623d","573e25","3d2309","fcbbae","ff8066","ff2b00","cc553d","9c5b4e","61372e","36130b"],"common":["000000","ffffff","464646","b4b4b4","990030","9c5a3c","ed1c24","ffa3b1","ff7e00","e5aa7a","ffc20e","f5e49c","fff200","fff9bd","a8e61d","d3f9bc","22b14c","00b7ef","99d9ea","4d6df3","709ad1","2f3699","546d8e","6f3198","b5a5d5","2b44a6","506fde","6c8dfa"],"skin tones":["ffe0bd","ffdbac","ffcd94","eac086","e0ac69","f1c27d","ffad60","c68642","8d5524","896347","765339","613D24","4C2D17","391E0B","351606","2D1304","180A01","090300"],"Simple Rainbow":["3B1830","4A2135","5E2F3F","7D3E3E","995B50","BA8270","D4A58C","C2717B","99567D","753D7A","57386B","3D2E57","2E233D","463E4A","5B5661","6F7078","82888C","97A1A3","BAC2BC","F2E9D3","8EC8D1","74A4C2","6485B3","546599","4D4C87","47396E","412D5E","3D204D","612751","7D2B53","913D59","AD4C56","D16C5A","E69065","EBB275","F0D299","A5C966","63B34F","459C57","377D54","276B5D","255457","1E3B45","172936","130A1C","22b14c"],"Middle of nowhere":["FF1744","F51743","EB1741","E1173F","D7173D","CD173F","C3173F","B91740","AF1740","A5173F","9B173F","91173F","87173E","7D173E","73173D","69173D","5F173D","55173D","4B173D","41173D","37173D","2D173D","23173D","19173D","0F173D","05173D"],"This took me an hour":["0B171F","28465A","3D5C74","58788D","7495A8","94B0C0","B1C5D2","CDDDE5","F0F4F7","00292A","004538","006045","007B46","009644","50B04A","94C952","C7E26E","810000","A20000","C2340B","E15C0F","F48925","F7AC38","FACE43","FFEF57","651415","822F22","9B4D2F","B76D3B","D18A4F","E9AA6B","F1C585","F9DAA2","47094D","7A0475","A41588","C4398B","DC5D86","F48D8A","FFB6A5","240553","291A72","2F4091","2C6FAF","28ADCF","4DD1DD","92E5E8","1F0C2C","30093D","51005D","81007A","83007A","B00081","C40380","C81680","D95588","EC849B","55BDED","6298D2","6579B6","5E5A91","584871","533D5A","362836","00cef7"],"New Palette":["3A224F","4E2557","73326A","A34474","C7506B","E3755F","ED9E70","FCC88D","FFD7A3","FFEFC9","F0EBA8","CFF291","A0DE85","69C976","50AB76","36777A","2E5C6B","223D54","1F2E52"],"Journey_Palette_":["050914","110524","3B063A","691749","9C3247","D46453","F5A15D","FFCF8E","FF7A7D","FF417D","D61A88","94007A","42004E","220029","100726","25082C","3D1132","73263D","BD4035","ED7B39","FFB84A","FFF540","C6D831","77B02A","429058","2C645E","153C4A","052137","0E0421","0C0B42","032769","144491","488BD4","78D7FF","B0FFF1","FAFFFF","C7D4E1","928FB8","5B537D","392946","24142C","0E0F2C","132243","1A466B","10908E","28C074","3DFF6E","F8FFB8","F0C297","CF968C","8F5765","52294B","0F022E","35003B","64004C","9B0E3E","D41E3C","ED4C40","FF9757","D4662F","9C341A","691B22","450C28","2D002E","000000"],"🌺~The cool colors~🌺":["FF0342","FF0040","131313","1B1B1B","272727","3D3D3D","5D5D5D","858585","B4B4B4","FFFFFF","C7CFDD","92A1B9","657392","424C6E","2A2F4E","1A1932","0E071B","1C121C","391F21","5D2C28","8A4836","BF6F4A","E69C69","F6CA9F","F9E6CF","EDAB50","E07438","C64524","8E251D","FF5000","ED7614","FFA214","FFC825","FFEB57","D3FC7E","99E65F","5AC54F","33984B","1E6F50","134C4C","0C2E44","0069AA","0098DC","00CDF9","0CF1FF","94FDFF","FDD2ED","F389F5","DB3FFD","7A09FA","3003D9","0C0293","03193F","3B1443","622461","93388F","CA52C9","C85086","F68187","F5555D","EA323C","C42430","891E2B","571C27"]},"colorSelected":"🌺~The cool colors~🌺","frames":[{"name":"","speed":100,"layers":[{"id":0,"src":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAABSRJREFUeF7tmz9rVF0Qxm8KW5vEQrAQQdhGUlhoY2W3jY0QBE3QjxCs8gFSST6CkihIwMZmOysbLSyCzYIgFoKFSWNroTyLzzI7O+fMnPtn98bkNu/rvXPOmed3Zuace092pTrj18oZ11+1AmB1dfWPBHlycmL2q+1S8KPtU3Ylk9oYAEQdHx/PjLm2tlZp5yy7lKPR9pZdiXjYhgBw5izifQSQ81cDcgFIgamZ2d/fn+l3a2vLjABtl5qtaPuUHSMyEiFZAHp20aG+UqLgnLyi4tkm2l7bob1MSQ9CEkAqtEuFlOZkU3sAidQkjpOs1lYnEH94eJj0cWNjI/scDT0b7zkHt+xwD1cJBBcAw94THxEXsWkCgP0TgkyHVCpkAaCRDPnc7EfERWyaApAQZDQUA0DjEvERcRGbtgHIaLCW8WQE6GLnzX5EXMSmCwCEUASAxabvVd9bNeQyWQRAbiYiBTBXnT0nI5FR0r+1GhTXgHMA/15wuBJEakDJTOqoaCP3ZZTo/UBxBNQpgn0DICFb7w14nl0F0IggTmMEMAqgoRgAd1F6MxQpaH2x4ZaYu9laqwDEoIPhcFisK5LXOZu67dFOvw8U1wDrZSgFYTQazcGBrRZg2VlUOY5sHx0D/cE2+kaYrAHb29vVzs7OjH9WJFiDMWrk/iFlZwHgOAQQHSMlfnd3t9rb25v7SJMtggCAy4MQdW4RAKwxIB5XbQApCFwdrHdvGQGc4ZRdKgLkMhwZw7Kh+EYA1tfXq6Ojo5lIkCtDxDm9KfGqqV55ImNoG4in740BoANA4IVwkhfTRd7TNnhm2Vkwom1zfkC89Lt2CrAjOgoQ8p7+d6mdBaDNMThx5wDqrgJnNgKYs/8DANaK8FYY4nEugKKlAaQquPzyUtLOWxHk8zpjoAak8j+5ESIA/DfyScw6nWkbQt0x2C51kuwejXkQLMc4a21BqDuGJz4bARSBVMhFQV3n6oa+bpeDnPoGIPsInQ7noqCvACKzH4oArx70EUBUfBgAIVip0FcA0T+fcVNA1gIrFfoGoGT2iyLAS4WSotaVban4WgBQdbGxyK0Mkb8h4OlNFAb6zLWBePoWDf/aANDQg0BhnuNtAKB4+rUQAFEITQB4ZxH8+iu/M+S2vRbscBFkDdAfNXKR4AmgQ6nQtuDJe3Lm2dfCAXQZCTkAlviFp4AMKe+tMZIK0YjhuIPBYC6qlxIBUry3AkSLnrRLwZPfKZeaArnZl0BKlz5vJekFAC/068y4FK7ba4gawkJToFS8NWMWoCb99hYAxcujNp7cWPdKIOgzi4VthEqdhNDNzc3ppLOKj8fj6b2Dg4OKpzrR9Ok9ADpIodbyBbH6uQXYWhGWCiCy7Fm5P379srpx5eJkkj9//1UNHjyam/BTASC6XiP8mfMX3r+diJYA8P+/79ybdEfb/w4A8h/hnwOANMjVAR1xWBY7SQHrdzc8LOGs6xnK7dhkfnsA0D9ANY0A+Su14nMBNH7z8FZ1/9XH6Z+WWAAi+3dd9LwUSAHG/WgRpP9oIzXoQpP9yQwAyA40AHk+n/tChBBtKwKkAH4C098DYDO8fGli+uTutXoA0BiC2dHox89JhxwM4iWgZQFglEq/6DP8hd+5jZH7QURD4Hc3CcY7P+wyAgDg+buvE6GWb96u0AUgIwGDaLrR3VqXdvCJESonxhMPn7IAvj29Pf1N8M0XX+bEf3p8vUtdob4tv9BQ+nb12YekTvOBFB7y4pQYWSD+AoLbvIzRjpNSAAAAAElFTkSuQmCC","edit":false,"name":"Background","opacity":"1","active":true,"unqid":"o4315o","options":{"blend":"source-over","locked":false,"filter":{"brightness":"100%","contrast":"100%","grayscale":"0%","blur":0,"dropshadow_x":0,"dropshadow_y":0,"dropshadow_blur":0,"dropshadow_alpha":1}}}],"active":true,"selectedLayer":0,"unqid":"whtmq","preview":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAABSRJREFUeF7tmz9rVF0Qxm8KW5vEQrAQQdhGUlhoY2W3jY0QBE3QjxCs8gFSST6CkihIwMZmOysbLSyCzYIgFoKFSWNroTyLzzI7O+fMnPtn98bkNu/rvXPOmed3Zuace092pTrj18oZ11+1AmB1dfWPBHlycmL2q+1S8KPtU3Ylk9oYAEQdHx/PjLm2tlZp5yy7lKPR9pZdiXjYhgBw5izifQSQ81cDcgFIgamZ2d/fn+l3a2vLjABtl5qtaPuUHSMyEiFZAHp20aG+UqLgnLyi4tkm2l7bob1MSQ9CEkAqtEuFlOZkU3sAidQkjpOs1lYnEH94eJj0cWNjI/scDT0b7zkHt+xwD1cJBBcAw94THxEXsWkCgP0TgkyHVCpkAaCRDPnc7EfERWyaApAQZDQUA0DjEvERcRGbtgHIaLCW8WQE6GLnzX5EXMSmCwCEUASAxabvVd9bNeQyWQRAbiYiBTBXnT0nI5FR0r+1GhTXgHMA/15wuBJEakDJTOqoaCP3ZZTo/UBxBNQpgn0DICFb7w14nl0F0IggTmMEMAqgoRgAd1F6MxQpaH2x4ZaYu9laqwDEoIPhcFisK5LXOZu67dFOvw8U1wDrZSgFYTQazcGBrRZg2VlUOY5sHx0D/cE2+kaYrAHb29vVzs7OjH9WJFiDMWrk/iFlZwHgOAQQHSMlfnd3t9rb25v7SJMtggCAy4MQdW4RAKwxIB5XbQApCFwdrHdvGQGc4ZRdKgLkMhwZw7Kh+EYA1tfXq6Ojo5lIkCtDxDm9KfGqqV55ImNoG4in740BoANA4IVwkhfTRd7TNnhm2Vkwom1zfkC89Lt2CrAjOgoQ8p7+d6mdBaDNMThx5wDqrgJnNgKYs/8DANaK8FYY4nEugKKlAaQquPzyUtLOWxHk8zpjoAak8j+5ESIA/DfyScw6nWkbQt0x2C51kuwejXkQLMc4a21BqDuGJz4bARSBVMhFQV3n6oa+bpeDnPoGIPsInQ7noqCvACKzH4oArx70EUBUfBgAIVip0FcA0T+fcVNA1gIrFfoGoGT2iyLAS4WSotaVban4WgBQdbGxyK0Mkb8h4OlNFAb6zLWBePoWDf/aANDQg0BhnuNtAKB4+rUQAFEITQB4ZxH8+iu/M+S2vRbscBFkDdAfNXKR4AmgQ6nQtuDJe3Lm2dfCAXQZCTkAlviFp4AMKe+tMZIK0YjhuIPBYC6qlxIBUry3AkSLnrRLwZPfKZeaArnZl0BKlz5vJekFAC/068y4FK7ba4gawkJToFS8NWMWoCb99hYAxcujNp7cWPdKIOgzi4VthEqdhNDNzc3ppLOKj8fj6b2Dg4OKpzrR9Ok9ADpIodbyBbH6uQXYWhGWCiCy7Fm5P379srpx5eJkkj9//1UNHjyam/BTASC6XiP8mfMX3r+diJYA8P+/79ybdEfb/w4A8h/hnwOANMjVAR1xWBY7SQHrdzc8LOGs6xnK7dhkfnsA0D9ANY0A+Su14nMBNH7z8FZ1/9XH6Z+WWAAi+3dd9LwUSAHG/WgRpP9oIzXoQpP9yQwAyA40AHk+n/tChBBtKwKkAH4C098DYDO8fGli+uTutXoA0BiC2dHox89JhxwM4iWgZQFglEq/6DP8hd+5jZH7QURD4Hc3CcY7P+wyAgDg+buvE6GWb96u0AUgIwGDaLrR3VqXdvCJESonxhMPn7IAvj29Pf1N8M0XX+bEf3p8vUtdob4tv9BQ+nb12YekTvOBFB7y4pQYWSD+AoLbvIzRjpNSAAAAAElFTkSuQmCC","width":64,"height":64}],"currentFrame":0,"speed":100,"name":"Untitled","preview":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,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","previewApp":"","art_edit_id":0,"palette_id":"24029","created_at":1690664211662,"updated_at":1690664211662,"persLayers":true,"id":1690660482264} \ No newline at end of file diff --git a/images/buildings/tower_1.png b/images/buildings/tower_1.png new file mode 100644 index 0000000..95d1eef Binary files /dev/null and b/images/buildings/tower_1.png differ diff --git a/images/enemy_plane_images/enemy_bullet.png b/images/enemy_plane_images/enemy_bullet.png new file mode 100644 index 0000000..2d6c250 Binary files /dev/null and b/images/enemy_plane_images/enemy_bullet.png differ diff --git a/images/enemy_plane_images/enemy_plane_1.pixil b/images/enemy_plane_images/enemy_plane_1.pixil new file mode 100644 index 0000000..007cbb8 --- /dev/null +++ b/images/enemy_plane_images/enemy_plane_1.pixil @@ -0,0 +1 @@ +{"application":"pixil","type":".pixil","version":"2.7.0","website":"pixilart.com","author":"https://www.pixilart.com","contact":"support@pixilart.com","width":64,"height":64,"colors":{"default":["000000","ffffff","f44336","E91E63","9C27B0","673AB7","3F51B5","2196F3","03A9F4","00BCD4","009688","4CAF50","8BC34A","CDDC39","FFEB3B","FFC107","FF9800","FF5722","795548","9E9E9E","607D8B","ffebee","ffcdd2","ef9a9a","e57373","ef5350","e53935","d32f2f","c62828","b71c1c","ff8a80","ff5252","ff1744","d50000","fce4ec","f8bbd0","f48fb1","f06292","ec407a","e91e63","d81b60","c2185b","ad1457","880e4f","ff80ab","ff4081","f50057","c51162","f3e5f5","e1bee7","ce93d8","ba68c8","ab47bc","9c27b0","8e24aa","7b1fa2","6a1b9a","4a148c","ea80fc","e040fb","d500f9","aa00ff","ede7f6","d1c4e9","b39ddb","9575cd","7e57c2","673ab7","5e35b1","512da8","4527a0","311b92","b388ff","7c4dff","651fff","6200ea","e8eaf6","c5cae9","9fa8da","7986cb","5c6bc0","3f51b5","3949ab","303f9f","283593","1a237e","8c9eff","536dfe","3d5afe","304ffe","e3f2fd","bbdefb","90caf9","64b5f6","42a5f5","2196f3","1e88e5","1976d2","1565c0","0d47a1","82b1ff","448aff","2979ff","2962ff","e1f5fe","b3e5fc","81d4fa","4fc3f7","29b6f6","03a9f4","039be5","0288d1","0277bd","01579b","80d8ff","40c4ff","00b0ff","0091ea","e0f7fa","b2ebf2","80deea","4dd0e1","26c6da","00bcd4","00acc1","0097a7","00838f","006064","84ffff","18ffff","00e5ff","00b8d4","e0f2f1","b2dfdb","80cbc4","4db6ac","26a69a","009688","00897b","00796b","00695c","004d40","a7ffeb","64ffda","1de9b6","00bfa5","e8f5e9","c8e6c9","a5d6a7","81c784","66bb6a","4caf50","43a047","388e3c","2e7d32","1b5e20","b9f6ca","69f0ae","00e676","00c853","f1f8e9","dcedc8","c5e1a5","aed581","9ccc65","8bc34a","7cb342","689f38","558b2f","33691e","ccff90","b2ff59","76ff03","64dd17","f9fbe7","f0f4c3","e6ee9c","dce775","d4e157","cddc39","c0ca33","afb42b","9e9d24","827717","f4ff81","eeff41","c6ff00","aeea00","fffde7","fff9c4","fff59d","fff176","ffee58","ffeb3b","fdd835","fbc02d","f9a825","f57f17","ffff8d","ffff00","ffea00","ffd600","fff8e1","ffecb3","ffe082","ffd54f","ffca28","ffc107","ffb300","ffa000","ff8f00","ff6f00","ffe57f","ffd740","ffc400","ffab00","fff3e0","ffe0b2","ffcc80","ffb74d","ffa726","ff9800","fb8c00","f57c00","ef6c00","e65100","ffd180","ffab40","ff9100","ff6d00","fbe9e7","ffccbc","ffab91","ff8a65","ff7043","ff5722","f4511e","e64a19","d84315","bf360c","ff9e80","ff6e40","ff3d00","dd2c00","efebe9","d7ccc8","bcaaa4","a1887f","8d6e63","795548","6d4c41","5d4037","4e342e","3e2723","fafafa","f5f5f5","eeeeee","e0e0e0","bdbdbd","9e9e9e","757575","616161","424242","212121","eceff1","cfd8dc","b0bec5","90a4ae","78909c","607d8b","546e7a","455a64","37474f","263238"],"simple":["ffffff","d4d4d4","a1a1a1","787878","545454","303030","000000","edc5c5","e68383","ff0000","de2424","ad3636","823737","592b2b","f5d2ee","eb8dd7","f700b9","bf1f97","9c277f","732761","4f2445","e2bcf7","bf79e8","9d00ff","8330ba","6d3096","502c69","351b47","c5c3f0","736feb","0905f7","2e2eb0","2d2d80","252554","090936","c7e2ed","6ac3e6","00bbff","279ac4","347c96","2d5b6b","103947","bbf0d9","6febb3","00ff88","2eb878","349166","2b694c","0c3d25","c2edc0","76ed70","0dff00","36c72c","408c3b","315c2e","144511","d6edbb","b5eb73","8cff00","89c93a","6f8f44","4b632a","2a400c","f1f2bf","eef069","ffff00","baba30","91913f","5e5e2b","3b3b09","ffdeb8","f2ae61","ff8400","c48037","85623d","573e25","3d2309","fcbbae","ff8066","ff2b00","cc553d","9c5b4e","61372e","36130b"],"common":["000000","ffffff","464646","b4b4b4","990030","9c5a3c","ed1c24","ffa3b1","ff7e00","e5aa7a","ffc20e","f5e49c","fff200","fff9bd","a8e61d","d3f9bc","22b14c","00b7ef","99d9ea","4d6df3","709ad1","2f3699","546d8e","6f3198","b5a5d5","2b44a6","506fde","6c8dfa"],"skin tones":["ffe0bd","ffdbac","ffcd94","eac086","e0ac69","f1c27d","ffad60","c68642","8d5524","896347","765339","613D24","4C2D17","391E0B","351606","2D1304","180A01","090300"],"Simple Rainbow":["3B1830","4A2135","5E2F3F","7D3E3E","995B50","BA8270","D4A58C","C2717B","99567D","753D7A","57386B","3D2E57","2E233D","463E4A","5B5661","6F7078","82888C","97A1A3","BAC2BC","F2E9D3","8EC8D1","74A4C2","6485B3","546599","4D4C87","47396E","412D5E","3D204D","612751","7D2B53","913D59","AD4C56","D16C5A","E69065","EBB275","F0D299","A5C966","63B34F","459C57","377D54","276B5D","255457","1E3B45","172936","130A1C","22b14c"],"Middle of nowhere":["FF1744","F51743","EB1741","E1173F","D7173D","CD173F","C3173F","B91740","AF1740","A5173F","9B173F","91173F","87173E","7D173E","73173D","69173D","5F173D","55173D","4B173D","41173D","37173D","2D173D","23173D","19173D","0F173D","05173D"],"This took me an hour":["0B171F","28465A","3D5C74","58788D","7495A8","94B0C0","B1C5D2","CDDDE5","F0F4F7","00292A","004538","006045","007B46","009644","50B04A","94C952","C7E26E","810000","A20000","C2340B","E15C0F","F48925","F7AC38","FACE43","FFEF57","651415","822F22","9B4D2F","B76D3B","D18A4F","E9AA6B","F1C585","F9DAA2","47094D","7A0475","A41588","C4398B","DC5D86","F48D8A","FFB6A5","240553","291A72","2F4091","2C6FAF","28ADCF","4DD1DD","92E5E8","1F0C2C","30093D","51005D","81007A","83007A","B00081","C40380","C81680","D95588","EC849B","55BDED","6298D2","6579B6","5E5A91","584871","533D5A","362836","00cef7"]},"colorSelected":"This took me an hour","frames":[{"name":"","speed":100,"layers":[{"id":0,"src":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAAAr9JREFUeF7tmjFSAzEMRTc1FVXKNJyAK1Bxg1whQ8sMHQUdM7RMrpAbUHEFTkCTMhUVNYyZiHEUryXLstaTiI6Jd9d6/vqSvTsbGvzdv25+OLddPz38DVs9PnOGDy93yxlrYMEg9Rtynn0xXyQBfe+25vMxeeBYwBQsCyBNAUgDx2BagnAAORmGFayhH67/eruilJ79/fL2c6idQ+76rAIcgCtAngJggBopEHJEmgaUikdTIHZwycM18h/MQeoDnBiyANa77bCaL0T0ewFAxfAPQKtmx5ZeK/9YAVWlJHExqPoIgOake71X7CkHKaAt214BxJ7GArC5fj8Q0fLjhlRkMC5rAJx5YkNlA4Cgw0N6BkDN0wGg1vpIAUHbWLocaeGc6DEFwpxwU3XUB2gZ4RQAKGNKNVRJACkVUDfvQQG5OaZWP4xPdoIafXxPChgLfhRA+KEWQi8AcsFnAcQQJCkxNQAInNpJso7E8D6B0+BMASAOmgoc/IIFIDYXLgwrAJKg43iKAWCnHQPSCkBtwHj+1QC4QErL6NhWWHI4k3u2OgCcLhy/oOq3dtCqKZCbvEZXKT0O4yrOFcAlJRnnCujgzRC1cJ4CFKGa3zX2E9yOTjrPpgqA/YS0FLauAORmSEpVqxdwAJWvxjkL6CnAoVQzpqYX8BQ4hRSQVgKL1TepAg5gf8Ba2gucnAKCErgQqJPcGlNufiI0NrmSamC1+mYeUOoDDsCg/IFSm3eC8CBPgYLDEU8BT4G6D6RLyqSZB3ArgaX8TcugA0i0xNDxxR3iWSnAAey/2jobBWAfwAqwlr+6CXK/OIcVTwHglDDNt8WqZZDzIiT+cCIFILdlbrFNVgUAEs/t/aUAWgSvngL4hQj8j00ulwJ4LNxDU/bxPNUVgHOY6wtjud8qcPPtcLwtzhld64AnOxLjuPsUY34BfdJ/X6zj6AMAAAAASUVORK5CYII=","edit":false,"name":"Background","opacity":"1","active":true,"unqid":"2atbht","options":{"blend":"source-over","locked":false,"filter":{"brightness":"100%","contrast":"100%","grayscale":"0%","blur":0,"dropshadow_x":0,"dropshadow_y":0,"dropshadow_blur":0,"dropshadow_alpha":1}}},{"id":1,"src":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAAAURJREFUeF7tmjEOwkAQAy81D6DkZzyOn6XkAdRBV0RaRSG5hPXlfGsqisjsju0VRYYU/DME3z8JgBIQnIAqEDwAOoKqgCqwQeCV0vRMfddEFWCpwO3+mPKsn/foapqrGBLmDMAbAiUATwi0ALwgUAPwgEABwPb/1505exy7ATCDOQqiOwBHa9ElAFuTvUQIAPLPi5d2yRFc/tae8/PzXSWgdGkLix7AmaWpAfy78LIqFAnwuiVrOgKApMugrQQwuIScUQlA0mXQVgIYXELOqAQg6TJoKwEMLiFnVAKQdBm0lQAGl5AzKgFIugzaSgCDS8gZlQAkXQZtJYDBJeSMSgCSLoO2EsDgEnLGyxOAegW2FJoAlJJCPRc+ARmshZC/e78EsWXe5RWwAOygtSA0CyDDqAGhGQA1ll2rQhMAUAe2RDc8gC+KbFpBhd7odAAAAABJRU5ErkJggg==","edit":false,"name":"Layer 1","opacity":"0.49","active":true,"unqid":"zv6wjc","options":{"blend":"source-over","locked":false,"filter":{"brightness":"100%","contrast":"100%","grayscale":"0%","blur":0,"dropshadow_x":0,"dropshadow_y":0,"dropshadow_blur":0,"dropshadow_alpha":1}}}],"active":true,"selectedLayer":"0","unqid":"m079l","preview":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAAAvpJREFUeF7tmj1OgzEMhtuZCZaOXTgBV2DiBhUSB6hYEYiFgQUhsaIegKU3YOIKnIClYxeYmEEuNXJTJ3ESO/30NV2Q2vz5yeufhAwHBp+r5/mPZNjZ/c2q2fTuUdJ88HQ5GYoaJjRSH1Ay98FozAL6Xi6qr6fKhD6DY7BqADEFkGu4C8YSRAMQkiHsYAl96P/1ehxTevD3w7OPQekaQv2DCmgAmgLyXQADoIYLgI/kukFMxV4XoBE8Z3IN/8fgkBsHJDYEAcyWi8F0NM6i3xUAMRv+AWjlbBrSS+VPFVCUSpjOqOotAJqL1hzr9uJoZcb1+d/f3A+4E40pGy6gLVsLAKUQ3HgiAjA/edsAPnk/jW4ATGQFwAdBss5sAGg0TNIFABwEujbfOnsFwIWgAgAGdaUrkZbrE9Yu4M4HwTG2TjcAwhhbdYBWIKwNAIGEsgRXULEAOBVEo57TYFcAfAGS231WAfClRh2/SwB0L0ARPuO9ADQgdAXAw8vnRuHjKjl6H4AdUnP6rgGg4bTq49xYdCXmnhMkMHYBgBodMxxhiABQclIYtQDkGE3tSQbgysgHxApAqcFJMSA19dHgmRs7uIKKfpdzOROyo1gBocE1iqrc2yDp5jUAUlI57ZoCOvCPkdjGNReIESr5vbnA+h2ApHLkQIcOMSUbo1oIxRZSogLrFBg8DcYMk/7eABRkgqaAwrcBEpWapkE8G5QEQe3a3/wwxJ0W9xpArgpq+H+VLNAArG+ZU92gdwoAJUgh1KgAMVaZZwGcKKUgqrX71WJAahxoACoUQM0F1gRaDJDUyxptWhBMOBX2MghKM0FN46umwQaAKYmx4qMV4l4poAFYP1uFZ7D4uKnXCnDjACoAAdQ2Xj0ISl+co89zACQ1h+Y1mWolKHldRh9OUABgODx+oO7gwrA4JqsCQImHzv4SANDfffBoYby6C9Ado+7gpjnOBagCcBzpSy+J2/jaqCuAuxUuWaCmv3PrMAeQCsTaYHc91QGUqMGi7y/SbH9fnmhwPwAAAABJRU5ErkJggg==","width":64,"height":64}],"currentFrame":0,"speed":100,"name":"Untitled","preview":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAEAA/sfR5H8Fkddasdmnacvx/AABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAAA35JREFUeF7tW72OE0EMnquvgiZlGgQ9r0DFG5yQeIATLQLRUNAgJFp0D0Bzb3AVr0APokmZBqqrQb7EkXfinfGMfzbApEmk7M6uP3/+7PV4z1JKD1NK3y2/X366/pYEn6t3r++Ounz7QXB0Sh9fXJxZ3ifYDQvCxxyEEqjnq/VvzuLb7eaRtTNq65kjyoF5vlqLGJGDcrvduN+fKwPmPC3iOznIkxmuCPd6PpIJRQaABzU0hPN/3Txodfjk+HtPfyQNA8AJpfOLDKidXBMYON8IgG6m1pw4GFBKgRoGoABaMABiojcMuhlABazn4hb0RzHY60BzGNAsNKdls4vCyVfbTbpcrQH9rotrvZ8B0FwkgROIDez5Bw2wSllUwi0BUKUS5mR06sGzVjFLvWYJwJvn9++WfvVs9937gXCimjLJAhZ52xsALQh5XTGJ7Tnhun78ZQL4xdcnVQfAhTwYgBfmmCC5z1xQRQyAhdFo+ruEgjcAHBMk99nNgFMEIAehAYAD848YAIvm1JVQK2dDBAPoNSEkaveZCyAUgUf53UoIowEoaUOpnjh6FsB6QCtgSwEwlyWI9ydOZys8CxCWBCAPjTnjiz1BLQinAsD7zz+x8GGdXe0HIJqtIbE0AGj4vuqbtVPUE8x7exIwlgCAGk3L3dIjf9dTHo2xOTCiAOgxmnayRAyoNU04QLwAYAxudiK1R3Uy1xPsCZdaSU3/72nOlHqXagbUdoAkelEDwNpoVwbQxS3aYr3tMOl232CAFKme4wYDTmBnqLZ5Y54FhgaQYQtto5V7fq95tPV/VwbAzWj6C9qNUQkYrlkAwkEjhN4pkO0I9ai9VzE0GLCbDXANU9fFhwYMDdjNH/YIYYQAhs0J9qTCCAEMyQKDAftiiNtxmusDRFSAmLrdswDWFS1hEEX/MA1oDYMoAQzTgNZ6YDAgoAIcGrB/RcD9aRCRbimGhgYoB6QlfQDMTmEMkAphpACGZgFpKoykf2gdwDEAKz66e/RfMaAAQFiFuqgGIAAwBouDj/80A/IwyAGINt5cA6RviWHMcwBUZ3AVL09wDV/TWJMMVtHBCQoAGA7DDzQcuOHL2sxPa1fbXANqIEgA4Gb9SqNurUaHzAfQcMjTHBcClAHo+WzSq/mNEUlFaM6A/KLaN1H++n2BnJ41ofQch+EY4c4ACQ01Maxd/w9ZUS9qkKk5kAAAAABJRU5ErkJggg==","previewApp":"","art_edit_id":0,"palette_id":"44747","created_at":1690574335667,"updated_at":1690574335667,"persLayers":true,"id":1690573689902} \ No newline at end of file diff --git a/images/enemy_plane_images/enemy_plane_1.png b/images/enemy_plane_images/enemy_plane_1.png new file mode 100644 index 0000000..b590a45 Binary files /dev/null and b/images/enemy_plane_images/enemy_plane_1.png differ diff --git a/images/enemy_plane_images/enemy_plane_2.png b/images/enemy_plane_images/enemy_plane_2.png new file mode 100644 index 0000000..9ce70f8 Binary files /dev/null and b/images/enemy_plane_images/enemy_plane_2.png differ diff --git a/images/enemy_plane_images/enemy_plane_3.png b/images/enemy_plane_images/enemy_plane_3.png new file mode 100644 index 0000000..a1bc5a1 Binary files /dev/null and b/images/enemy_plane_images/enemy_plane_3.png differ diff --git a/images/environment/island_1.pixil b/images/environment/island_1.pixil new file mode 100644 index 0000000..591c644 --- /dev/null +++ b/images/environment/island_1.pixil @@ -0,0 +1 @@ +{"application":"pixil","type":".pixil","version":"2.7.0","website":"pixilart.com","author":"https://www.pixilart.com","contact":"support@pixilart.com","width":128,"height":128,"colors":{"default":["000000","ffffff","f44336","E91E63","9C27B0","673AB7","3F51B5","2196F3","03A9F4","00BCD4","009688","4CAF50","8BC34A","CDDC39","FFEB3B","FFC107","FF9800","FF5722","795548","9E9E9E","607D8B","ffebee","ffcdd2","ef9a9a","e57373","ef5350","e53935","d32f2f","c62828","b71c1c","ff8a80","ff5252","ff1744","d50000","fce4ec","f8bbd0","f48fb1","f06292","ec407a","e91e63","d81b60","c2185b","ad1457","880e4f","ff80ab","ff4081","f50057","c51162","f3e5f5","e1bee7","ce93d8","ba68c8","ab47bc","9c27b0","8e24aa","7b1fa2","6a1b9a","4a148c","ea80fc","e040fb","d500f9","aa00ff","ede7f6","d1c4e9","b39ddb","9575cd","7e57c2","673ab7","5e35b1","512da8","4527a0","311b92","b388ff","7c4dff","651fff","6200ea","e8eaf6","c5cae9","9fa8da","7986cb","5c6bc0","3f51b5","3949ab","303f9f","283593","1a237e","8c9eff","536dfe","3d5afe","304ffe","e3f2fd","bbdefb","90caf9","64b5f6","42a5f5","2196f3","1e88e5","1976d2","1565c0","0d47a1","82b1ff","448aff","2979ff","2962ff","e1f5fe","b3e5fc","81d4fa","4fc3f7","29b6f6","03a9f4","039be5","0288d1","0277bd","01579b","80d8ff","40c4ff","00b0ff","0091ea","e0f7fa","b2ebf2","80deea","4dd0e1","26c6da","00bcd4","00acc1","0097a7","00838f","006064","84ffff","18ffff","00e5ff","00b8d4","e0f2f1","b2dfdb","80cbc4","4db6ac","26a69a","009688","00897b","00796b","00695c","004d40","a7ffeb","64ffda","1de9b6","00bfa5","e8f5e9","c8e6c9","a5d6a7","81c784","66bb6a","4caf50","43a047","388e3c","2e7d32","1b5e20","b9f6ca","69f0ae","00e676","00c853","f1f8e9","dcedc8","c5e1a5","aed581","9ccc65","8bc34a","7cb342","689f38","558b2f","33691e","ccff90","b2ff59","76ff03","64dd17","f9fbe7","f0f4c3","e6ee9c","dce775","d4e157","cddc39","c0ca33","afb42b","9e9d24","827717","f4ff81","eeff41","c6ff00","aeea00","fffde7","fff9c4","fff59d","fff176","ffee58","ffeb3b","fdd835","fbc02d","f9a825","f57f17","ffff8d","ffff00","ffea00","ffd600","fff8e1","ffecb3","ffe082","ffd54f","ffca28","ffc107","ffb300","ffa000","ff8f00","ff6f00","ffe57f","ffd740","ffc400","ffab00","fff3e0","ffe0b2","ffcc80","ffb74d","ffa726","ff9800","fb8c00","f57c00","ef6c00","e65100","ffd180","ffab40","ff9100","ff6d00","fbe9e7","ffccbc","ffab91","ff8a65","ff7043","ff5722","f4511e","e64a19","d84315","bf360c","ff9e80","ff6e40","ff3d00","dd2c00","efebe9","d7ccc8","bcaaa4","a1887f","8d6e63","795548","6d4c41","5d4037","4e342e","3e2723","fafafa","f5f5f5","eeeeee","e0e0e0","bdbdbd","9e9e9e","757575","616161","424242","212121","eceff1","cfd8dc","b0bec5","90a4ae","78909c","607d8b","546e7a","455a64","37474f","263238"],"simple":["ffffff","d4d4d4","a1a1a1","787878","545454","303030","000000","edc5c5","e68383","ff0000","de2424","ad3636","823737","592b2b","f5d2ee","eb8dd7","f700b9","bf1f97","9c277f","732761","4f2445","e2bcf7","bf79e8","9d00ff","8330ba","6d3096","502c69","351b47","c5c3f0","736feb","0905f7","2e2eb0","2d2d80","252554","090936","c7e2ed","6ac3e6","00bbff","279ac4","347c96","2d5b6b","103947","bbf0d9","6febb3","00ff88","2eb878","349166","2b694c","0c3d25","c2edc0","76ed70","0dff00","36c72c","408c3b","315c2e","144511","d6edbb","b5eb73","8cff00","89c93a","6f8f44","4b632a","2a400c","f1f2bf","eef069","ffff00","baba30","91913f","5e5e2b","3b3b09","ffdeb8","f2ae61","ff8400","c48037","85623d","573e25","3d2309","fcbbae","ff8066","ff2b00","cc553d","9c5b4e","61372e","36130b"],"common":["000000","ffffff","464646","b4b4b4","990030","9c5a3c","ed1c24","ffa3b1","ff7e00","e5aa7a","ffc20e","f5e49c","fff200","fff9bd","a8e61d","d3f9bc","22b14c","00b7ef","99d9ea","4d6df3","709ad1","2f3699","546d8e","6f3198","b5a5d5","2b44a6","506fde","6c8dfa"],"skin tones":["ffe0bd","ffdbac","ffcd94","eac086","e0ac69","f1c27d","ffad60","c68642","8d5524","896347","765339","613D24","4C2D17","391E0B","351606","2D1304","180A01","090300"],"Simple Rainbow":["3B1830","4A2135","5E2F3F","7D3E3E","995B50","BA8270","D4A58C","C2717B","99567D","753D7A","57386B","3D2E57","2E233D","463E4A","5B5661","6F7078","82888C","97A1A3","BAC2BC","F2E9D3","8EC8D1","74A4C2","6485B3","546599","4D4C87","47396E","412D5E","3D204D","612751","7D2B53","913D59","AD4C56","D16C5A","E69065","EBB275","F0D299","A5C966","63B34F","459C57","377D54","276B5D","255457","1E3B45","172936","130A1C","22b14c"],"Middle of nowhere":["FF1744","F51743","EB1741","E1173F","D7173D","CD173F","C3173F","B91740","AF1740","A5173F","9B173F","91173F","87173E","7D173E","73173D","69173D","5F173D","55173D","4B173D","41173D","37173D","2D173D","23173D","19173D","0F173D","05173D"],"This took me an hour":["0B171F","28465A","3D5C74","58788D","7495A8","94B0C0","B1C5D2","CDDDE5","F0F4F7","00292A","004538","006045","007B46","009644","50B04A","94C952","C7E26E","810000","A20000","C2340B","E15C0F","F48925","F7AC38","FACE43","FFEF57","651415","822F22","9B4D2F","B76D3B","D18A4F","E9AA6B","F1C585","F9DAA2","47094D","7A0475","A41588","C4398B","DC5D86","F48D8A","FFB6A5","240553","291A72","2F4091","2C6FAF","28ADCF","4DD1DD","92E5E8","1F0C2C","30093D","51005D","81007A","83007A","B00081","C40380","C81680","D95588","EC849B","55BDED","6298D2","6579B6","5E5A91","584871","533D5A","362836","00cef7"]},"colorSelected":"This took me an hour","frames":[{"name":"","speed":100,"layers":[{"id":0,"src":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,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","edit":false,"name":"Background","opacity":"1","active":true,"unqid":"tybjhv","options":{"blend":"source-over","locked":false,"filter":{"brightness":"100%","contrast":"100%","grayscale":"0%","blur":0,"dropshadow_x":0,"dropshadow_y":0,"dropshadow_blur":0,"dropshadow_alpha":1}}}],"active":true,"selectedLayer":0,"unqid":"nczngo","preview":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,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","width":128,"height":128}],"currentFrame":0,"speed":100,"name":"Untitled","preview":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAIAA/sfR5H8Fkddasdmnacvx/AACACAYAAADDPmHLAAAAAXNSR0IArs4c6QAADXtJREFUeF7tnW2MHVUZx0/rK6XNtlCo1baYQtosIbsfKsu1Ul+KjUkLBmsJGFeJMSqxJGCTQmxMDY1pgnxQEzA2fDAkbXyBVgKIMdEaBZul0sRd093cAhsLLRVLoevWomC65j93n5vnPnvOnDOzM3Nn5pzz5e6dO/fcO/P8z+/5P8/M7s5RSq1SSh0Lj36ehzmqNYIIPF0EEEAIvqfBB/kDATwOPhZ/IIDnBAwECAQIHsDnKigQIBAgECAQwHMj5HMpHKoAz8UfPEDwAMEDBA/gOQaDB/Acg4EAgQDeXhALVYDn4g9VgOfpLxAgECDcERSqAM8xGKoAzzEYCBAI4O1d0aEK8Fz8oQrwPP0FAgQChKuBoQrwHIOhCvAcg4EAgQDhaqDPGAwECAQIBAgE8LMaCn0Azw1w6AR6nv4CAQIB/Mx9wfO04h4IEAgQCBD6AJ4bIZ/TQagCPBd/8ADBAwQPEDxAjTD44HObm9N//bT9cOd1B1bLIGM/3XbfxFB7D/Dgc5unoAQKtnzuswH0og9ARLjzugNzQvBnpvtaEkCXBmRamKZCLY8/SRqrfRXw8E39kSf473eu7NAAiOA7/mv7t4I5Ad73vZeiwJMA4AX4674bwVoRgHI8xzuC/cbX/6qWrljQFoLvQefkqxUGZWlH+D/18mSHAHhVYEoDvhjGWhGABxNiIPxDADuHx9ti1wXX12qhVgQg98uDCVHs6l/Z3Dk83tEMMomAPIIvfYNaEgDB5S5/V//KKU4AiMJUKvJ+AZUNdfYMtSSArIMlASQhsP/DN/VHHUNUC5Q6vvbkcLt5xGvIOpWQtSSANHaSAEQIngZ4v4AJoJ024ppLVSaElwTghOClI1Y57xvQStcZRFlqVlUEXhJAVgs813MScCMoryXIZlJVry56TYC40k82lSQpiABV7xd4QwAEjJeCcsXqjKGsFniJ6CKeKqQFLwiAnK8rBXV9A15C2ppDcdiXpWhZLzx5QQBbMwh0wPUCEEIGXWcEKZhxHUXmK0q9yEr95ZJc17atMBCApwEED0Gf3jaHE8KUHkxBlenD9ba0LI/Pdvym170hAKUBLgIuCl27mK902x1FVe0TeEMASgO6O4PQJo7zCNwrxBk7fgFK3oBS1rayVwSQInh65+Vq465/tjUhLxhJbJqMna2NXOYLS7UlwMC9O6YO37+74/ga+xtNHvCzP+tVC78wpkgIT3xxrXr+nr0zbiEHAbjhk7jn1w4orfAbUMp8V3LtCLBy3Zbm/CuWqPd/qEf95+SEOnf8NXX53SeiVb59wyr15xNnop8ReBpcCP976apo8/P37O0QD3kEU79AegzqKPILSrKzmNa4Zfm+uhCg2Te4NQo2hhQAbRvZ+5DaNrpJHRo704F+LgT8jNeHPj+kPvL9wYgICD5VC7IjyD1BnJHMMmhZVg+lIIAO144HOUWBR9BtAsDr2A9jy99+o/ODCjSgwYVC9xOY+gRcJGUNtu57dZUAOlyPP/OYNgezL98OOq1sCmwSAdB7QIXG/kZEBHiBtb2XdgiDPAJtHFz2QfyW0YyqwaWKcBR1oX+yrhsEcMa1UmqGGPoGt0Y45sHmAqAVTh6A9iVC0OucBvM+d2SGALD6MSAMSQX4hM/uO9RxbaGK+C/69wJS43pk70NtUvUNbo06elIAtEJNApCvcwF8esff26YQFCDDeHTds9HPXAA0D5nI6crBqY/gIwEyxzVyPg0SAWc2CQBop33lfrQPvQ8C4PmeAk74l2lBJwJJhDIGu3APkAeuebB1Ahh/5jG1ct0WJR91IqFtSAFUIiLoEAAJQvoCbCdB8FISc4EGGLKELLMYcvUAeeDaJAAe8Fe2367m9S5S58feVMsfeKRDEGQc+TwQAPL6x298syMV6IwhCYAepQgohWB+zFl2MeRaBRABeM6eLa75+4F5Wu0U9A4Lz55wMUgRUAogc8fnkPkfgcd+777yRS0JdIZxmgq26qZQ90/poBACmASQBtcUdMyJ99sCLwUBIWB8Yujf0SPmQHOIhq5JpDOB2N/WUOJzmjqM3U4PXSHAbHANAZiC3nP1cjUx+soMCJi2ExW4AKTBw3MdBbCdt5ZJECbDSK8zIZSCCIURICtcSwHI4OI5hhSCTgRcAHHmDvPB4AH7cYHnc8QJgtLIdGrIdRHaCJP3hzeRo7PENeYauHdHe5Xjgg81ff6w/j0zVj9t+NTBd6L9MPAeDDw/fP/u9vUBrF4ZROz3p6cWRfu/9RelDvxysdoz9kLH5+h8AReAaU4SFE02bRoLJUOuBFBKTeWB62cf6Y+CePf6Ne1A/KT5ovpRc0LdNn4q2vaunrnt1/ZdukTdtbpH3bG6daUP44cHj0QCuP724ei5Log88Atua61+HixUDXHDNGccSYr2CrkTgAsgC1zjCt3cMyuilXtF3+b2+e/pW6r2nFORAI6PHGhvB4H+2LhYbTo1X02MtMSBgX1AEhIAD6Qu8Lp8T8GyCQFzY05T4KWIRIrIlQi5EyAPXIMAOgH8euk5df1vJ9sEWLx2lXr90DFnAbgEPi5YOiHEBV6XGvj8RXiF3AjQ2N+IevYXDq/PFNc4oW+P9CgEmw80fEAbLgB6HSngo4+3qgc+QAX0AFwCnyRYEIJL4FOaxkyJkDkBcNsVTjIh07Ra0+B67sDBKH7nf9XK/WgF37znLfX4Ny6KHr/108VR508OBP4HX3ld/W73h6OA45HGd388qXZ+9YKiHG8q7dIEa9/2xdHHZGUaMReM6NFH9betpbkPIVMC7P/Xl5vXLLik46CzxDUEQC1bHSqRY0kc/HW0emV9zlco7Wubm88hW8Ly+/DnmBdikEIwpRPeZeR0ov2PPtp5u5qt1It7PVMCbBvdNPWxZa0bKkgIt3zpnUxxzfOizXzNxoWnmZvuIYgzjC5CwPmTgb/o2lb4S02AbaObmvwk4Avf983Wn2dLgutbGs1oJUtc4zmNJEKgE5rGhduEgLlNgTetcGw3CcEUeJprWgCZkTtzAtDJoC+M1cCJwDHIczHPyXTnLp1c1/Zqni5cN3fcinf9ziQEW+Dp/Jx+4Pfq+OlTmRnBzJQEA7JhTW9zcker2yaHTgh5OeU8XTjmtgU+jWHEysYg1Mvzh9cvHDqozr89BQFkFrdMCbBhTe/UiX9MqIvvWt9uepiEQNulaZSI54aIE0FXlkn6mMxX2tYt5WC0gzGydve64FPg8XnLPtCjcH7HTr5aTgLcunGg+cZrk9GXxIgTAiFSmsY0Tjkr82UzjSROCOvbd8xtG90031nn7rkAeODpc5kAykmAWzcOTEEANOKEQAKQptFEBF1aydJ8yflt6YnawEmEgM+Ic/cQgC7wl13dUKdHh6pDgIWNG9XZoadihSAFQDvHmUaeHvDzbK7Hx7nwNNWCTQg2k6cLvBRlZQgAAWBwEeC5JMKC3RMqiWnMw3xxF2673q+jEPkSExFsgac54e7nvZcsmf6TKuMBTCeKpwYcDInC1TTmbRixinUlaBpXj7kw0GbGcHH3JABCfmUJYBMAXr9kSatBlMQ0FmUYqeafbbXwmftaF4V0Q+fudftxMdSGAFIAnAz4WUcEuluHcj8e8zaMpi6g7eYROh6dAOLcvW3hlN4DUB+A8B53QJwArqYxSZeRPtvmG1zyelw7OM7VcwG4uPu488VTZmn7AOgEktHTiYAHWgoABx9nGhf94kjXDSMXgs3cIeC4xDz586uiDp4tuHTeTPuhA4iRZRs4l/8bCBGQuYsjAReADX04OYS/bhhGHmx+VS7O3MHVr1qxsF35pBUAC3xmzZ9C/mcQmkI46JHhE1Hw5EgiAPIMRRtGXbeOjsPF1TeuXd5hcm3unp+jvFa8vGkk02sBujtS0B6WQsCK7utfFh0v7xzaPEOSLuNsOoy2bp3ue+pcPY6Ri5a/T+fusVCOvXyWUJ/Lipc3hxTyIfhQTgQcIT85rqYRJzNPw+iS1+XKj3P1cQLgYqD0hm1ZGjyXO4VyJ4D8EuQR6AQkMY0kgKwNoy3w9F2R1y/bfkP01MXVuwggL3fvEvyi/0KI9rdfUTq6mkaXdJHGMCbp1s3/5A3Ort5FAEXl+tL/rWCdV+CYhGl0EUAawzjbbp30BIT0OAHk7e4rQwCpTF31QKYxqQBkmjF1GKUA4vI6z9c2V68TQLdXfOFVgKsS5X6cCAgknfg8DCP3ALJpI6/FcwHYXD0JAPsV7e5dz3thVUCaX1rAQZBHIJ9AYpDYlV1GV8OIS8BJunUmAehcfTfdvev5LrwKcFWmbr88DWNcD0ISKK5t221Xn/T8lp4Ars2lrAyjLa/bCFC2HG8jQaUIkKdh1K1qU7dOt29ZXL0XBMjDMNquxnETyvet2oqvTBWQVMmzNYyueZ1yfFldfdLzVkkP4HKQSQ1jnABolfPLu0X37G25PO3rlfYALgft2mG05PXMfhPHRbwux5XVPLUlQFLDaMjrtT8/tSeAzTAaunW1XfFdux+gSKy54FHXYRw7+WrtV3ytq4CyiawK38c7xVchKC4Ey+o4vPMARZ7crIKU5zyBAEp15e/05xnUJCIPBFDqWFmC0Y3vEQgQCBBdSPUagz4f//8B3bPTHUKVgMgAAAAASUVORK5CYII=","previewApp":"","art_edit_id":0,"palette_id":"44747","created_at":1690233056872,"updated_at":1690233056872,"persLayers":true,"id":1690229194555} \ No newline at end of file diff --git a/images/environment/island_1.png b/images/environment/island_1.png new file mode 100644 index 0000000..e763888 Binary files /dev/null and b/images/environment/island_1.png differ diff --git a/images/environment/island_2.pixil b/images/environment/island_2.pixil new file mode 100644 index 0000000..b01e74f --- /dev/null +++ b/images/environment/island_2.pixil @@ -0,0 +1 @@ +{"application":"pixil","type":".pixil","version":"2.7.0","website":"pixilart.com","author":"https://www.pixilart.com","contact":"support@pixilart.com","width":128,"height":128,"colors":{"default":["000000","ffffff","f44336","E91E63","9C27B0","673AB7","3F51B5","2196F3","03A9F4","00BCD4","009688","4CAF50","8BC34A","CDDC39","FFEB3B","FFC107","FF9800","FF5722","795548","9E9E9E","607D8B","ffebee","ffcdd2","ef9a9a","e57373","ef5350","e53935","d32f2f","c62828","b71c1c","ff8a80","ff5252","ff1744","d50000","fce4ec","f8bbd0","f48fb1","f06292","ec407a","e91e63","d81b60","c2185b","ad1457","880e4f","ff80ab","ff4081","f50057","c51162","f3e5f5","e1bee7","ce93d8","ba68c8","ab47bc","9c27b0","8e24aa","7b1fa2","6a1b9a","4a148c","ea80fc","e040fb","d500f9","aa00ff","ede7f6","d1c4e9","b39ddb","9575cd","7e57c2","673ab7","5e35b1","512da8","4527a0","311b92","b388ff","7c4dff","651fff","6200ea","e8eaf6","c5cae9","9fa8da","7986cb","5c6bc0","3f51b5","3949ab","303f9f","283593","1a237e","8c9eff","536dfe","3d5afe","304ffe","e3f2fd","bbdefb","90caf9","64b5f6","42a5f5","2196f3","1e88e5","1976d2","1565c0","0d47a1","82b1ff","448aff","2979ff","2962ff","e1f5fe","b3e5fc","81d4fa","4fc3f7","29b6f6","03a9f4","039be5","0288d1","0277bd","01579b","80d8ff","40c4ff","00b0ff","0091ea","e0f7fa","b2ebf2","80deea","4dd0e1","26c6da","00bcd4","00acc1","0097a7","00838f","006064","84ffff","18ffff","00e5ff","00b8d4","e0f2f1","b2dfdb","80cbc4","4db6ac","26a69a","009688","00897b","00796b","00695c","004d40","a7ffeb","64ffda","1de9b6","00bfa5","e8f5e9","c8e6c9","a5d6a7","81c784","66bb6a","4caf50","43a047","388e3c","2e7d32","1b5e20","b9f6ca","69f0ae","00e676","00c853","f1f8e9","dcedc8","c5e1a5","aed581","9ccc65","8bc34a","7cb342","689f38","558b2f","33691e","ccff90","b2ff59","76ff03","64dd17","f9fbe7","f0f4c3","e6ee9c","dce775","d4e157","cddc39","c0ca33","afb42b","9e9d24","827717","f4ff81","eeff41","c6ff00","aeea00","fffde7","fff9c4","fff59d","fff176","ffee58","ffeb3b","fdd835","fbc02d","f9a825","f57f17","ffff8d","ffff00","ffea00","ffd600","fff8e1","ffecb3","ffe082","ffd54f","ffca28","ffc107","ffb300","ffa000","ff8f00","ff6f00","ffe57f","ffd740","ffc400","ffab00","fff3e0","ffe0b2","ffcc80","ffb74d","ffa726","ff9800","fb8c00","f57c00","ef6c00","e65100","ffd180","ffab40","ff9100","ff6d00","fbe9e7","ffccbc","ffab91","ff8a65","ff7043","ff5722","f4511e","e64a19","d84315","bf360c","ff9e80","ff6e40","ff3d00","dd2c00","efebe9","d7ccc8","bcaaa4","a1887f","8d6e63","795548","6d4c41","5d4037","4e342e","3e2723","fafafa","f5f5f5","eeeeee","e0e0e0","bdbdbd","9e9e9e","757575","616161","424242","212121","eceff1","cfd8dc","b0bec5","90a4ae","78909c","607d8b","546e7a","455a64","37474f","263238"],"simple":["ffffff","d4d4d4","a1a1a1","787878","545454","303030","000000","edc5c5","e68383","ff0000","de2424","ad3636","823737","592b2b","f5d2ee","eb8dd7","f700b9","bf1f97","9c277f","732761","4f2445","e2bcf7","bf79e8","9d00ff","8330ba","6d3096","502c69","351b47","c5c3f0","736feb","0905f7","2e2eb0","2d2d80","252554","090936","c7e2ed","6ac3e6","00bbff","279ac4","347c96","2d5b6b","103947","bbf0d9","6febb3","00ff88","2eb878","349166","2b694c","0c3d25","c2edc0","76ed70","0dff00","36c72c","408c3b","315c2e","144511","d6edbb","b5eb73","8cff00","89c93a","6f8f44","4b632a","2a400c","f1f2bf","eef069","ffff00","baba30","91913f","5e5e2b","3b3b09","ffdeb8","f2ae61","ff8400","c48037","85623d","573e25","3d2309","fcbbae","ff8066","ff2b00","cc553d","9c5b4e","61372e","36130b"],"common":["000000","ffffff","464646","b4b4b4","990030","9c5a3c","ed1c24","ffa3b1","ff7e00","e5aa7a","ffc20e","f5e49c","fff200","fff9bd","a8e61d","d3f9bc","22b14c","00b7ef","99d9ea","4d6df3","709ad1","2f3699","546d8e","6f3198","b5a5d5","2b44a6","506fde","6c8dfa"],"skin tones":["ffe0bd","ffdbac","ffcd94","eac086","e0ac69","f1c27d","ffad60","c68642","8d5524","896347","765339","613D24","4C2D17","391E0B","351606","2D1304","180A01","090300"],"Simple Rainbow":["3B1830","4A2135","5E2F3F","7D3E3E","995B50","BA8270","D4A58C","C2717B","99567D","753D7A","57386B","3D2E57","2E233D","463E4A","5B5661","6F7078","82888C","97A1A3","BAC2BC","F2E9D3","8EC8D1","74A4C2","6485B3","546599","4D4C87","47396E","412D5E","3D204D","612751","7D2B53","913D59","AD4C56","D16C5A","E69065","EBB275","F0D299","A5C966","63B34F","459C57","377D54","276B5D","255457","1E3B45","172936","130A1C","22b14c"],"Middle of nowhere":["FF1744","F51743","EB1741","E1173F","D7173D","CD173F","C3173F","B91740","AF1740","A5173F","9B173F","91173F","87173E","7D173E","73173D","69173D","5F173D","55173D","4B173D","41173D","37173D","2D173D","23173D","19173D","0F173D","05173D"],"This took me an hour":["0B171F","28465A","3D5C74","58788D","7495A8","94B0C0","B1C5D2","CDDDE5","F0F4F7","00292A","004538","006045","007B46","009644","50B04A","94C952","C7E26E","810000","A20000","C2340B","E15C0F","F48925","F7AC38","FACE43","FFEF57","651415","822F22","9B4D2F","B76D3B","D18A4F","E9AA6B","F1C585","F9DAA2","47094D","7A0475","A41588","C4398B","DC5D86","F48D8A","FFB6A5","240553","291A72","2F4091","2C6FAF","28ADCF","4DD1DD","92E5E8","1F0C2C","30093D","51005D","81007A","83007A","B00081","C40380","C81680","D95588","EC849B","55BDED","6298D2","6579B6","5E5A91","584871","533D5A","362836","00cef7"]},"colorSelected":"This took me an hour","frames":[{"name":"","speed":100,"layers":[{"id":0,"src":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAYAAADDPmHLAAAAAXNSR0IArs4c6QAADVRJREFUeF7tXH+MVFcVPtSVWHAtu2y7CtiasNKAWDW6uAuh6ZaQQkviXwSiq41uYrQYGivbWJKaEBP8AdZgUo2loE3B2BJqqmioDWzTBha7oJHW2fBL3WZZu/xa6Jo1wbVjvjtzHnfu3vfufTPzZt7MvfcfZmfevHfP+b77ne+eO+008sPpDExzOnofPHkCOE4CTwBPAMcz4Hj4XgE8ARzPgOPhewXwBHA8A46H7xXAE8DxDDgevlcATwDHM+B4+F4BPAEcz4Dj4XsF8ARwPAOOh+8VwBPA8Qw4Hr5XAE8AxzPgePheATwBHM+A4+F7BfAEcDwDjofvFcATwPEMOB6+VwBPAMcz4Hj4XgE8ARzPgOPhewXwBHA8A46H7xXAE8DxDDgevlcATwDHM+B4+F4BPAEcz4Dj4XsF8ARwPAOOh+8VwBPA8Qw4Hr5XAE8AxzNARA0tDVlkYfLSpHMLwrmAdXT3BHBUBAB817e76MhTR2jZV5dR3/f7nFMBZxUA4E9vnk5NK5qoZ00Pbf/mdmpqa6LR10cjSVBvauEkAQBi69pWoiGing09Qv/6B/spcy5Do/s8Aeq6IPDKR5CQfR6dCztp14FdNHZojCZOT0xZGPVaLpxSAJZvSD/Ax4oH4DIR4AfUUlBMuaiVUuEMAdQVDKB5wAeIMUQ0dnaMNv14kygJL296eVqx5cITIGWFRAC5pJXojtzEFs1fFMyQyQAlQCkA+NgRYEAt4pSLWisVzigAQAykvC234rHaIfeCEPfmCCFvCZkAtuWimFJR7XXiDAECKZdWP9d7gA8/IEhxaIyuX7lOcn/AplxAMYrdWVSTBE4RYPMzm8V+Xx5B/c+/iZ7A1ge3UtxyEbdUVBN0+dlOEYAbP+wBsOplL5A5nBGlAP+iISSuN5QLqEXcUpEW8DEPJwgg7/3h8OUhOoDYBQzlfACDL+TcUC7QNIpbKrCz8ASoQgZkg4Y6j8Hyj7/FSs/vEACsTbnAdXFLRdpOHFPFxqR4wVtAuH4MuHp2+yz72P5h7Hpy1w35z/cHUCbCygXMn02pSOthkzsEWNsqHD5WPXf/2PnLxMOqZkNnKheB87fYWdgcNCW1AKLu6w4BlrTS+T+cL8jFjAUzpuQGBGESMFnCyoVtqcDOgptLvgRUmOaQ/8lLk7Tuzjniyc+dGqHe5Te6gE+O/nNK/UddtykX2C7G2VnAY5hOGyucHid2AVkGX0cAvLfttQzN/fpcsSXM/yikAIeV21cGjSL+IE6pgM8A+NL9U6O8qZlIQswvAL+9/SO0ac9R2t69VDxudOhq8NhfLb5G5392PlIp1DmiB8AKYNpZ8E4D/QWMtJSCuibAujvniB97MvBdH18QYNj3xmnxmssBVMBKKe6fK1YzbwFtSgV2FkG7eYiMvzpKaDFob1uXBOjY3yGAv2PzWwXgz5udP/YlouHLuS0hE0EG36QUQj3QA7DcWfCuA1tNNJ6gHF4BEqA5A9+7cgEdGb5Mc7aOCcnnlS8TAI8HCUAABt9WKeAXgiZQPg5e4VwK5PDkhlOawMcc60IBVOA5+X9Zd0YAvO0LiyPpdvz4FSulgHcAoRpaGkTt518SFZwqHs7cOGbOdxa5/5C2HUDNEyAM+KODl2npwtkC9CcW/Z6+vLyNfvHaWfF3/3fvoaf+OFzw95FT162UglkEAmDIbWD8XXCwlD9e5i4izhpE6TD86jgBYYy8ZU0qgAl4lQCPrV1F39t3MCDAb0++jzIbf0MvLr9ZEGLz8yNWStG7901xj0cyD4h/f3L3S0HXMDhLyAPN5wriwrzxw8u01H5mRc0RYP87X8oubmwW8//54JkCdgP4yXNt1DD/rFAArH6MSAXobaPObTl1MClF5+OvBODjeibaFCLkf23Ek0Pd/+Sj6+n4o3tSl+/UTShMr3jV8+cAem9vi5YIePNHCw/QZ2fOpNcnJqi/t01cNz753uD2jQ3/zb3+wDwCsBgmpdARQCYciHDbZK48YFxomKSNr94nXjM58TpNREg9AaLkHsnHCCPCxYcuhfGp4P1nX/mTWQHySsHyr94YAGMMdh8PPuo5kQNfHmkjQmoJEAZ8VEJVInAJiGJBNpuNrRQyCRh43nrys2Qfont+WoiQOgKYDF4YmEjo3y8tpduvXShQhK88fcFKBXDRD/58k/FaqMVnftgtfAZGGPAqAcIIUW0ipIYAJuCLSegv3z5F+07mCLD2rtsKwMX76nu4YPETA0YSgAD/GSB64fkWoxFVFUFHhFcPNAWE4utR3irhFapKAJ2xu3tNrkUrJ042WrYJZfDHFn1OfKUp86IWcB3a4+8ZKzSMza1E7wyL3cLH1nZT4/rc6pfBUuet3lfdoeBzGXidkrDHSZIIVSGAjbErJaFPH/mfWPkAv729XWAxMDAQSQJVEUay/y7AsLG5VewWOvZ3aGWfwTLN2wR8GHHwfhJEqCgBijF2cROqA7+vr4+6urqMJFCTP940M9giomGkbgOjwNLN27TiuXupU6WkvEJFCGCq72FFVw7aNqGNG98sWPnqvXVKEOYHQIDPz/4d/eOhRtExZALEcfiYtw3wxXiccihCogQwAV9M0DYJ3TCxQeDOK18lQUtLroEUNVavXq39GFvAYuYd1qvQeQM8mJ8RZhpxDYzo3/aV1l1MjABxWracaVPQvPWKMl+4BxMgDGAbAjz+xl4qhyHlPoE8Z5BBbWPbmkYGnq9PLQEeyTyQXTYvdyIX1ru3DTpqz60zX586sb7g1qoSdHd3a7lx8GDuwAhjy8QWca6AYfIhulUc1SCSO5gmIuD5KCEy8DfnfG26FQAEkJMQhwgcdBjwYcRhsFQCqNdDAVatWkUMOF53zL/xE/Fj5yboW4NrxNdMPkQ3F7ynbuui5hymCGHA871SXQJkAvCEkRQTEWwMk3b5SmA9/KGpPXj+Dkzgjh07aPfu3eKtnTt3Un9/P31x6azgts8evRoQgN80EaEcLWEmggl4ntPFbYdo6OK/SirjJX05DAi8v/LTC7Pjm2/RXqIjgg3wtubLRgFGRkamEKC5/UG6MvAMgQCdL3QGPyqRg1CJYALeds7yfbGyMVjq1STi83ePHqaJ69l0E2D47Ws08+F7p7Q5VUXgv23P+eVVib2zmmSZALqdADyATgHOjF6nj7ZOLyCAyYWjHYxh+m2Cac74XF75OvAZeFw774O3EPI7eH6kpEVc0pejFGDd/UuyV0bHxSQxoojADZBymEabXQDmIxvBPXv20Es//UZBCYACqC3osJ79Y1+7qWSji4fzyldXvww8T7JmCMATjiICE6AU0xgmxSpJZam12Y7xyrTZicQhgrriZdABOBRAB/ytizroYuZY7SjArI41dPXYgQAHHRFUAqglImobaarBYSplQ4QoXxJFLBMRTCZPB7z6vJpRABAAQyYB/laJ0Lj1GsUxjSbgizFfsgs3nffbEEslggl4vifc/Yzp0dW5ZggQ5ROYCAiGX9uaxnIZRjxX160DePiPS0zmLexcQFYY3AvjOz3vin9t3D0TgCW/ZhXARAB83tzaKC6LYxrLZRjx3KizeO4Cltqzv29L7lBIN3TuXnedTIa6UQCVABy4yTRW2jCGtYN1xFClHjHpCBDl7k0LJ/UEQCMIILK8RwUkK4CtaVRl26bLaPINNnU96lwgqmcvE8DG3UflSy6Zqe0DMAEQiI4EMtAqAUymsem5E1U3jDIRTOYOgONnZOO/bhMdPBO4rH5h16EDiFFqGxj3SKwRhJuDBPjXpAQyAUzSx/eK02Usp2HUdetMrVu4+gW3zwp2PsUSoJzA8xwSJQA/BF1BvD7512GtGsQhAHuGShtGXV3n+GxcfUf7hwtMrsndyyRJAviKEiCKCFjJd31inrgEoNoMEEa+NknDGFXXTcBz+eMYZdLKcercPcrm6bdy/wubckh9WF4rogDqw2VFwGcgACfH1jTi+iQNo01dVwkQ5erlGG1LQKkGz2YxVYUAPDH2CPw3r2Qb08gEwHejuoxxDaMJeJ4r6vqtvSvEnzau3oYA5XT3NuDjmqoSQJ1kHNNoUy6KMYxxunXvv2eFtau3IUCStT5VJcDEThvTaEOAYgxjqd06NTZu2EQRoBrAV8UEmoCP8gqyPHIybe4X1zCqBIiq6wwu5mFy9ToCVBP4miAAT1I1jZz4JAyj7AHUpo16Fi8TwOTqZdJWwt3bLI7UeQDTpGXTmIRhxBFwnG5dGAHkOGSy8pwr4e5NuawpBdAFk6RhNCVPB6ruO9Vw9aa5q5+nahcQd/K4PknDaKrrJgVIQ4035bTmCaDzCaUaRt1hTFi3TndtLQBf8yUgjNnlMIym07iwElBLwNctATiwUgxjFAFkdeHXaXL1JsmvOw9gE3BcwxhFAF7l8vFumly9TT7ka+rGA9gEbmsYa72u2+Si7ktAVBJ0RAg7sq3Fuu4JYJmBsGNpfL2W67pl+OIyp0pAWGJ0hrGW67onQJwMOH6tVwBPAMcz4Hj4XgE8ARzPgOPhewXwBHA8A46H7xXAE8DxDDgevlcATwDHM+B4+P8HY4YaNYfspxQAAAAASUVORK5CYII=","edit":false,"name":"Background","opacity":"1","active":true,"unqid":"jnw9im","options":{"blend":"source-over","locked":false,"filter":{"brightness":"100%","contrast":"100%","grayscale":"0%","blur":0,"dropshadow_x":0,"dropshadow_y":0,"dropshadow_blur":0,"dropshadow_alpha":1}}}],"active":true,"selectedLayer":0,"unqid":"ntkyod","preview":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,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","width":128,"height":128}],"currentFrame":0,"speed":100,"name":"Untitled","preview":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,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","previewApp":"","art_edit_id":0,"palette_id":"44747","created_at":1690234224330,"updated_at":1690234224330,"persLayers":true,"id":1690229194555} \ No newline at end of file diff --git a/images/environment/island_2.png b/images/environment/island_2.png new file mode 100644 index 0000000..d0fff2d Binary files /dev/null and b/images/environment/island_2.png differ diff --git a/images/environment/ocean.piskel b/images/environment/ocean.piskel new file mode 100644 index 0000000..2016462 --- /dev/null +++ b/images/environment/ocean.piskel @@ -0,0 +1 @@ +{"modelVersion":2,"piskel":{"name":"ocean","description":"","fps":24,"height":800,"width":1600,"layers":["{\"name\":\"Layer 1\",\"opacity\":1,\"frameCount\":1,\"chunks\":[{\"layout\":[[0]],\"base64PNG\":\"data:image/png;base64,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\"}]}"],"hiddenFrames":[""]}} \ No newline at end of file diff --git a/images/environment/ocean.png b/images/environment/ocean.png new file mode 100644 index 0000000..7d6f243 Binary files /dev/null and b/images/environment/ocean.png differ diff --git a/images/menu/button_background.png b/images/menu/button_background.png new file mode 100644 index 0000000..f4e1d19 Binary files /dev/null and b/images/menu/button_background.png differ diff --git a/images/menu/button_background2.png b/images/menu/button_background2.png new file mode 100644 index 0000000..6d1e272 Binary files /dev/null and b/images/menu/button_background2.png differ diff --git a/images/menu/button_background2_hover.png b/images/menu/button_background2_hover.png new file mode 100644 index 0000000..f355e8c Binary files /dev/null and b/images/menu/button_background2_hover.png differ diff --git a/images/menu/button_background_hover.png b/images/menu/button_background_hover.png new file mode 100644 index 0000000..043dd29 Binary files /dev/null and b/images/menu/button_background_hover.png differ diff --git a/images/menu/credits_menu_background.jpg b/images/menu/credits_menu_background.jpg new file mode 100644 index 0000000..21c5679 Binary files /dev/null and b/images/menu/credits_menu_background.jpg differ diff --git a/images/menu/gold_icon.png b/images/menu/gold_icon.png new file mode 100644 index 0000000..d6a39dc Binary files /dev/null and b/images/menu/gold_icon.png differ diff --git a/images/menu/main_menu_background2.jpg b/images/menu/main_menu_background2.jpg new file mode 100644 index 0000000..b8062fe Binary files /dev/null and b/images/menu/main_menu_background2.jpg differ diff --git a/images/menu/plane_icon.jpg b/images/menu/plane_icon.jpg new file mode 100644 index 0000000..b5897bd Binary files /dev/null and b/images/menu/plane_icon.jpg differ diff --git a/images/menu/planes_background.png b/images/menu/planes_background.png new file mode 100644 index 0000000..7a7dd4e Binary files /dev/null and b/images/menu/planes_background.png differ diff --git a/images/menu/planes_menu_background (copy).jpg b/images/menu/planes_menu_background (copy).jpg new file mode 100644 index 0000000..c3256c6 Binary files /dev/null and b/images/menu/planes_menu_background (copy).jpg differ diff --git a/images/menu/planes_menu_background.jpg b/images/menu/planes_menu_background.jpg new file mode 100644 index 0000000..945f4b5 Binary files /dev/null and b/images/menu/planes_menu_background.jpg differ diff --git a/images/menu/settings_background.jpg b/images/menu/settings_background.jpg new file mode 100644 index 0000000..c7d06aa Binary files /dev/null and b/images/menu/settings_background.jpg differ diff --git a/images/power_ups/powerup_x2.pixil b/images/power_ups/powerup_x2.pixil new file mode 100644 index 0000000..b3cb026 --- /dev/null +++ b/images/power_ups/powerup_x2.pixil @@ -0,0 +1 @@ +{"application":"pixil","type":".pixil","version":"2.7.0","website":"pixilart.com","author":"https://www.pixilart.com","contact":"support@pixilart.com","width":20,"height":20,"colors":{"default":["000000","ffffff","f44336","E91E63","9C27B0","673AB7","3F51B5","2196F3","03A9F4","00BCD4","009688","4CAF50","8BC34A","CDDC39","FFEB3B","FFC107","FF9800","FF5722","795548","9E9E9E","607D8B","ffebee","ffcdd2","ef9a9a","e57373","ef5350","e53935","d32f2f","c62828","b71c1c","ff8a80","ff5252","ff1744","d50000","fce4ec","f8bbd0","f48fb1","f06292","ec407a","e91e63","d81b60","c2185b","ad1457","880e4f","ff80ab","ff4081","f50057","c51162","f3e5f5","e1bee7","ce93d8","ba68c8","ab47bc","9c27b0","8e24aa","7b1fa2","6a1b9a","4a148c","ea80fc","e040fb","d500f9","aa00ff","ede7f6","d1c4e9","b39ddb","9575cd","7e57c2","673ab7","5e35b1","512da8","4527a0","311b92","b388ff","7c4dff","651fff","6200ea","e8eaf6","c5cae9","9fa8da","7986cb","5c6bc0","3f51b5","3949ab","303f9f","283593","1a237e","8c9eff","536dfe","3d5afe","304ffe","e3f2fd","bbdefb","90caf9","64b5f6","42a5f5","2196f3","1e88e5","1976d2","1565c0","0d47a1","82b1ff","448aff","2979ff","2962ff","e1f5fe","b3e5fc","81d4fa","4fc3f7","29b6f6","03a9f4","039be5","0288d1","0277bd","01579b","80d8ff","40c4ff","00b0ff","0091ea","e0f7fa","b2ebf2","80deea","4dd0e1","26c6da","00bcd4","00acc1","0097a7","00838f","006064","84ffff","18ffff","00e5ff","00b8d4","e0f2f1","b2dfdb","80cbc4","4db6ac","26a69a","009688","00897b","00796b","00695c","004d40","a7ffeb","64ffda","1de9b6","00bfa5","e8f5e9","c8e6c9","a5d6a7","81c784","66bb6a","4caf50","43a047","388e3c","2e7d32","1b5e20","b9f6ca","69f0ae","00e676","00c853","f1f8e9","dcedc8","c5e1a5","aed581","9ccc65","8bc34a","7cb342","689f38","558b2f","33691e","ccff90","b2ff59","76ff03","64dd17","f9fbe7","f0f4c3","e6ee9c","dce775","d4e157","cddc39","c0ca33","afb42b","9e9d24","827717","f4ff81","eeff41","c6ff00","aeea00","fffde7","fff9c4","fff59d","fff176","ffee58","ffeb3b","fdd835","fbc02d","f9a825","f57f17","ffff8d","ffff00","ffea00","ffd600","fff8e1","ffecb3","ffe082","ffd54f","ffca28","ffc107","ffb300","ffa000","ff8f00","ff6f00","ffe57f","ffd740","ffc400","ffab00","fff3e0","ffe0b2","ffcc80","ffb74d","ffa726","ff9800","fb8c00","f57c00","ef6c00","e65100","ffd180","ffab40","ff9100","ff6d00","fbe9e7","ffccbc","ffab91","ff8a65","ff7043","ff5722","f4511e","e64a19","d84315","bf360c","ff9e80","ff6e40","ff3d00","dd2c00","efebe9","d7ccc8","bcaaa4","a1887f","8d6e63","795548","6d4c41","5d4037","4e342e","3e2723","fafafa","f5f5f5","eeeeee","e0e0e0","bdbdbd","9e9e9e","757575","616161","424242","212121","eceff1","cfd8dc","b0bec5","90a4ae","78909c","607d8b","546e7a","455a64","37474f","263238"],"simple":["ffffff","d4d4d4","a1a1a1","787878","545454","303030","000000","edc5c5","e68383","ff0000","de2424","ad3636","823737","592b2b","f5d2ee","eb8dd7","f700b9","bf1f97","9c277f","732761","4f2445","e2bcf7","bf79e8","9d00ff","8330ba","6d3096","502c69","351b47","c5c3f0","736feb","0905f7","2e2eb0","2d2d80","252554","090936","c7e2ed","6ac3e6","00bbff","279ac4","347c96","2d5b6b","103947","bbf0d9","6febb3","00ff88","2eb878","349166","2b694c","0c3d25","c2edc0","76ed70","0dff00","36c72c","408c3b","315c2e","144511","d6edbb","b5eb73","8cff00","89c93a","6f8f44","4b632a","2a400c","f1f2bf","eef069","ffff00","baba30","91913f","5e5e2b","3b3b09","ffdeb8","f2ae61","ff8400","c48037","85623d","573e25","3d2309","fcbbae","ff8066","ff2b00","cc553d","9c5b4e","61372e","36130b"],"common":["000000","ffffff","464646","b4b4b4","990030","9c5a3c","ed1c24","ffa3b1","ff7e00","e5aa7a","ffc20e","f5e49c","fff200","fff9bd","a8e61d","d3f9bc","22b14c","00b7ef","99d9ea","4d6df3","709ad1","2f3699","546d8e","6f3198","b5a5d5","2b44a6","506fde","6c8dfa"],"skin tones":["ffe0bd","ffdbac","ffcd94","eac086","e0ac69","f1c27d","ffad60","c68642","8d5524","896347","765339","613D24","4C2D17","391E0B","351606","2D1304","180A01","090300"],"Simple Rainbow":["3B1830","4A2135","5E2F3F","7D3E3E","995B50","BA8270","D4A58C","C2717B","99567D","753D7A","57386B","3D2E57","2E233D","463E4A","5B5661","6F7078","82888C","97A1A3","BAC2BC","F2E9D3","8EC8D1","74A4C2","6485B3","546599","4D4C87","47396E","412D5E","3D204D","612751","7D2B53","913D59","AD4C56","D16C5A","E69065","EBB275","F0D299","A5C966","63B34F","459C57","377D54","276B5D","255457","1E3B45","172936","130A1C","22b14c"],"Middle of nowhere":["FF1744","F51743","EB1741","E1173F","D7173D","CD173F","C3173F","B91740","AF1740","A5173F","9B173F","91173F","87173E","7D173E","73173D","69173D","5F173D","55173D","4B173D","41173D","37173D","2D173D","23173D","19173D","0F173D","05173D"],"This took me an hour":["0B171F","28465A","3D5C74","58788D","7495A8","94B0C0","B1C5D2","CDDDE5","F0F4F7","00292A","004538","006045","007B46","009644","50B04A","94C952","C7E26E","810000","A20000","C2340B","E15C0F","F48925","F7AC38","FACE43","FFEF57","651415","822F22","9B4D2F","B76D3B","D18A4F","E9AA6B","F1C585","F9DAA2","47094D","7A0475","A41588","C4398B","DC5D86","F48D8A","FFB6A5","240553","291A72","2F4091","2C6FAF","28ADCF","4DD1DD","92E5E8","1F0C2C","30093D","51005D","81007A","83007A","B00081","C40380","C81680","D95588","EC849B","55BDED","6298D2","6579B6","5E5A91","584871","533D5A","362836","00cef7"]},"colorSelected":"This took me an hour","frames":[{"name":"","speed":100,"layers":[{"id":0,"src":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAYAAACNiR0NAAAAAXNSR0IArs4c6QAAAHlJREFUOE9jZKAyYKSyeQxYDdTJX/+fkEVXJgZi1YshSIxhMMuwGYpiICmG4TKUYgNBBiO7FG4gOa5DDmeYoaMGEkp9uOVpG4aUxjBy0gHHMtUNpIahVA1DrDkFFn+keh+9gCC7+ELPwzAH4SxgCbmU6PKQ/KQN0QkAckFEFRuahScAAAAASUVORK5CYII=","edit":false,"name":"Layer 2","opacity":"0.99","active":true,"unqid":"gext29","options":{"blend":"source-over","locked":false,"filter":{"brightness":"100%","contrast":"100%","grayscale":"0%","blur":0,"dropshadow_x":0,"dropshadow_y":0,"dropshadow_blur":0,"dropshadow_alpha":1}}},{"id":1,"src":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAYAAACNiR0NAAAAAXNSR0IArs4c6QAAAKBJREFUOE+1lDsSgCAMREPtASy9mYfzZpYewFoHZ+IEyJcBO4F9yRLdBIOfJPGWdXu0Wvd1slp2McMkARaRzjRAD0yDFsAITIL+wB4YB/2AHtgB0AxpB2gaCgEpIBdwAeuD9Xt2xK2hS7ZDFHhh9NpEyxGYCeQ6tK5CtCwJh0/ZyhB1KJaY2y+A3o9bSyYMk3n/shVLmk26Nz8Paac9if0CtB20FW5jgacAAAAASUVORK5CYII=","edit":false,"name":"Background","opacity":"1","active":true,"unqid":"goc2fe","options":{"blend":"source-over","locked":false,"filter":{"brightness":"100%","contrast":"100%","grayscale":"0%","blur":0,"dropshadow_x":0,"dropshadow_y":0,"dropshadow_blur":0,"dropshadow_alpha":1}}},{"id":2,"src":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAYAAACNiR0NAAAAAXNSR0IArs4c6QAAAF1JREFUOE9jZKAyYKSyeQyjBlIeohSF4f/34f8ZBVeimEGSgegGEG0gMRqxGQYKMJwuhGnAphGXYXgNBEmSahjJLiQmKLB6mRiNuHxAUiwTk0pHDSQmlPCrGfxhCAAhM0gVILXrCwAAAABJRU5ErkJggg==","edit":false,"name":"Layer 1","opacity":"0.44","active":true,"unqid":"f6ze5n","options":{"blend":"source-over","locked":false,"filter":{"brightness":"100%","contrast":"100%","grayscale":"0%","blur":0,"dropshadow_x":0,"dropshadow_y":0,"dropshadow_blur":0,"dropshadow_alpha":1}}}],"active":true,"selectedLayer":2,"unqid":"b4gcfp","preview":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAUCAYAAACNiR0NAAAAAXNSR0IArs4c6QAAALpJREFUOE9jZKAyYMRlHre4/H98dn19+RCrXqyCIMMUIyb8xWfg/RUFzNgMxTCQGMNgFmEzFMVAUgzDZSjcQHIMw2Yo2EBiDCubGMiMHqbPV3T8W3xcHRx5MO+TZCCyASALiDIQXSE6H+QabGJ4XQjTIBlRwYTsClyGEeVlYl2GHjFYwxCbCwkFBU4v49II8j5VY5lQGUJysiHJQGITNy5DkfM07fIyzHZisiHRpQ0phhJdHiIbSk6JDQC13gUkR0BETAAAAABJRU5ErkJggg==","width":20,"height":20,"data_id":0}],"currentFrame":0,"speed":100,"name":"Untitled","preview":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAABQA/sfR5H8Fkddasdmnacvx/AAAUCAYAAACNiR0NAAAAAXNSR0IArs4c6QAAANtJREFUOE9jZGBgUGNgYLhFLZqRAQIwDOUWl78JlcNKfX35EKQXQx9WQZBhihET/uIz8P6KAmZshmK4kBjDYBZhMxTFhaQYhstQuAvJMQyboWAXEmNY2cRAZvQwfb6i49/i4+r/QeIw74NdyC0u/59QJIAMRDYAnQ81UB3DhYQ0ghyAroagC2EaJCMqmJBdhcswJAMxXQgLJ2yuwCaGHjFYwxCbCwkFBclhCPI+VWMZXzYkKgwJGYAuj5IOiU3cuCxBztO0y8uwQpaYbEh0aUOKoUSXh8iGklNiAwB2pCigxoi7lQAAAABJRU5ErkJggg==","previewApp":"","art_edit_id":0,"palette_id":"44747","created_at":1690575770688,"updated_at":1690575770688,"persLayers":true,"id":1690573689902} \ No newline at end of file diff --git a/images/power_ups/powerup_x2.png b/images/power_ups/powerup_x2.png new file mode 100644 index 0000000..73b9209 Binary files /dev/null and b/images/power_ups/powerup_x2.png differ diff --git a/images/ranks/ace_rank.png b/images/ranks/ace_rank.png new file mode 100644 index 0000000..efa2908 Binary files /dev/null and b/images/ranks/ace_rank.png differ diff --git a/images/ranks/airman_rank.png b/images/ranks/airman_rank.png new file mode 100644 index 0000000..ad82288 Binary files /dev/null and b/images/ranks/airman_rank.png differ diff --git a/images/ranks/one_star_general_rank.png b/images/ranks/one_star_general_rank.png new file mode 100644 index 0000000..01c1b79 Binary files /dev/null and b/images/ranks/one_star_general_rank.png differ diff --git a/images/ranks/senior_airman_rank.png b/images/ranks/senior_airman_rank.png new file mode 100644 index 0000000..bab63dc Binary files /dev/null and b/images/ranks/senior_airman_rank.png differ diff --git a/images/user_plane_images/user_bullet.pixil b/images/user_plane_images/user_bullet.pixil new file mode 100644 index 0000000..375b11b --- /dev/null +++ b/images/user_plane_images/user_bullet.pixil @@ -0,0 +1 @@ +{"application":"pixil","type":".pixil","version":"2.7.0","website":"pixilart.com","author":"https://www.pixilart.com","contact":"support@pixilart.com","width":2,"height":6,"colors":{"default":["000000","ffffff","f44336","E91E63","9C27B0","673AB7","3F51B5","2196F3","03A9F4","00BCD4","009688","4CAF50","8BC34A","CDDC39","FFEB3B","FFC107","FF9800","FF5722","795548","9E9E9E","607D8B","ffebee","ffcdd2","ef9a9a","e57373","ef5350","e53935","d32f2f","c62828","b71c1c","ff8a80","ff5252","ff1744","d50000","fce4ec","f8bbd0","f48fb1","f06292","ec407a","e91e63","d81b60","c2185b","ad1457","880e4f","ff80ab","ff4081","f50057","c51162","f3e5f5","e1bee7","ce93d8","ba68c8","ab47bc","9c27b0","8e24aa","7b1fa2","6a1b9a","4a148c","ea80fc","e040fb","d500f9","aa00ff","ede7f6","d1c4e9","b39ddb","9575cd","7e57c2","673ab7","5e35b1","512da8","4527a0","311b92","b388ff","7c4dff","651fff","6200ea","e8eaf6","c5cae9","9fa8da","7986cb","5c6bc0","3f51b5","3949ab","303f9f","283593","1a237e","8c9eff","536dfe","3d5afe","304ffe","e3f2fd","bbdefb","90caf9","64b5f6","42a5f5","2196f3","1e88e5","1976d2","1565c0","0d47a1","82b1ff","448aff","2979ff","2962ff","e1f5fe","b3e5fc","81d4fa","4fc3f7","29b6f6","03a9f4","039be5","0288d1","0277bd","01579b","80d8ff","40c4ff","00b0ff","0091ea","e0f7fa","b2ebf2","80deea","4dd0e1","26c6da","00bcd4","00acc1","0097a7","00838f","006064","84ffff","18ffff","00e5ff","00b8d4","e0f2f1","b2dfdb","80cbc4","4db6ac","26a69a","009688","00897b","00796b","00695c","004d40","a7ffeb","64ffda","1de9b6","00bfa5","e8f5e9","c8e6c9","a5d6a7","81c784","66bb6a","4caf50","43a047","388e3c","2e7d32","1b5e20","b9f6ca","69f0ae","00e676","00c853","f1f8e9","dcedc8","c5e1a5","aed581","9ccc65","8bc34a","7cb342","689f38","558b2f","33691e","ccff90","b2ff59","76ff03","64dd17","f9fbe7","f0f4c3","e6ee9c","dce775","d4e157","cddc39","c0ca33","afb42b","9e9d24","827717","f4ff81","eeff41","c6ff00","aeea00","fffde7","fff9c4","fff59d","fff176","ffee58","ffeb3b","fdd835","fbc02d","f9a825","f57f17","ffff8d","ffff00","ffea00","ffd600","fff8e1","ffecb3","ffe082","ffd54f","ffca28","ffc107","ffb300","ffa000","ff8f00","ff6f00","ffe57f","ffd740","ffc400","ffab00","fff3e0","ffe0b2","ffcc80","ffb74d","ffa726","ff9800","fb8c00","f57c00","ef6c00","e65100","ffd180","ffab40","ff9100","ff6d00","fbe9e7","ffccbc","ffab91","ff8a65","ff7043","ff5722","f4511e","e64a19","d84315","bf360c","ff9e80","ff6e40","ff3d00","dd2c00","efebe9","d7ccc8","bcaaa4","a1887f","8d6e63","795548","6d4c41","5d4037","4e342e","3e2723","fafafa","f5f5f5","eeeeee","e0e0e0","bdbdbd","9e9e9e","757575","616161","424242","212121","eceff1","cfd8dc","b0bec5","90a4ae","78909c","607d8b","546e7a","455a64","37474f","263238"],"simple":["ffffff","d4d4d4","a1a1a1","787878","545454","303030","000000","edc5c5","e68383","ff0000","de2424","ad3636","823737","592b2b","f5d2ee","eb8dd7","f700b9","bf1f97","9c277f","732761","4f2445","e2bcf7","bf79e8","9d00ff","8330ba","6d3096","502c69","351b47","c5c3f0","736feb","0905f7","2e2eb0","2d2d80","252554","090936","c7e2ed","6ac3e6","00bbff","279ac4","347c96","2d5b6b","103947","bbf0d9","6febb3","00ff88","2eb878","349166","2b694c","0c3d25","c2edc0","76ed70","0dff00","36c72c","408c3b","315c2e","144511","d6edbb","b5eb73","8cff00","89c93a","6f8f44","4b632a","2a400c","f1f2bf","eef069","ffff00","baba30","91913f","5e5e2b","3b3b09","ffdeb8","f2ae61","ff8400","c48037","85623d","573e25","3d2309","fcbbae","ff8066","ff2b00","cc553d","9c5b4e","61372e","36130b"],"common":["000000","ffffff","464646","b4b4b4","990030","9c5a3c","ed1c24","ffa3b1","ff7e00","e5aa7a","ffc20e","f5e49c","fff200","fff9bd","a8e61d","d3f9bc","22b14c","00b7ef","99d9ea","4d6df3","709ad1","2f3699","546d8e","6f3198","b5a5d5","2b44a6","506fde","6c8dfa"],"skin tones":["ffe0bd","ffdbac","ffcd94","eac086","e0ac69","f1c27d","ffad60","c68642","8d5524","896347","765339","613D24","4C2D17","391E0B","351606","2D1304","180A01","090300"],"Simple Rainbow":["3B1830","4A2135","5E2F3F","7D3E3E","995B50","BA8270","D4A58C","C2717B","99567D","753D7A","57386B","3D2E57","2E233D","463E4A","5B5661","6F7078","82888C","97A1A3","BAC2BC","F2E9D3","8EC8D1","74A4C2","6485B3","546599","4D4C87","47396E","412D5E","3D204D","612751","7D2B53","913D59","AD4C56","D16C5A","E69065","EBB275","F0D299","A5C966","63B34F","459C57","377D54","276B5D","255457","1E3B45","172936","130A1C","22b14c"],"Middle of nowhere":["FF1744","F51743","EB1741","E1173F","D7173D","CD173F","C3173F","B91740","AF1740","A5173F","9B173F","91173F","87173E","7D173E","73173D","69173D","5F173D","55173D","4B173D","41173D","37173D","2D173D","23173D","19173D","0F173D","05173D"],"This took me an hour":["0B171F","28465A","3D5C74","58788D","7495A8","94B0C0","B1C5D2","CDDDE5","F0F4F7","00292A","004538","006045","007B46","009644","50B04A","94C952","C7E26E","810000","A20000","C2340B","E15C0F","F48925","F7AC38","FACE43","FFEF57","651415","822F22","9B4D2F","B76D3B","D18A4F","E9AA6B","F1C585","F9DAA2","47094D","7A0475","A41588","C4398B","DC5D86","F48D8A","FFB6A5","240553","291A72","2F4091","2C6FAF","28ADCF","4DD1DD","92E5E8","1F0C2C","30093D","51005D","81007A","83007A","B00081","C40380","C81680","D95588","EC849B","55BDED","6298D2","6579B6","5E5A91","584871","533D5A","362836","00cef7"],"New Palette":["3A224F","4E2557","73326A","A34474","C7506B","E3755F","ED9E70","FCC88D","FFD7A3","FFEFC9","F0EBA8","CFF291","A0DE85","69C976","50AB76","36777A","2E5C6B","223D54","1F2E52"],"Journey_Palette_":["050914","110524","3B063A","691749","9C3247","D46453","F5A15D","FFCF8E","FF7A7D","FF417D","D61A88","94007A","42004E","220029","100726","25082C","3D1132","73263D","BD4035","ED7B39","FFB84A","FFF540","C6D831","77B02A","429058","2C645E","153C4A","052137","0E0421","0C0B42","032769","144491","488BD4","78D7FF","B0FFF1","FAFFFF","C7D4E1","928FB8","5B537D","392946","24142C","0E0F2C","132243","1A466B","10908E","28C074","3DFF6E","F8FFB8","F0C297","CF968C","8F5765","52294B","0F022E","35003B","64004C","9B0E3E","D41E3C","ED4C40","FF9757","D4662F","9C341A","691B22","450C28","2D002E","000000"]},"colorSelected":"Journey_Palette_","frames":[{"name":"","speed":100,"layers":[{"id":0,"src":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAAGCAYAAADpJ08yAAAAAXNSR0IArs4c6QAAACBJREFUGFdjvJKm/5+BgYGBEZPx1scBIgVn/J8eDhYBAKkTDxumLFo4AAAAAElFTkSuQmCC","edit":false,"name":"Background","opacity":"0.91","active":true,"unqid":"291m7f","options":{"blend":"source-over","locked":false,"filter":{"brightness":"120%","contrast":"100%","grayscale":"0%","blur":"0px","dropshadow_x":"4px","dropshadow_y":"5px","dropshadow_blur":"9px","dropshadow_alpha":"1"}}},{"id":1,"src":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAAGCAYAAADpJ08yAAAAAXNSR0IArs4c6QAAACBJREFUGFdjnM1n95+BgYGBEZNxRc4GIgVnvPVxAIsAAFdlDIswVUg2AAAAAElFTkSuQmCC","edit":false,"name":"Background Copy","opacity":"0.66","active":true,"unqid":"291m7f","options":{"blend":"source-over","locked":false,"filter":{"brightness":"120%","contrast":"100%","grayscale":"0%","blur":"0px","dropshadow_x":"4px","dropshadow_y":"5px","dropshadow_blur":"9px","dropshadow_alpha":"1"}}}],"active":true,"selectedLayer":1,"unqid":"r6j4yj","preview":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAAGCAYAAADpJ08yAAAAAXNSR0IArs4c6QAAACBJREFUGFdjvGDk8p2BgYGBEZPx18wTIgVn/KsIBYsAAJGZDmYxu8DDAAAAAElFTkSuQmCC","width":2,"height":6}],"currentFrame":0,"speed":100,"name":"Untitled","preview":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAAIA/sfR5H8Fkddasdmnacvx/AAAGCAYAAADpJ08yAAAAAXNSR0IArs4c6QAAADBJREFUGFdjPG/o8oORkeE/4wUjl+///zMwMsJF/pp5QkT+mHpC1PyrCP3+//9/RgBoUhhiWiR2JgAAAABJRU5ErkJggg==","previewApp":"","art_edit_id":0,"palette_id":"41025","created_at":1690406954437,"updated_at":1690406954437,"persLayers":true,"id":1690398131746} \ No newline at end of file diff --git a/images/user_plane_images/user_bullet.png b/images/user_plane_images/user_bullet.png new file mode 100644 index 0000000..a579ec4 Binary files /dev/null and b/images/user_plane_images/user_bullet.png differ diff --git a/images/user_plane_images/user_plane_0.png b/images/user_plane_images/user_plane_0.png new file mode 100644 index 0000000..0f98dfc Binary files /dev/null and b/images/user_plane_images/user_plane_0.png differ diff --git a/images/user_plane_images/user_plane_1.png b/images/user_plane_images/user_plane_1.png new file mode 100644 index 0000000..50dfcf8 Binary files /dev/null and b/images/user_plane_images/user_plane_1.png differ diff --git a/images/user_plane_images/user_plane_2.png b/images/user_plane_images/user_plane_2.png new file mode 100644 index 0000000..9c196ed Binary files /dev/null and b/images/user_plane_images/user_plane_2.png differ diff --git a/images/user_plane_images/user_plane_3.png b/images/user_plane_images/user_plane_3.png new file mode 100644 index 0000000..fb82f7d Binary files /dev/null and b/images/user_plane_images/user_plane_3.png differ diff --git a/images/user_plane_images/user_plane_4.png b/images/user_plane_images/user_plane_4.png new file mode 100644 index 0000000..3cf4d6f Binary files /dev/null and b/images/user_plane_images/user_plane_4.png differ diff --git a/images/user_plane_images/user_plane_5.png b/images/user_plane_images/user_plane_5.png new file mode 100644 index 0000000..05ecd48 Binary files /dev/null and b/images/user_plane_images/user_plane_5.png differ diff --git a/images/user_plane_images/user_plane_6.png b/images/user_plane_images/user_plane_6.png new file mode 100644 index 0000000..e28b59b Binary files /dev/null and b/images/user_plane_images/user_plane_6.png differ diff --git a/images/user_plane_images/user_plane_template.pixil b/images/user_plane_images/user_plane_template.pixil new file mode 100644 index 0000000..3fa2b55 --- /dev/null +++ b/images/user_plane_images/user_plane_template.pixil @@ -0,0 +1 @@ +{"application":"pixil","type":".pixil","version":"2.7.0","website":"pixilart.com","author":"https://www.pixilart.com","contact":"support@pixilart.com","width":64,"height":64,"colors":{"default":["000000","ffffff","f44336","E91E63","9C27B0","673AB7","3F51B5","2196F3","03A9F4","00BCD4","009688","4CAF50","8BC34A","CDDC39","FFEB3B","FFC107","FF9800","FF5722","795548","9E9E9E","607D8B","ffebee","ffcdd2","ef9a9a","e57373","ef5350","e53935","d32f2f","c62828","b71c1c","ff8a80","ff5252","ff1744","d50000","fce4ec","f8bbd0","f48fb1","f06292","ec407a","e91e63","d81b60","c2185b","ad1457","880e4f","ff80ab","ff4081","f50057","c51162","f3e5f5","e1bee7","ce93d8","ba68c8","ab47bc","9c27b0","8e24aa","7b1fa2","6a1b9a","4a148c","ea80fc","e040fb","d500f9","aa00ff","ede7f6","d1c4e9","b39ddb","9575cd","7e57c2","673ab7","5e35b1","512da8","4527a0","311b92","b388ff","7c4dff","651fff","6200ea","e8eaf6","c5cae9","9fa8da","7986cb","5c6bc0","3f51b5","3949ab","303f9f","283593","1a237e","8c9eff","536dfe","3d5afe","304ffe","e3f2fd","bbdefb","90caf9","64b5f6","42a5f5","2196f3","1e88e5","1976d2","1565c0","0d47a1","82b1ff","448aff","2979ff","2962ff","e1f5fe","b3e5fc","81d4fa","4fc3f7","29b6f6","03a9f4","039be5","0288d1","0277bd","01579b","80d8ff","40c4ff","00b0ff","0091ea","e0f7fa","b2ebf2","80deea","4dd0e1","26c6da","00bcd4","00acc1","0097a7","00838f","006064","84ffff","18ffff","00e5ff","00b8d4","e0f2f1","b2dfdb","80cbc4","4db6ac","26a69a","009688","00897b","00796b","00695c","004d40","a7ffeb","64ffda","1de9b6","00bfa5","e8f5e9","c8e6c9","a5d6a7","81c784","66bb6a","4caf50","43a047","388e3c","2e7d32","1b5e20","b9f6ca","69f0ae","00e676","00c853","f1f8e9","dcedc8","c5e1a5","aed581","9ccc65","8bc34a","7cb342","689f38","558b2f","33691e","ccff90","b2ff59","76ff03","64dd17","f9fbe7","f0f4c3","e6ee9c","dce775","d4e157","cddc39","c0ca33","afb42b","9e9d24","827717","f4ff81","eeff41","c6ff00","aeea00","fffde7","fff9c4","fff59d","fff176","ffee58","ffeb3b","fdd835","fbc02d","f9a825","f57f17","ffff8d","ffff00","ffea00","ffd600","fff8e1","ffecb3","ffe082","ffd54f","ffca28","ffc107","ffb300","ffa000","ff8f00","ff6f00","ffe57f","ffd740","ffc400","ffab00","fff3e0","ffe0b2","ffcc80","ffb74d","ffa726","ff9800","fb8c00","f57c00","ef6c00","e65100","ffd180","ffab40","ff9100","ff6d00","fbe9e7","ffccbc","ffab91","ff8a65","ff7043","ff5722","f4511e","e64a19","d84315","bf360c","ff9e80","ff6e40","ff3d00","dd2c00","efebe9","d7ccc8","bcaaa4","a1887f","8d6e63","795548","6d4c41","5d4037","4e342e","3e2723","fafafa","f5f5f5","eeeeee","e0e0e0","bdbdbd","9e9e9e","757575","616161","424242","212121","eceff1","cfd8dc","b0bec5","90a4ae","78909c","607d8b","546e7a","455a64","37474f","263238"],"simple":["ffffff","d4d4d4","a1a1a1","787878","545454","303030","000000","edc5c5","e68383","ff0000","de2424","ad3636","823737","592b2b","f5d2ee","eb8dd7","f700b9","bf1f97","9c277f","732761","4f2445","e2bcf7","bf79e8","9d00ff","8330ba","6d3096","502c69","351b47","c5c3f0","736feb","0905f7","2e2eb0","2d2d80","252554","090936","c7e2ed","6ac3e6","00bbff","279ac4","347c96","2d5b6b","103947","bbf0d9","6febb3","00ff88","2eb878","349166","2b694c","0c3d25","c2edc0","76ed70","0dff00","36c72c","408c3b","315c2e","144511","d6edbb","b5eb73","8cff00","89c93a","6f8f44","4b632a","2a400c","f1f2bf","eef069","ffff00","baba30","91913f","5e5e2b","3b3b09","ffdeb8","f2ae61","ff8400","c48037","85623d","573e25","3d2309","fcbbae","ff8066","ff2b00","cc553d","9c5b4e","61372e","36130b"],"common":["000000","ffffff","464646","b4b4b4","990030","9c5a3c","ed1c24","ffa3b1","ff7e00","e5aa7a","ffc20e","f5e49c","fff200","fff9bd","a8e61d","d3f9bc","22b14c","00b7ef","99d9ea","4d6df3","709ad1","2f3699","546d8e","6f3198","b5a5d5","2b44a6","506fde","6c8dfa"],"skin tones":["ffe0bd","ffdbac","ffcd94","eac086","e0ac69","f1c27d","ffad60","c68642","8d5524","896347","765339","613D24","4C2D17","391E0B","351606","2D1304","180A01","090300"],"Simple Rainbow":["3B1830","4A2135","5E2F3F","7D3E3E","995B50","BA8270","D4A58C","C2717B","99567D","753D7A","57386B","3D2E57","2E233D","463E4A","5B5661","6F7078","82888C","97A1A3","BAC2BC","F2E9D3","8EC8D1","74A4C2","6485B3","546599","4D4C87","47396E","412D5E","3D204D","612751","7D2B53","913D59","AD4C56","D16C5A","E69065","EBB275","F0D299","A5C966","63B34F","459C57","377D54","276B5D","255457","1E3B45","172936","130A1C","22b14c"],"Middle of nowhere":["FF1744","F51743","EB1741","E1173F","D7173D","CD173F","C3173F","B91740","AF1740","A5173F","9B173F","91173F","87173E","7D173E","73173D","69173D","5F173D","55173D","4B173D","41173D","37173D","2D173D","23173D","19173D","0F173D","05173D"],"This took me an hour":["0B171F","28465A","3D5C74","58788D","7495A8","94B0C0","B1C5D2","CDDDE5","F0F4F7","00292A","004538","006045","007B46","009644","50B04A","94C952","C7E26E","810000","A20000","C2340B","E15C0F","F48925","F7AC38","FACE43","FFEF57","651415","822F22","9B4D2F","B76D3B","D18A4F","E9AA6B","F1C585","F9DAA2","47094D","7A0475","A41588","C4398B","DC5D86","F48D8A","FFB6A5","240553","291A72","2F4091","2C6FAF","28ADCF","4DD1DD","92E5E8","1F0C2C","30093D","51005D","81007A","83007A","B00081","C40380","C81680","D95588","EC849B","55BDED","6298D2","6579B6","5E5A91","584871","533D5A","362836","00cef7"]},"colorSelected":"This took me an hour","frames":[{"name":"","speed":100,"layers":[{"id":0,"src":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAAAq1JREFUeF7tWztOAzEQ3dQ5QMp0uQFHoMgNqBASRwBFdIgOITgCUkTFDShyBG5AlzIHSA3yKl55Z/2ZGY+9KzJpIu1612/ePI9nbO+sOfPfTMr+q4e3X6l3Yd7z+Xwngl3kJRjAsM18sewRdjzsR8EySqeWDEvCWMYbHFECDEAIzndtKgrg4K1GAJR8ijSOKpQAhmKTCjCecr3BHbfdc+tV1Pnzr5/2PlUBPlwYrCgCXECulLEgscZ3wZFIgg8TFmeSgM1h37wslp1HzIvhtZBLeyASnh9MkycSMGrwYcLi7BFADVSpQDbV+65yOwJCMr2/uG1ev99RtlDaol7oaUTpw9cWxpiWgJhUczvkGhp6LhePJcAOLSWAooCP7W7gmOuby+4axTtcZcA+YphiQ4CsANORa6w1wL1em4AUJiXAE8DZMcBl+2m7ax5P0p+KAnyYVAGlFOAGsKkowIdJVAGmg7OeBTDTVu1ZIIUJrQA3FziCooViFKVtCnzpTNDWA1oMuUy7Cwh2eSnnv822iGVwqCw2HsvBYp+H5fVgPUC6JJYigDtk4HNwEafosnjrMQEFYFeeOCQVJyBnGHDXBylEFCXAzi5cFRgCSnrf4FMCKHLhtM2JA6oAHQIaAzQI6ixQ+OCEToOcqY3yjE6DGfWA5gGaB2geoHmA5gGaB5Q9QaqJECWp4bTVREgTIf7KsGaCmglqJvg/MkHO5kiNTZEq+wLczZEaAXB0Ajove/YPlYAKM4AqoMbeYOz4TWgI1AqAYgrAHqqAu8QpAlK1h8RagUg1iCl42qAGgl2MgNSWulSQFCPAeisE3Gcs9lrvHBPhU5qUgsSGgO0o9Y1Q76DyetW4BMB7ocNS8JATxshYGxEFDMCC74JzQXbqKrA8VoSAlMGhoCkR1FJ9w/t/tVBXbnhrt+8AAAAASUVORK5CYII=","edit":false,"name":"Background","opacity":"1","active":true,"unqid":"l7ibt","options":{"blend":"source-over","locked":false,"filter":{"brightness":"100%","contrast":"100%","grayscale":"0%","blur":"0px","dropshadow_x":"1px","dropshadow_y":"1px","dropshadow_blur":"0px","dropshadow_alpha":"0.3"}}},{"id":1,"src":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAAAUxJREFUeF7tmtERwiAQRJNWbMAO/bBDG7AVHT+cSRDCEm6jDi+fclwuy+5ywczT4Nc8+PNPAAADBkcACQxOAEwQCSCBwRHISuB6Pj0ut3tRHsvxUuxWTG5O+lvvPdJ1LdUJADkFwAAkgAdgguwCbIP0ATRCpS65t0ujE8z0GT/VCtfejxQG1HJEjEfUwXlAxEr8c45DGLCl7zd4SowDaABwoFo7jGjdBp01wgAnui36xgOS5qh2KhW1cEggCsmtPAq9lRhHrTDAgSrbYIKAQm8lxrFYSMCBKhJAAmsEFH0rMQ624gEOVPEAPAAPWCGgGJwS45ArJuhAFRPEBDFBTHCJgOLwSozDrw7ZBWqm+Bo/6hA0rQUAHLSq5VT+GarliBqHAVFItuSBAcInMi2A9sQigR709s5FAkjg82v0oRqhvdJxzPuKCToeZG/OJyCZQH2Cwb4ZAAAAAElFTkSuQmCC","edit":false,"name":"Layer 2","opacity":"0.12","active":true,"unqid":"h87d99","options":{"blend":"source-over","locked":false,"filter":{"brightness":"100%","contrast":"100%","grayscale":"0%","blur":0,"dropshadow_x":0,"dropshadow_y":0,"dropshadow_blur":0,"dropshadow_alpha":1}}},{"id":2,"src":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAAAVJJREFUeF7tmjEOgkAQRaH2AFbG1s4DWOshrDyalYfQi9haegBrzBLX4ILZLP4J/synBWaHN+8vBdSV86N2/vyVAMgA5wQUAecCaBNUBBQB5wQUAecC6C2gCCgCzgkoAs4F0FtAEVAEnBNQBKwEmM2XDbL2434zGZZJ0fjgDBBMAZQYkINFaUAJgJw1bgB0oXWtcAkgwIgQ3AIYE6OSe/5mEyxpGnmtACBpMtaSAYxTQ/YsA5A0GWvJAMapIXuWAUiajLVkAOPUkD3LACRNxloygHFqyJ5lAJImYy0ZwDg1ZM8yAEmTsZYMYJwasufpDDhsm+p4adcPn7+sPn3lYAlAjpDZ+cSAsM4UFsANWO32g7/GXM+nz7UyAEIsFutNj3+vzo8TggOI/aQgxgAItVIINABaEGHK3eO16b3PfdkE099lLKNhZkCJmT7fAiWEDK99AqQKXUEVaMuOAAAAAElFTkSuQmCC","edit":false,"name":"Layer 1","opacity":"0.71","active":true,"unqid":"y76rk","options":{"blend":"source-over","locked":false,"filter":{"brightness":"100%","contrast":"100%","grayscale":"0%","blur":0,"dropshadow_x":0,"dropshadow_y":0,"dropshadow_blur":0,"dropshadow_alpha":1}}}],"active":true,"selectedLayer":0,"unqid":"exroqh","preview":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAAA/tJREFUeF7tW0FrU0EQ3pi0FIJUipKDhUAPOXjwZL0XUSjSnqUHEb17UcSb6ElEL94V8RA868GDSM7a/gIPQiAK0VotkiBt0shs3zznTfa9N/veJpZkvZjum52d+XZmdnZ2t6Cm/F/Blf5X7j4ZuOIl4fPq4S0nsjthQgRekwgPNOVK9TWl7bSb69K+hO5Nhj6RLq4BsJKnXKlqqyHK51bISgClVCIAIGCn3YzQmNpsBw0sIOIyfJysPG3llQAAphnOTABApE0iLM62hDawCmvrNMmWJu9RBiATyIE7iScsFQA+G8RvrWYo7LdaSzSC8ttP+jtXJM1yWDzRAJjaOB8RABQEaspSv5Uqj8IREEQgM5m05ZjaTCCmAnCn3VSPKtVwRoAxb4ubnYgQKTPPeSAIknhgkkkq51CETzO1SfhOLTcEgJrpib2e+jVb0rreXr6hHm8+i+hNv8fRxtEAI/oNGfO2vGNw2ZEfdy8NADfVaQAAXWvaAVi3AuDli3faYnuzJVXa6+nfNzdWjO4yLhd4Wm8MyXT12sUh9+UugEutGABQHhlT5Z7XG+r6xkrsgCafdxUD6NiUJ8pK45cHIAjsbHmVuwC1gPv1hroXzPpRsQAqk7eAwF29C5AcJncMgGA21asATQXzZmmuVoGkpTYtE4wsg5Gt42otkqpOcCqsa5CZNkPzRaV2+4c2QX+Pe6OUVQ5agzQCAARQtc37PwDSP1XOhUvxe0f3zysL9kdeWOYbqgfY1u7StHMFQNo40u+8Ah1XEBHX95MG1lbEYoopNYa24x9bav/YP3FmDgb6b7CAQb+/1d1uPZAqKaALa4aikpOAoZEErWnmwlK4YYoDACP63NYXzQsAOPjR1b8DAJazypHUb6QA4OpiAwAKC4Dsv/+slYe27nZregEoFIvfOu3m5am0ANvyuC1IR94FPACHp8YjOzT1FmDrM7b0sBTmWQW8C3gX8DHAB0G/Cvhl0OcBPhGyzT+k9D4TlCKVlc5ngj4V9nsBvxnyu0GLqjAvivrtsN8OT8B2WJ/HkauykuPxrJembfOVkWeCeDiSBYBxvCT5rwCEs2w4P4Rvow6AMDkeAFufyUKvn60YYgBaAByhz52tRA5QJ84CaCDkN7Y4AOMKgM5cQHqpAq3ABAAch/8+v6gNjN7mTLI46YuVkR+PUxNf3Jk3jvfzw2a4FEoAAKs4uXRmiFdrYTcEyUWQdBIETU9jOBAAALpBEgA0LgA9BwH5aF4OskQnAATTtEafw9Kgh9OIysHtrq+XaqGpw2wv7HTCm2f8XtGfc6cjbsGe2eaqF7oEAPWMAJFl1Yjr41JxHGMUAIRAxCnCH04jnfABda4Z5zL9BZxQXZ0xdvaAAAAAAElFTkSuQmCC","width":64,"height":64}],"currentFrame":0,"speed":100,"name":"Untitled","preview":"data:image/pngp98kjasdnasd983/24kasdjasdbase64,iVBORw0KGgoAAAANSUhEUgAAAEAA/sfR5H8Fkddasdmnacvx/AABACAYAAACqaXHeAAAAAXNSR0IArs4c6QAABJZJREFUeF7tWz1oFEEUfmt+CBwSCcoVCRykSEDQSq0NopAmtUQQ0cY0NorYiZ2INjbaKGIRrG0sRFJrUtokhXB4EY78aJA7QnKXkze3M7yd292Z2Zldztyk2cvtzcyb733vvZk3bwIAmAGAjUF9BtD9swbh+qMX62FfhTw+PL2PslvL7aQTwqBZAJgEgE3Vs1SufKRINerVJZ12Ur+vbUFwxoAsZlQqVzoIApk8sqhQc0xlQKlcWW/Uq6hVIRQK3ahXrZnDJ89ZII+TRbNZ5E1lQDjZBQAQmgkHQboa0Q/bmTiHLCBnkVeHAZHJxg2iQ1tZ4yowQrMwBllup5JXyYDQRoUZcE2aaki0m0fHnfxX+oTWxvxChHkqkIlcop3kY2LBVDJAtlGqSV0QdCfPxyIgaPkaal6cAZKciWAqGfCwXoVn5YrQCA5Gvkv1BREhFJqXOcFBkBkYxwQcJ6ucEYRNHZXKjvv1PWWuYACl6amDFvwZHWbyP7h4B56vvonMhb5P+m3Sb7Aj+o53LH9nO4YsO+9PNi/GgIgNzc9EBDyuAISmFTAGyLY6CAzgK1AjBrx/95kxtjU6DMMHLfb53uJcrLkUZQIvl1d6ZLp562qP+comwEOtNgNw8rxjOrm3yytwe3EuccA4m3flA+jYtE8uKzXfBACWtBlwTAFYyMSAJ8sr8DjUer8wgMrkGRCaq4YJZGPAQPoAdGYDHQXoUtB2leYqCqSFWtVKMLIOwA2G2DoOyEqQp+Eiu0HdpMX4EMBeu8sJ+rnozU9WOWgOMnY3iMkIzNraPhGQ9pmSFS5DWw3WHoUulSuvbJ98BcjTfD35ANdbYlcAWKFIGoeZJkzdswxRUsZFO7+flv9nGpN8StJ2+OS3Ghye4PoAGDnqsP+RAZ12e625XcM9ufK8QXUeEb4X6bFczwW4Txm5Mi02TKp8wNgazrELwNFOk33utFrfmzub57KkylW5RK2cm6qTtPcIggkAnK0Y4g6//GCThyDYb27XbtjIkQRergzgyRYrANrttSAIGo2tn5cHkgFZzgdMmNL3DDA9HzCZfFoUcHZAaesDPAMMT4g8AwyLJrwPyCO0yPUENmHQ+wDvA1jtkFGdgIkj9D7A+4Du7sO63i6JdphfsHSCRpUiJvT3K0GADe8D8qQ/zzZbmoCPArRO0dTGVb/v+4yQXwn6laBfCfp1gN8LkGp1lVc3fV9IFGDncaRUVud4nBQ0/t/rAL4YygJAETdJcmcAPxyJA0BoOeb8EN/lnRJH5eS+F0hjgAYAudK/kN2gDgPwCH3sfDlygHrsGEAdoVy1KQNQlAN0xgDdogruB+IAwOPwv5emWHaGXpZIK4zQvbGSFhqd+AB2MSkMc1O747Ey//66KkKhDgDIitPTZ3v6qk3sCZBcbJScRAH5vgFKKAOBAHAzSAOAa5+X1sgg8H7kWp+seQ0nDAgHn6XXYWnY42rkk8Pqrl/XZgTVcbITuw1ReSbXFe1fmIyYhXTN1ipl7oQBko3dxdogV0VNtB9S4IR1NE6u2bpkgHyknlhoJV+c5pPUvEBtpXHZIf4D+wx/YkUT9TIAAAAASUVORK5CYII=","previewApp":"","art_edit_id":0,"palette_id":"44747","created_at":1690398190860,"updated_at":1690398190860,"persLayers":true,"id":1690398131746} \ No newline at end of file diff --git a/libcrypto1.0.0-udeb_1.0.1f-1ubuntu2.27_amd64.udeb b/libcrypto1.0.0-udeb_1.0.1f-1ubuntu2.27_amd64.udeb new file mode 100644 index 0000000..2fe4906 Binary files /dev/null and b/libcrypto1.0.0-udeb_1.0.1f-1ubuntu2.27_amd64.udeb differ diff --git a/libfdk-aac1_0.1.6-1_amd64.deb b/libfdk-aac1_0.1.6-1_amd64.deb new file mode 100644 index 0000000..9fc4523 Binary files /dev/null and b/libfdk-aac1_0.1.6-1_amd64.deb differ diff --git a/main.py b/main.py new file mode 100755 index 0000000..9ddad94 --- /dev/null +++ b/main.py @@ -0,0 +1,9 @@ +#!/usr/bin/python3 + +import sys, os +from gui import main_menu + + + + +main_menu.init_app() \ No newline at end of file diff --git a/requirements b/requirements new file mode 100644 index 0000000..6fb9265 --- /dev/null +++ b/requirements @@ -0,0 +1,3 @@ +PyQt5==5.15.9 +pyqt5-tools==5.15.9.3.3 +pygame==2.5.0 \ No newline at end of file diff --git a/settings/__init__.py b/settings/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/settings/__pycache__/__init__.cpython-310.pyc b/settings/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000..2e44082 Binary files /dev/null and b/settings/__pycache__/__init__.cpython-310.pyc differ diff --git a/settings/__pycache__/__init__.cpython-311.pyc b/settings/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000..9ec0c8d Binary files /dev/null and b/settings/__pycache__/__init__.cpython-311.pyc differ diff --git a/settings/__pycache__/settings_handler.cpython-310.pyc b/settings/__pycache__/settings_handler.cpython-310.pyc new file mode 100644 index 0000000..0f31e0c Binary files /dev/null and b/settings/__pycache__/settings_handler.cpython-310.pyc differ diff --git a/settings/__pycache__/settings_handler.cpython-311.pyc b/settings/__pycache__/settings_handler.cpython-311.pyc new file mode 100644 index 0000000..9bc3295 Binary files /dev/null and b/settings/__pycache__/settings_handler.cpython-311.pyc differ diff --git a/settings/enemy_planes.json b/settings/enemy_planes.json new file mode 100644 index 0000000..bff348b --- /dev/null +++ b/settings/enemy_planes.json @@ -0,0 +1,20 @@ +{ + "enemy_plane_1": { + "plane_name": "Enemy Plane 1", + "health": "100", + "armor": "100", + "damage": "10" + }, + "enemy_plane_2": { + "plane_name": "Enemy Plane 2", + "health": "100", + "armor": "120", + "damage": "20" + }, + "enemy_plane_3": { + "plane_name": "Enemy Plane 3", + "health": "100", + "armor": "150", + "damage": "30" + } +} \ No newline at end of file diff --git a/settings/game_settings.json b/settings/game_settings.json new file mode 100644 index 0000000..6070e20 --- /dev/null +++ b/settings/game_settings.json @@ -0,0 +1,5 @@ +{ + "fps": "75", + "music": "0", + "effects": "43" +} \ No newline at end of file diff --git a/settings/planes_settings.json b/settings/planes_settings.json new file mode 100644 index 0000000..93306dc --- /dev/null +++ b/settings/planes_settings.json @@ -0,0 +1,44 @@ +{ + "user_plane_1": { + "plane_name": "Plane 1", + "health": "100", + "armor": "100", + "damage": "50", + "gold": "0" + }, + "user_plane_2": { + "plane_name": "Plane 2", + "health": "100", + "armor": "120", + "damage": "60", + "gold": "100" + }, + "user_plane_3": { + "plane_name": "Plane 3", + "health": "100", + "armor": "150", + "damage": "80", + "gold": "150" + }, + "user_plane_4": { + "plane_name": "Plane 4", + "health": "100", + "armor": "170", + "damage": "100", + "gold": "200" + }, + "user_plane_5": { + "plane_name": "Plane 5", + "health": "100", + "armor": "190", + "damage": "120", + "gold": "250" + }, + "user_plane_6": { + "plane_name": "Plane 6", + "health": "100", + "armor": "210", + "damage": "140", + "gold": "300" + } +} \ No newline at end of file diff --git a/settings/settings_handler.py b/settings/settings_handler.py new file mode 100755 index 0000000..87f0910 --- /dev/null +++ b/settings/settings_handler.py @@ -0,0 +1,91 @@ +#!/usr/bin/python3 + +import json +import os + + +def get_relative_path_to_settings(): + target_directory = os.path.join(os.path.dirname(__file__), '..', 'settings') + current_directory = os.getcwd() + relative_path = os.path.relpath(target_directory, start=current_directory) + + return relative_path + + +def read_file(path: str): + with open(path, "r") as file: + return json.load(file) + + +def save_file(path_to_file, new_data: dict): + with open(path_to_file, "w") as file: + json.dump(new_data, file, indent=4) + + +def get_game_settings(): + """ + :return: dictionary with the game settings information + """ + + path_to_file = f"{get_relative_path_to_settings()}/game_settings.json" + return read_file(path_to_file) + + +def get_planes_settings(): + """ + :return: dictionary with the planes settings information + """ + + path_to_file = f"{get_relative_path_to_settings()}/planes_settings.json" + return read_file(path_to_file) + + +def get_user_settings(): + """ + :return: dictionary with the user settings information + """ + + path_to_file = f"{get_relative_path_to_settings()}/user_settings.json" + return read_file(path_to_file) + + +def overwrite_game_settings(**new_settings): + """ + :param new_settings: key-value pairs containing new game settings + if bad key is passed, KeyError will be raised + + """ + new_settings = {k.lower(): v for k, v in new_settings.items()} + + data = get_game_settings() + + for key in new_settings: + if not data.get(key): + raise KeyError(f"{key} is not a correct key.For more information, open settings/game_settings.json") + + data[key] = new_settings[key] + + save_file(f"{get_relative_path_to_settings()}/game_settings.json", + data + ) + + +def overwrite_user_settings(**new_settings): + """ + :param new_settings: key-value pairs containing new game settings + if bad key is passed, KeyError will be raised + + """ + new_settings = {k.lower(): v for k, v in new_settings.items()} + + data = get_user_settings() + + for key in new_settings: + if not data.get(key): + raise KeyError(f"{key} is not a correct key.For more information, open settings/user_settings.json") + + data[key] = new_settings[key] + + save_file(f"{get_relative_path_to_settings()}/user_settings.json", + data + ) diff --git a/settings/user_settings.json b/settings/user_settings.json new file mode 100644 index 0000000..c693d5e --- /dev/null +++ b/settings/user_settings.json @@ -0,0 +1,8 @@ +{ + "username": "pesho", + "gold": "0", + "rank": "airman", + "levels_completed": "0", + "enemies_killed": "0", + "buildings_destroyed": "0" +} \ No newline at end of file diff --git a/sounds/__pycache__/sounds.cpython-310.pyc b/sounds/__pycache__/sounds.cpython-310.pyc new file mode 100644 index 0000000..f0c840b Binary files /dev/null and b/sounds/__pycache__/sounds.cpython-310.pyc differ diff --git a/sounds/music/main_menu_music.wav b/sounds/music/main_menu_music.wav new file mode 100644 index 0000000..370aadc Binary files /dev/null and b/sounds/music/main_menu_music.wav differ diff --git a/sounds/music/main_menu_music2.flac b/sounds/music/main_menu_music2.flac new file mode 100644 index 0000000..076de57 Binary files /dev/null and b/sounds/music/main_menu_music2.flac differ diff --git a/sounds/music/main_menu_music_cut.wav b/sounds/music/main_menu_music_cut.wav new file mode 100644 index 0000000..67f67e2 Binary files /dev/null and b/sounds/music/main_menu_music_cut.wav differ diff --git a/sounds/sounds.py b/sounds/sounds.py new file mode 100644 index 0000000..b748a95 --- /dev/null +++ b/sounds/sounds.py @@ -0,0 +1,39 @@ +#!/usr/bin/python3 + +from PyQt5.QtGui import * +from PyQt5.QtCore import * +from PyQt5.QtMultimedia import QMediaPlayer, QMediaContent, QMediaPlaylist +import sys, os +from pathlib import Path + +sys.path.append(r'..') +from settings import settings_handler + +# song = r'sounds/music/main_menu_music.flac' + + +"""PLAY THE BACKGROUND MUSIC""" +def main_menu_music(music, app): + global us + us = settings_handler.get_game_settings() + + global player + player = QMediaPlayer() + + music = os.path.join(os.getcwd(), music) + bg_playlist = QMediaPlaylist() + url = QUrl.fromLocalFile(music) + bg_playlist.addMedia(QMediaContent(url)) + player.setPlaylist(bg_playlist) + bg_playlist.setPlaybackMode(QMediaPlaylist.Loop) + + + player.setVolume(int(us.get("music"))) + player.play() + app.exec() + +def change_volume(): + us = settings_handler.get_game_settings() + player.setVolume(int(us.get("music"))) + +# main_menu_music()