Created
September 10, 2020 20:26
-
-
Save McOwners/dad61ed3b8a5a83cd72f4acc5932db42 to your computer and use it in GitHub Desktop.
Shooter_Arcade.py
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import ui | |
| import console | |
| import time | |
| from time import * | |
| from objc_util import * | |
| import random | |
| from datetime import timedelta | |
| import sound | |
| from scene import Touch | |
| from scene import * | |
| from GameMenu import MenuScene ## SAVED A MODIFIED VERSION LOCALLY | |
| from math import sin, cos, pi, ceil, floor | |
| #from GameMenu import MenuScene | |
| from colorsys import hsv_to_rgb | |
| import sys | |
| import json | |
| import os.path | |
| from os import path | |
| A = Action | |
| def _cmp(a, b): | |
| return ((a>b)-(a<b)) | |
| if sys.version_info[0] >= 3: | |
| cmp = _cmp | |
| sound.set_volume(0.1) | |
| laserUpgradeNames = ['Fire Rate', 'Power', 'Number of lasers'] | |
| rocketUpgradeNames = ['Fire Rate', 'Power', 'Number of rockets', 'Splash Radius'] | |
| laserUpgradeCost = ['100', '100', '1000'] | |
| rocketUpgradeCost = ['100', '100', '1000', '250'] | |
| upgradeTitle = "" | |
| upgradeCostMultiplier = 1.5 | |
| laserFireRateUpgradeCost = 100 | |
| laserPowerUpgradeCost = 100 | |
| laserNumberOfLasersUpgradeCost = 1000 | |
| leaderboardFile = 'ShooterArcade.txt' | |
| #playerDataFile = 'ShooterArcadePlayerData.txt' | |
| #m = SpriteNode('shp:BlackSmoke00', scale = 0.75, parent=self) | |
| #m = SpriteNode('shp:BlackSmoke00', scale = 0.50, parent=self) | |
| #meteor.texture = Texture('spc:StarSilver', scale = 0.10) | |
| #m = SpriteNode('spc:MeteorBrownMed1', parent=self) | |
| explosionTexture = Texture('shp:Explosion00') | |
| #m = SpriteNode('shp:BlackSmoke00', scale = 0.75, parent=self) | |
| smokeTextureMed = Texture('shp:BlackSmoke00', scale = 0.75) | |
| smokeTextureSmall = Texture('shp:BlackSmoke00', scale = 0.50) | |
| starTextureSilver = Texture('spc:StarSilver', scale = 0.10) | |
| brownMeteorMed = Texture('spc:MeteorBrownMed1') | |
| laserTexture = Texture('spc:LaserBlue12') | |
| sound.load_effect('arcade:Hit_1') | |
| playerName = "" | |
| maxSpeedLevel = "" | |
| numberOfProjectileLevel = "" | |
| listOfProjectiles = "" | |
| activeWeapon = "" | |
| laserFireRateLevel = "" | |
| defaultWeaponTimer = "" | |
| laserFireRateUpgradeCost = "" | |
| laserNumberOfLasersLevel = "" | |
| laserNumberOfLasersUpgradeCost = "" | |
| stageNumber = "" | |
| gameScore = "" | |
| listOfXOffsets = "" | |
| weaponTimer = 5 | |
| speed = "" | |
| listOfProjectilesX = "" | |
| score = "" | |
| profileLoaded = False | |
| x = "" | |
| """ | |
| class Coin (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = 'plf:Item_CoinGold' | |
| SpriteNode.__init__(self, img, scale = 0.01, **kwargs) | |
| class Coin100 (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = '100.png' | |
| SpriteNode.__init__(self, img, scale = 0.01, **kwargs) | |
| class Coin1K (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = '1K.png' | |
| SpriteNode.__init__(self, img, scale = 0.02, **kwargs) | |
| class Coin10K (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = '10K.png' | |
| SpriteNode.__init__(self, img, scale = 0.03, **kwargs) | |
| class Coin100K (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = '100K.png' | |
| SpriteNode.__init__(self, img, scale = 0.04, **kwargs) | |
| class Coin1B (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = '1B.png' | |
| SpriteNode.__init__(self, img, scale = 0.05, **kwargs) | |
| """ | |
| class Rocket (SpriteNode): | |
| def __init__(self, **kwargs): | |
| if path.exists('rocket_.png'): | |
| img = 'rocket.png' | |
| SpriteNode.__init__(self, img, scale = 0.05, **kwargs) | |
| else: | |
| img = 'spc:PlayerLife3Blue' | |
| SpriteNode.__init__(self, img, scale = 0.15, **kwargs) | |
| class MiniRocket (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = 'plf:LaserPurpleDot' | |
| SpriteNode.__init__(self, img, scale = 0.05, **kwargs) | |
| class Laser (SpriteNode): | |
| def __init__(self, **kwargs): | |
| if path.exists('laser.jpg'): | |
| img = 'laser.jpg' | |
| collisionsLeft = 1 | |
| SpriteNode.__init__(self, img, scale = 0.05, **kwargs) | |
| else: | |
| img = 'spc:LaserBlue8' | |
| collisionsLeft = 1 | |
| SpriteNode.__init__(self, img, scale = 0.15, **kwargs) | |
| """ | |
| class LaserSlice (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = 'laserSlice.png' | |
| SpriteNode.__init__(self, img, scale = 0.05, **kwargs) | |
| """ | |
| """ | |
| class LaserBeam (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = 'laserBeam1.png' | |
| SpriteNode.__init__(self, img, scale = 0.05, **kwargs) | |
| """ | |
| class Meteor (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = 'spc:MeteorBrownBig1' | |
| SpriteNode.__init__(self, img, scale = 0.50, **kwargs) | |
| self.destroyed = False | |
| class Meteor2 (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = 'spc:MeteorGrayBig1' | |
| SpriteNode.__init__(self, img, scale = 0.60, **kwargs) | |
| self.destroyed = False | |
| class Meteor3 (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = 'spc:MeteorGrayBig2' | |
| SpriteNode.__init__(self, img, scale = 0.70, **kwargs) | |
| self.destroyed = False | |
| self.livesRemaining = 100 | |
| #self.color = 'red' | |
| class Meteor4 (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = 'spc:MeteorGrayBig3' | |
| SpriteNode.__init__(self, img, scale = 0.80, **kwargs) | |
| self.destroyed = False | |
| self.livesRemaining = 500 | |
| self.color = 'blue' | |
| class Meteor5 (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = 'spc:MeteorGrayBig3' | |
| SpriteNode.__init__(self, img, scale = 0.90, **kwargs) | |
| self.destroyed = False | |
| self.livesRemaining = 2500 | |
| self.color = 'green' | |
| class Meteor6 (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = 'spc:MeteorGrayBig3' | |
| SpriteNode.__init__(self, img, scale = 1.0, **kwargs) | |
| self.destroyed = False | |
| self.livesRemaining = 5000 | |
| self.color = 'white' | |
| class MeteorMedium (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = random.choice(['spc:MeteorGrayMed1', 'spc:MeteorGrayMed2']) | |
| SpriteNode.__init__(self, img, scale = 0.75, **kwargs) | |
| self.destroyed = False | |
| class MeteorSmall (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = random.choice(['spc:MeteorGraySmall1', 'spc:MeteorGraySmall2']) | |
| SpriteNode.__init__(self, img, scale = 0.75, **kwargs) | |
| self.destroyed = False | |
| class MeteorTiny (SpriteNode): | |
| def __init__(self, **kwargs): | |
| img = random.choice(['spc:MeteorGrayTiny1', 'spc:MeteorGrayTiny2']) | |
| SpriteNode.__init__(self, img, scale = 0.75, **kwargs) | |
| self.destroyed = False | |
| class Upgrade (SpriteNode): | |
| def __init__(self, **kwargs): | |
| if path.exists('IMG_5667_.png'): | |
| img = 'IMG_5667.png' | |
| SpriteNode.__init__(self, img, scale = 0.05, **kwargs) | |
| else: | |
| img = 'spc:PowerupYellowStar' | |
| SpriteNode.__init__(self, img, scale = 0.50, **kwargs) | |
| class MyScene (Scene): | |
| def run_async(func): | |
| from threading import Thread | |
| from functools import wraps | |
| @wraps(func) | |
| def async_func(*args, **kwargs): | |
| func_hl = Thread(target = func, args = args, kwargs = kwargs) | |
| func_hl.start() | |
| return func_hl | |
| return async_func | |
| # -------------------- | |
| #@run_async | |
| def setup(self): | |
| if path.exists('deepSpace4.png'): | |
| self.background = SpriteNode('deepSpace4.png', size = self.size, position = self.size / 2) | |
| self.add_child(self.background) | |
| else: | |
| self.background_color = "black" | |
| #self.background2 = SpriteNode('hqDeepSpace_1.png') | |
| #self.background_color = "black" | |
| self.shows_fps = True | |
| self.game_over = False | |
| self.updateCounter = 0 | |
| self.colorCounter = 3 | |
| self.laserUpgrades = 0 | |
| self.rocketUpgrades = 0 | |
| self.ropeLaserUpgrades = 0 | |
| self.stageTimer = 1800 | |
| self.stageNumber = 1 | |
| self.playerName = "" | |
| self.score = 0 | |
| self.explosions = [] | |
| self.rocketFireRateUpgradeCost = 10000 | |
| self.rocketPowerUpgradeCost = 100 | |
| self.rocketFragmentPenetrationUpgradeCost = 10000 | |
| self.rocketFragmentsUpgradeCost = 20000 | |
| self.rocketFireRateLevel = 1 | |
| self.rocketPowerLevel = 1 | |
| self.rocketFragmentPenetrationLevel = 1 | |
| self.rocketFragmentsLevel = 1 | |
| #self.background_color = ('#000000') | |
| #'spc:BackgroundPurple', position = (self.size.h, self.size.h)) | |
| #self.add_child(background) | |
| #self.background_color = 'spc:BackgroundPurple' | |
| self.pause_button = SpriteNode('iow:ios7_pause_outline_32', position=(32, self.size.h-32), parent=self) | |
| self.pause_button.alpha = 0.0 | |
| #self.ship = SpriteNode('spc:PlayerShip1Red') | |
| #self.ship.scale = 0.50 | |
| #self.ship.position = self.size / 2 | |
| #self.add_child(self.ship) | |
| #self.ship.position = (self.size.w/2, 32) | |
| score_font = ('Futura', 30) | |
| timeFont = ('Futura', 20) | |
| self.score_label = LabelNode('0', score_font, parent=self) | |
| self.score_label.position = (self.size.w/2, self.size.h - 70) | |
| self.score_label.z_position = 1 | |
| self.gameScore = 0 | |
| self.stageLabel = LabelNode((f'Stage: {self.stageNumber}'), score_font, parent=self) | |
| self.stageLabel.position = (self.size.w/2, self.size.h - 120) | |
| self.stageLabel.z_position = 1 | |
| self.stageLabel.alpha = 0.5 | |
| self.clockLabel = LabelNode("", timeFont, parent=self) | |
| self.clockLabel.position = (50, self.size.h - 50) | |
| self.clockLabel.z_position = 1 | |
| self.stageLabel.alpha = 0.5 | |
| self.items = [] | |
| self.projectiles = [] | |
| self.defaultWeaponTimer = 0 | |
| projectileCounter = 1 | |
| self.weaponTimer = 5 | |
| self.numberOfLasers = 1 | |
| self.maxSpeedLevel = 0 | |
| self.listOfProjectiles = ['fire1'] | |
| self.laserNumberOfLasersLevel = 1 | |
| self.listOfProjectilesX = [0] | |
| self.listOfXOffsets = [ | |
| -5, 5, -10, 10, -15, 15, -20, 20, -25, 25, | |
| -30, 30, -35, 35, -40, 40, -45, 45, -50, 50, | |
| -55, 55, -60, 60, -65, 65, -70, 70, -75, 75, | |
| -80, 80, -85, 85, -90, 95, -100, 100, -105, 105, | |
| -110, 110, -115, 115, -120, 120, -125, 125, -130, 130, | |
| -135, 135, -140, 145, -150, 150] | |
| self.listOfColors = ['#F00', '#F0F', '#00F', '#FF0', '#0FF'] | |
| self.listOfStarColors = ['#ffe68a', '#ff0707', '#f5ff0e', '#32ff07', '#071cff', '#7cffcc', '#53ffe9', '#8629ff', '#baff1c'] | |
| self.defaultTimer = 0 | |
| self.touchCounter = 0 | |
| self.starCounter = 0 | |
| self.numberOfStars = 0 | |
| self.listOfStars = [] | |
| self.starToRemove = None | |
| self.leaderboardEntries = "" | |
| self.leaderboardEntry = "" | |
| #self.createLeaderboard() | |
| #self.new_game() | |
| self.showStartMenu() | |
| #self.loadProfile() | |
| def new_game(self): | |
| if self.laserFireRateLevel > 59: | |
| self.ship = SpriteNode('spc:PlayerShip3Red') | |
| elif self.laserFireRateLevel > 29: | |
| self.ship = SpriteNode('spc:PlayerShip2Red') | |
| else: | |
| self.ship = SpriteNode('spc:PlayerShip1Red') | |
| self.ship.scale = 0.50 | |
| self.ship.position = self.size / 2 | |
| self.add_child(self.ship) | |
| self.ship.position = (self.size.w/2, 32) | |
| self.stageTimer = 600 | |
| self.stageLabel.text = f'Stage: {self.stageNumber}' | |
| self.score_label.text = self.siConvert(self.score) | |
| #print(f'self.ship.bbox: {self.ship.bbox}') | |
| ########## ROCKET FRAGMENT OBJECTS LIST ########## | |
| self.listOfInactiveFragments = [] | |
| self.listOfActiveFragments = [] ## I ENDED UP USING self.projectiles INSTEAD OF THIS | |
| for x in range(3000): | |
| x = MiniRocket(parent=self) | |
| self.listOfInactiveFragments.append(x) | |
| #print(f'self.listOfInactiveFragments: {self.listOfInactiveFragments}') | |
| ############## METEOR OBJECTS LISTS ############## | |
| # | |
| self.listOfInactiveMeteor2 = [] # | |
| self.listOfActiveMeteor2 = [] # | |
| for m in range(25): # | |
| m = Meteor2() # | |
| self.listOfInactiveMeteor2.append(m) # | |
| self.add_child(m) # | |
| self.listOfInactiveMeteorMedium = [] # | |
| self.listOfActiveMeteorMedium = [] # | |
| for m in range(75): # | |
| m = MeteorMedium() # | |
| self.listOfInactiveMeteorMedium.append(m) # | |
| self.add_child(m) # | |
| self.listOfInactiveMeteorSmall = [] # | |
| self.listOfActiveMeteorSmall = [] # | |
| for m in range(225): # | |
| m = MeteorSmall() # | |
| self.listOfInactiveMeteorSmall.append(m) # | |
| self.add_child(m) # | |
| self.listOfInactiveMeteorTiny = [] # | |
| self.listOfActiveMeteorTiny = [] # | |
| for m in range(675): # | |
| m = MeteorTiny() # | |
| self.listOfInactiveMeteorTiny.append(m) # | |
| self.add_child(m) # | |
| ################################################## | |
| for item in self.items: | |
| item.remove_from_parent() | |
| for projectile in self.projectiles: | |
| projectile.remove_from_parent() | |
| self.items = [] | |
| self.projectiles = [] | |
| self.showPlayMenu() | |
| if profileLoaded == True: | |
| self.upgradeCostMultiplier = 2.0 | |
| else: | |
| self.maxSpeedLevel = 0 | |
| self.numberOfProjectileLevel = 1 | |
| self.listOfProjectiles = ['fire1'] | |
| self.activeWeapon = "laser" | |
| self.defaultWeaponTimer = 0 | |
| self.laserFireRateLevel = 1 | |
| self.laserFireRateUpgradeCost = 1000 | |
| self.laserPowerLevel = 1 | |
| self.laserPowerUpgradeCost = 5000 | |
| self.laserNumberOfLasersLevel = 1 | |
| self.laserNumberOfLasersUpgradeCost = 100000 | |
| self.rocketFireRateLevel = 1 | |
| self.rocketFireRateUpgradeCost = 5000 | |
| self.rocketFragmentPenetrationLevel = 1 | |
| self.rocketFragmentPenetrationUpgradeCost = 10000 | |
| self.rocketFragmentsLevel = 1 | |
| self.rocketFragmentsUpgradeCost = 200000 | |
| self.stageNumber = 1 | |
| self.gameScore = 0 | |
| self.listOfXOffsets = [ | |
| -5, 5, -10, 10, -15, 15, -20, 20, -25, 25, | |
| -30, 30, -35, 35, -40, 40, -45, 45, -50, 50, | |
| -55, 55, -60, 60, -65, 65, -70, 70, -75, 75, | |
| -80, 80, -85, 85, -90, 90, -95, 95, -100, 100, | |
| -105, 105, -110, 110, -115, 115, -120, 120, -125, 125, | |
| -130, 130, -135, 135, -140, 140, -145, 145, -150, 150] | |
| self.weaponTimer = 5 | |
| self.speed = 1.0 | |
| self.listOfProjectilesX = [0] | |
| self.stageLabel.text = f'Stage: {self.stageNumber}' | |
| self.score = 0 | |
| self.score_label.text = self.siConvert(self.score) | |
| self.upgradeCostMultiplier = 2.0 | |
| for item in self.items: | |
| item.remove_from_parent() | |
| self.items = [] | |
| self.projectiles = [] | |
| self.numberOfLasers = 1 | |
| self.localNumberOfProjectiles = 1 | |
| self.stageTimer = 600 | |
| self.ship.position = (self.size.w/2, 32) | |
| self.game_over = False | |
| self.dismiss_modal_scene() | |
| self.paused = False | |
| self.laserBeamTickFrequencyUpgradeCost = 100 | |
| self.laserBeamTickFrequencyLevel = 1 | |
| self.laserBeamPowerUpgradeCost = 100 | |
| self.laserBeamPowerLevel = 1 | |
| self.laserBeamWidthUpgradeCost = 1000 | |
| self.laserBeamWidthLevel = 1 | |
| #self.rocketFireRateLevel = 1 | |
| #self.rocketPowerLevel = 1 | |
| #self.rocketNumberOfRocketsLevel = 1 | |
| #self.rocketFragmentsLevel = 1 | |
| def update(self): | |
| #if self.game_over: | |
| #return | |
| self.check_item_collisions() | |
| self.check_laser_collisions() | |
| if random.random() < 0.05 * self.stageNumber: | |
| if len(self.items) < 100: | |
| self.spawn_item() | |
| self.stageTimer -= 1 | |
| self.clockLabel.text = f'{round(self.stageTimer / 60, 1)}' | |
| if self.stageTimer <= 0: | |
| self.stageNumber += 1 | |
| self.stageLabel.text = f'Stage: {self.stageNumber}' | |
| self.stageTimer = 600 | |
| self.speed = 1.0 + self.stageNumber * 0.25 | |
| else: | |
| self.speed += 0.005 | |
| if (len(self.touches)) >= 1: | |
| self.shouldFire() | |
| """ | |
| def createDestroyStar(self): | |
| self.star = SpriteNode('shp:nova') | |
| #self.star.color = random.choice(self.listOfStarColors) | |
| if random.random() <= 0.25: | |
| self.star.color = '#ffefb3' | |
| else: | |
| self.star.color = '#FFFFFF' | |
| self.star.alpha = 0 | |
| self.star.scale = 0.25/5 | |
| self.star.position = (random.uniform(0,self.size.w), random.uniform(0,self.size.h)) | |
| self.star.rotation = (random.uniform(0,360)) | |
| noneToOne = random.uniform(0.0, 1) | |
| i = random.uniform(0,3) | |
| actions = [ | |
| A.scale_by(random.uniform(0, 0.01), i), | |
| A.fade_to(noneToOne, i), | |
| A.scale_to(random.uniform(0.02, 0.0), noneToOne), | |
| A.fade_to(0, noneToOne), | |
| A.remove() | |
| ] | |
| self.star.run_action(A.sequence(actions)) | |
| self.add_child(self.star) | |
| def writeToLeaderboard(self): | |
| fscore = f'{self.siConvert(self.gameScore)}' | |
| score = self.gameScore | |
| stage = f'{self.stageNumber}' | |
| playerName = console.input_alert(f'New High Score!\n{fscore}\n{stage}', 'Enter your Alias', hide_cancel_button=True) | |
| if playerName == "": | |
| playerName = "NOOB" | |
| self.playerName = playerName | |
| newEntry = f'{playerName}:{score}' | |
| f = open(leaderboardFile, "a+") | |
| f.write(newEntry + "\n") | |
| f.close() | |
| self.createLeaderboard() | |
| actions = [A.call(self.new_game), A.call(self.showStartMenu)] | |
| self.ship.run_action(A.sequence(actions)) | |
| def createLeaderboard(self): | |
| listOfScores = [] | |
| listOfNames = [] | |
| entries = [] | |
| with open(leaderboardFile) as f: | |
| #f.newlines = "\n" | |
| for line in f: | |
| entries.append(line) | |
| #print(line) | |
| for entry in entries: | |
| entry = entry.rstrip("\n") | |
| name = entry.split(":") | |
| name = name[0] | |
| score = entry.split(":") | |
| score = score[-1] | |
| #print(f'{name} {score}') | |
| listOfNames.append(name) | |
| listOfScores.append(float(score)) | |
| self.leaderboardEntry = f'{name} {score}' | |
| self.leaderboardEntries += self.leaderboardEntry + "\n" | |
| sortedLeaderboard = reversed(sorted(zip(listOfScores, listOfNames))) | |
| #result = sorted(unsorted, key=lambda s: (len(s), s)) | |
| #print(sortedLeaderboard) | |
| tuples = zip(*sortedLeaderboard) | |
| listOfScores, listOfNames = [list(tuple) for tuple in tuples] | |
| #print(f'listOfScores: {listOfScores}') | |
| #print(f'listOfNames: {listOfNames}') | |
| leaderboardList = [] | |
| placeCounter = 1 | |
| itemsToIterate = len(listOfNames) | |
| while len(leaderboardList) < 10 and itemsToIterate != 0: | |
| newEntry = f'#{placeCounter} {listOfNames.pop(0)} {self.siConvert(listOfScores.pop(0))}' | |
| leaderboardList.append(newEntry) | |
| placeCounter += 1 | |
| itemsToIterate -= 1 | |
| #print(f'leaderboardList: {leaderboardList}') | |
| self.leaderboardEntries = "" | |
| for x in leaderboardList: | |
| self.leaderboardEntries += x + "\n" | |
| #self.leaderboardEntries = leaderboardList | |
| def showLeaderboard(self): | |
| self.paused = True | |
| self.menu = MenuScene('Leaderboard', self.leaderboardEntries, ['Dismiss'], height = 300, buttonOffset = 5) | |
| self.present_modal_scene(self.menu) | |
| """ | |
| ## REPURPOSED CODE FROM CIRCUIT TOOL | |
| ## ONLY BOTTOM HALF IS UTILIZED | |
| def siConvert(self, number): | |
| if number == "": | |
| siOutput = "" | |
| return siOutput | |
| if number == 1E-30: | |
| siOutput = "" | |
| return siOutput | |
| if number == 1E30: | |
| siOutput = "" | |
| return siOutput | |
| number = float(number) | |
| if (0 < number < 1): | |
| if (number * 1000) >= 1:############################## 1E-3 | |
| multipliedNumber = number * 1000 | |
| multipliedNumber = round(multipliedNumber) | |
| siUnit = str(" m") | |
| siOutput = str(multipliedNumber) + siUnit | |
| elif (number * 1000000) >= 1: ######################## 1E-6 | |
| multipliedNumber = number * 1000000 | |
| multipliedNumber = round(multipliedNumber) | |
| siUnit = str(" u") | |
| siOutput = str(multipliedNumber) + siUnit | |
| elif (number * 1000000000) >= 1: ##################### 1E-9 | |
| multipliedNumber = number * 1000000000 | |
| multipliedNumber = round(multipliedNumber) | |
| siUnit = str(" n") | |
| siOutput = str(multipliedNumber) + siUnit | |
| elif (number * 1000000000000) >= 1:################### 1E-12 | |
| multipliedNumber = number * 1000000000000 | |
| multipliedNumber = round(multipliedNumber) | |
| siUnit = str(" p") | |
| siOutput = str(multipliedNumber) + siUnit | |
| elif (number * 1000000000000000) >= 1:################ 1E-15 | |
| multipliedNumber = number * 1000000000000000 | |
| multipliedNumber = round(multipliedNumber) | |
| siUnit = str(" f") | |
| siOutput = str(multipliedNumber) + siUnit | |
| elif number / 1000000000000000 >= 1: ########################### 1E15 | |
| dividedNumber = number / 1000000000000000 | |
| dividedNumber = round(dividedNumber, 2) | |
| siUnit = str("Q") | |
| siOutput = str(dividedNumber) + siUnit | |
| elif number / 1000000000000 >= 1: ########################### 1E12 | |
| dividedNumber = number / 1000000000000 | |
| dividedNumber = round(dividedNumber, 2) | |
| siUnit = str("T") | |
| siOutput = str(dividedNumber) + siUnit | |
| elif number / 1000000000 >= 1: ########################### 1E9 | |
| dividedNumber = number / 1000000000 | |
| dividedNumber = round(dividedNumber, 2) | |
| siUnit = str("B") | |
| siOutput = str(dividedNumber) + siUnit | |
| elif number / 1000000 >= 1: ############################## 1E6 | |
| dividedNumber = number / 1000000 | |
| dividedNumber = round(dividedNumber, 2) | |
| siUnit = str("M") | |
| siOutput = str(dividedNumber) + siUnit | |
| elif number / 1000 >= 1: ################################# 1E3 | |
| dividedNumber = number / 1000 | |
| dividedNumber = round(dividedNumber, 2) | |
| siUnit = str("K") | |
| siOutput = str(dividedNumber) + siUnit | |
| else: | |
| dividedNumber = number | |
| dividedNumber = round(dividedNumber, 2) | |
| siUnit = str("") | |
| siOutput = str(dividedNumber) + siUnit | |
| return siOutput | |
| def spawn_item(self): | |
| if random.random() < 0.05 * self.speed: | |
| meteor = Meteor(parent=self) | |
| meteor.scale = 1.0 | |
| meteor.position = (random.uniform(20, self.size.w-20), self.size.h + 30) | |
| d = random.uniform(12.0, 14.0) | |
| #if meteor.destroyed == True: | |
| #meteor.color = '#00FFFF' | |
| actions = [A.move_to(random.uniform(0, self.size.w), -50, d), A.remove()] | |
| meteor.run_action(A.sequence(actions)) | |
| self.items.append(meteor) | |
| if random.random() < 0.05 * self.speed: | |
| meteor2 = self.listOfInactiveMeteor2.pop(0) | |
| self.add_child(meteor2) | |
| meteor2.scale = 0.75 | |
| meteor2.livesRemaining = 20 * self.stageNumber | |
| meteor2.position = (random.uniform(20, self.size.w-20), self.size.h + 30) | |
| d = random.uniform(4.0, 8.0) | |
| actions = [A.move_to(random.uniform(0, self.size.w), -25, d), A.remove()] | |
| meteor2.run_action(A.sequence(actions)) | |
| self.items.append(meteor2) | |
| if random.random() < 0.01 * self.speed: | |
| meteor3 = Meteor3(parent=self) | |
| #meteor3.color = 'red' | |
| meteor3.scale = 1.25 | |
| meteor3.livesRemaining = 10 * self.stageNumber | |
| meteor3.position = (random.uniform(20, self.size.w-20), self.size.h + 30) | |
| d = random.uniform(6.0, 10.0) | |
| actions = [A.move_to(random.uniform(0, self.size.w), -25, d), A.remove()] | |
| meteor3.run_action(A.sequence(actions)) | |
| self.items.append(meteor3) | |
| if random.random() < 0.0075 * self.speed: | |
| meteor4 = Meteor4(parent=self) | |
| #meteor4.color = 'blue' | |
| meteor4.scale = 1.50 | |
| meteor4.livesRemaining = 20 * self.stageNumber | |
| meteor4.position = (random.uniform(20, self.size.w-20), self.size.h + 30) | |
| d = random.uniform(8.0, 12.0) | |
| actions = [A.move_to(random.uniform(0, self.size.w), -25, d), A.remove()] | |
| meteor4.run_action(A.sequence(actions)) | |
| self.items.append(meteor4) | |
| if random.random() < 0.0050 * self.speed: | |
| meteor5 = Meteor5(parent=self) | |
| #meteor5.color = 'green' | |
| meteor5.livesRemaining = 40 * self.stageNumber | |
| meteor5.scale = 1.75 | |
| meteor5.position = (random.uniform(20, self.size.w-20), self.size.h + 30) | |
| d = random.uniform(10.0, 14.0) | |
| actions = [A.move_to(random.uniform(0, self.size.w), -25, d), A.remove()] | |
| meteor5.run_action(A.sequence(actions)) | |
| self.items.append(meteor5) | |
| if random.random() < 0.0025 * self.speed: | |
| meteor6 = Meteor6(parent=self) | |
| #meteor6.color = 'purple' | |
| meteor6.scale = 2.00 | |
| meteor6.livesRemaining = 80 * self.stageNumber | |
| meteor6.position = (random.uniform(20, self.size.w-20), self.size.h + 30) | |
| d = random.uniform(12.0, 16.0) | |
| actions = [A.move_to(random.uniform(0, self.size.w), -25, d), A.remove()] | |
| meteor6.run_action(A.sequence(actions)) | |
| self.items.append(meteor6) | |
| if random.random() < 0.025 * self.speed: | |
| #if random.random() < 0.0025 * self.speed: | |
| upgrade = Upgrade(parent=self) | |
| upgrade.position = (random.uniform(20, self.size.w-20), self.size.h + 30) | |
| d = random.uniform(2.0, 4.0) | |
| actions = [A.move_by(0, -(self.size.h + 20), d), A.remove()] | |
| upgrade.run_action(A.sequence(actions)) | |
| self.items.append(upgrade) | |
| """ | |
| if random.random() < 0.025 * self.speed * self.stageNumber: | |
| coin1B = Coin1B(parent=self) | |
| coin1B.position = (random.uniform(20, self.size.w-20), self.size.h + 30) | |
| coin1B.color = '#FF9900' | |
| d = random.uniform(2.0, 4.0) | |
| actions = [A.fade_by(0.75), A.move_by(0, -(self.size.h + 60), d), A.fade_by(1.0), A.remove()] | |
| coin1B.run_action(A.sequence(actions)) | |
| self.items.append(coin1B) | |
| if random.random() < 0.05 * self.speed * self.stageNumber: | |
| coin100K = Coin100K(parent=self) | |
| coin100K.position = (random.uniform(20, self.size.w-20), self.size.h + 30) | |
| #coin100K.color = '#FF00AF' | |
| d = random.uniform(2.0, 4.0) | |
| actions = [A.fade_by(0.75), A.move_by(0, -(self.size.h + 60), d), A.fade_by(1.0), A.remove()] | |
| coin100K.run_action(A.sequence(actions)) | |
| self.items.append(coin100K) | |
| if random.random() < 0.1 * self.speed * self.stageNumber: | |
| coin10K = Coin10K(parent=self) | |
| coin10K.position = (random.uniform(20, self.size.w-20), self.size.h + 30) | |
| #coin10K.color = '#0000FF' | |
| d = random.uniform(2.0, 4.0) | |
| actions = [A.move_by(0, -(self.size.h + 60), d), A.remove()] | |
| coin10K.run_action(A.sequence(actions)) | |
| self.items.append(coin10K) | |
| if random.random() < 0.25 * self.speed * self.stageNumber: | |
| coin1K = Coin1K(parent=self) | |
| coin1K.position = (random.uniform(20, self.size.w-20), self.size.h + 30) | |
| #coin1K.color = '#FF0000' | |
| d = random.uniform(2.0, 4.0) | |
| actions = [A.move_by(0, -(self.size.h + 60), d), A.remove()] | |
| coin1K.run_action(A.sequence(actions)) | |
| self.items.append(coin1K) | |
| """ | |
| """ | |
| elif random.random() < 0.5 * self.speed * self.stageNumber: | |
| coin100 = Coin100(parent=self) | |
| coin100.position = (random.uniform(20, self.size.w-20), self.size.h + 30) | |
| d = random.uniform(2.0, 4.0) | |
| actions = [A.move_by(0, -(self.size.h + 60), d), A.remove()] | |
| coin100.run_action(A.sequence(actions)) | |
| self.items.append(coin100) | |
| """ | |
| self.speed = min(2.0, self.speed + 0.01) | |
| def collect_item(self, item, value=10): | |
| # UPGRADE | |
| """ | |
| if value == 101: | |
| sound.play_effect('digital:PowerUp8') | |
| self.numberOfLasers += 1 | |
| elif value == 1000: | |
| sound.play_effect('digital:PowerUp8') | |
| elif value == 10000: | |
| sound.play_effect('digital:PowerUp8') | |
| elif value == 100000: | |
| sound.play_effect('digital:PowerUp8') | |
| elif value == 1000000: | |
| sound.play_effect('digital:PowerUp8') | |
| elif value == 1000000000: | |
| sound.play_effect('arcade:Powerup_3') | |
| else: | |
| sound.play_effect('digital:PowerUp7') | |
| """ | |
| item.remove_from_parent() | |
| self.items.remove(item) | |
| self.score += value ## USED AS CURRENCY | |
| self.gameScore += value ## USED FOR LEADERBOARD IF RE-IMPLEMENTED | |
| self.score_label.text = self.siConvert(self.score) | |
| """ | |
| def flashyFlash(self): | |
| for item in list(self.items): | |
| if isinstance(item, Coin1B): | |
| item.color = self.listOfColors[self.colorCounter] | |
| if isinstance(item, MeteorTiny): | |
| if item.destroyed: | |
| item.color = self.listOfColors[(self.colorCounter - 2)] | |
| """ | |
| def touch_moved(self, touch): | |
| if self.game_over == False: | |
| x, y = touch.location | |
| move_action = Action.move_to(x, y + 40, 0.0) | |
| self.ship.run_action(move_action) | |
| def shouldFire(self): | |
| if self.game_over == False: | |
| if self.activeWeapon == 'laser': | |
| self.defaultWeaponTimer = self.laserFireRateLevel | |
| #playSound = sound.play_effect('arcade:Laser_6') | |
| elif self.activeWeapon == 'rocket': | |
| self.defaultWeaponTimer = self.rocketFireRateLevel | |
| #playSound = sound.play_effect('game:Woosh_1') | |
| elif self.activeWeapon == 'ropeLaser': | |
| self.defaultWeaponTimer = self.ropeLaserFireRateLevel | |
| if self.defaultWeaponTimer < 20: | |
| self.maxSpeedLevel = 0 | |
| if self.defaultWeaponTimer >= 20 < 30: | |
| self.maxSpeedLevel = 1 | |
| #self.defaultWeaponTimer = 0 | |
| if self.defaultWeaponTimer >= 30 < 40: | |
| self.maxSpeedLevel = 2 | |
| #self.defaultWeaponTimer = 0 | |
| if self.defaultWeaponTimer >= 40 < 50: | |
| self.maxSpeedLevel = 3 | |
| #self.defaultWeaponTimer = 0 | |
| if self.defaultWeaponTimer >= 50 < 60: | |
| self.maxSpeedLevel = 4 | |
| if self.defaultWeaponTimer >= 60 < 70: | |
| self.maxSpeedLevel = 5 | |
| if self.defaultWeaponTimer >= 70 < 80: | |
| self.maxSpeedLevel = 6 | |
| if self.defaultWeaponTimer >= 80: | |
| self.maxSpeedLevel = 7 | |
| #print(f'self.defaultWeaponTimer: {self.defaultWeaponTimer}') | |
| #print(f'self.maxSpeedLevel: {self.maxSpeedLevel}') | |
| if self.weaponTimer >= 100: | |
| if self.maxSpeedLevel == 0: | |
| self.fireWeapon() | |
| elif self.maxSpeedLevel == 1: | |
| self.fireWeapon(20, -5) | |
| self.fireWeapon(20, 5) | |
| elif self.maxSpeedLevel == 2: | |
| self.fireWeapon(20, -5) | |
| self.fireWeapon(20, 5) | |
| self.fireWeapon() | |
| elif self.maxSpeedLevel == 3: | |
| self.fireWeapon(30, -10) | |
| self.fireWeapon(30, 10) | |
| self.fireWeapon(20, -5) | |
| self.fireWeapon(20, 5) | |
| elif self.maxSpeedLevel == 4: | |
| self.fireWeapon(30, -10) | |
| self.fireWeapon(30, 10) | |
| self.fireWeapon(20, -5) | |
| self.fireWeapon(20, 5) | |
| self.fireWeapon() | |
| elif self.maxSpeedLevel == 5: | |
| self.fireWeapon(40, -15) | |
| self.fireWeapon(40, 15) | |
| self.fireWeapon(30, -10) | |
| self.fireWeapon(30, 10) | |
| self.fireWeapon(20, -5) | |
| self.fireWeapon(20, 5) | |
| elif self.maxSpeedLevel == 6: | |
| self.fireWeapon(40, -15) | |
| self.fireWeapon(40, 15) | |
| self.fireWeapon(30, -10) | |
| self.fireWeapon(30, 10) | |
| self.fireWeapon(20, -5) | |
| self.fireWeapon(20, 5) | |
| self.fireWeapon() | |
| elif self.maxSpeedLevel == 7: | |
| self.fireWeapon(50, -20) | |
| self.fireWeapon(50, 20) | |
| self.fireWeapon(40, -15) | |
| self.fireWeapon(40, 15) | |
| self.fireWeapon(30, -10) | |
| self.fireWeapon(30, 10) | |
| self.fireWeapon(20, -5) | |
| self.fireWeapon(20, 5) | |
| if self.activeWeapon == 'laser': | |
| sound.play_effect('arcade:Laser_6') | |
| elif self.activeWeapon == 'rocket': | |
| sound.play_effect('game:Woosh_1') | |
| self.weaponTimer = self.defaultWeaponTimer | |
| self.weaponTimer += 5 | |
| def touch_ended(self, touch): | |
| if self.game_over == False: | |
| self.showPauseMenu() | |
| def touch_began(self, touch): | |
| #print(f'touch: {touch}') | |
| x, y = touch.location | |
| if x < 48 and y > self.size.h - 48: | |
| self.showPauseMenu() | |
| ################################################################################ | |
| def saveProfile(self, passedPlayerName = None): | |
| if passedPlayerName == None: | |
| self.playerName = console.input_alert(f'Please enter your Profile Name', 'Case Sensitive, probably', hide_cancel_button=True) | |
| if self.playerName == "": | |
| self.playerName = "NOOB" | |
| else: | |
| self.playerName = passedPlayerName | |
| print(f'self.stageNumber: {self.stageNumber}') | |
| print(f'self.speed: {self.speed}') | |
| print(f'stageNumber: {stageNumber}') | |
| print(f'speed: {speed}') | |
| playerData = [] | |
| for x in ( | |
| self.playerName, #0 | |
| self.maxSpeedLevel, #1 | |
| self.numberOfProjectileLevel, #2 | |
| self.listOfProjectiles, #3 | |
| self.activeWeapon, #4 | |
| self.laserFireRateLevel, #5 | |
| self.defaultWeaponTimer, #6 | |
| self.laserFireRateUpgradeCost, #7 | |
| self.laserNumberOfLasersLevel, #8 | |
| self.laserNumberOfLasersUpgradeCost, #9 | |
| self.stageNumber, #10 | |
| self.gameScore, #11 | |
| self.listOfProjectilesX, #12 | |
| self.weaponTimer, #13 | |
| self.speed, #14 | |
| self.score, #15 | |
| self.listOfXOffsets, #16 | |
| self.rocketFireRateLevel, #17 | |
| self.rocketFireRateUpgradeCost, #18 | |
| self.rocketFragmentPenetrationLevel, #19 | |
| self.rocketFragmentPenetrationUpgradeCost, #20 | |
| self.rocketFragmentsLevel, #21 | |
| self.rocketFragmentsUpgradeCost, #22 | |
| self.laserPowerLevel, #23 | |
| self.laserPowerUpgradeCost #24 | |
| ): | |
| playerData.append(x) | |
| with open(self.playerName + ".txt", 'w') as f: | |
| json.dump(playerData, f) | |
| def resetStage(self, passedPlayerName = None): | |
| global stageNumber | |
| global speed | |
| if passedPlayerName != None: | |
| playerName = passedPlayerName | |
| self.stageNumber = 1 | |
| self.speed = 1.0 | |
| speed = self.speed | |
| stageNumber = self.stageNumber | |
| self.shipHit() | |
| def createNewProfile(self): | |
| playerName = console.input_alert(f'Please enter your Profile Name', 'Case Sensitive, probably', hide_cancel_button=True) | |
| if playerName == "": | |
| playerName = "NOOB" | |
| file = playerName + ".txt" | |
| if path.exists(file): | |
| self.paused = True | |
| profileExistsChoice = console.alert( | |
| title = f'Profile Exists!', | |
| message = f'Profile already exists for {playerName}.', | |
| button1 = f'Load Profile: {playerName}', | |
| button2 = f'Reset Profile: {playerName}', | |
| hide_cancel_button = True) | |
| if profileExistsChoice == 1: | |
| self.loadProfile(playerName) | |
| elif profileExistsChoice == 2: | |
| self.resetProfile(playerName) | |
| else: | |
| self.resetProfile(playerName) | |
| def resetProfile(self, passedPlayerName = None): | |
| global profileLoaded | |
| if passedPlayerName != None: | |
| self.playerName = passedPlayerName | |
| else: | |
| self.playerName = console.input_alert(f'Please enter your Profile Name', 'Case Sensitive, probably', hide_cancel_button=True) | |
| if self.playerName == "": | |
| self.playerName = "NOOB" | |
| playerData = [] | |
| for x in ( | |
| self.playerName, ##0 self.playerName | |
| 0, ##1 self.maxSpeedLevel | |
| 1, ##2 self.numberOfProjectileLevel | |
| ['fire1'], ##3 self.listOfProjectiles | |
| "laser", ##4 self.activeWeapon | |
| 1, ##5 self.laserFireRateLevel | |
| 0, ##6 self.defaultWeaponTimer | |
| 1000, ##7 self.laserFireRateUpgradeCost | |
| 1, ##8 self.laserNumberOfLasersLevel | |
| 100000, ##9 self.laserNumberOfLasersUpgradeCost | |
| 1, ##10 self.stageNumber | |
| 0, ##11 self.gameScore | |
| [0], ##12 self.listOfProjectilesX | |
| 0, ##13 self.weaponTimer | |
| 1.0, ##14 self.speed | |
| 0, ##15 self.score | |
| [-5, 5, -10, 10, -15, 15, -20, 20, -25, 25, -30, 30, -35, 35, -40, 40, -45, 45, -50, 50, -55, 55, -60, 60, -65, 65, -70, 70, -75, 75, -80, 80, -85, 85, -90, 90, -95, 95, -100, 100, -105, 105, -110, 110, -115, 115, -120, 120, -125, 125, -130, 130, -135, 135, -140, 140, -145, 145, -150, 150], ##16 self.listOfXOffsets | |
| 1, ##17 self.rocketFireRateLevel | |
| 10000, ##18 self.rocketFireRateUpgradeCost | |
| 1, ##19 self.rocketFragmentPenetrationLevel | |
| 100000, ##20 self.rocketFragmentPenetrationUpgradeCost | |
| 1, ##21 self.rocketFragmentsLevel | |
| 20000, ##22 self.rocketFragmentsUpgradeCost | |
| 1, ##23 self.laserPowerLevel | |
| 1000 ##24 self.laserPowerUpgradeCost | |
| ): | |
| playerData.append(x) | |
| with open(self.playerName + ".txt", 'w') as f: | |
| json.dump(playerData, f) | |
| profileLoaded = False | |
| self.ship = SpriteNode('spc:PlayerShip1Red') | |
| self.ship.scale = 0.50 | |
| self.ship.position = self.size / 2 | |
| self.add_child(self.ship) | |
| self.ship.position = (self.size.w/2, 32) | |
| resetFlag = 1 | |
| self.shipHit(resetFlag) | |
| self.loadProfile(self.playerName) | |
| """ | |
| console.alert(title[, message, button1, button2, button3, hide_cancel_button=False]) | |
| Show an alert dialog with up to three custom buttons. The selected button is returned as an integer (button1 => 1 ...). Unless hide_cancel_button is True, all alert dialogs contain a ‘Cancel’ button that sends a KeyboardInterrupt. | |
| """ | |
| def loadProfile(self, passedPlayerName = None, resetProfile = None): | |
| global playerName, maxSpeedLevel, numberOfProjectileLevel, listOfProjectiles, activeWeapon, laserFireRateLevel, defaultWeaponTimer, laserFireRateUpgradeCost, laserNumberOfLasersLevel, laserNumberOfLasersUpgradeCost, stageNumber, gameScore, listOfProjectilesX, weaponTimer, speed, x, score, listOfXOffsets | |
| global profileLoaded | |
| if passedPlayerName != None: | |
| self.playerName = passedPlayerName | |
| else: | |
| self.playerName = console.input_alert(f'Please enter your Profile Name', 'Case Sensitive, probably', hide_cancel_button=True) | |
| if self.playerName == "": | |
| self.playerName = "NOOB" | |
| if self.playerName == "SUDO" or self.playerName == "ADMIN": | |
| self.playerName = self.playerName | |
| self.maxSpeedLevel = 0 | |
| self.numberOfProjectileLevel = 1 | |
| self.listOfProjectiles = ['fire1'] | |
| self.activeWeapon = "laser" | |
| self.laserFireRateLevel = 1 | |
| self.defaultWeaponTimer = 0 | |
| self.laserFireRateUpgradeCost = 1 | |
| self.laserNumberOfLasersLevel = 1 | |
| self.laserNumberOfLasersUpgradeCost = 1 | |
| self.stageNumber = int(console.input_alert(f'Enter desired Stage Number', 'Must be of type INT', hide_cancel_button=True)) | |
| self.gameScore = 0 | |
| self.listOfProjectilesX = [0] | |
| self.weaponTimer = 0 | |
| self.speed = 1.0 | |
| self.score = 1e21 | |
| self.listOfXOffsets = [-5, 5, -10, 10, -15, 15, -20, 20, -25, 25, -30, 30, -35, 35, -40, 40, -45, 45, -50, 50, -55, 55, -60, 60, -65, 65, -70, 70, -75, 75, -80, 80, -85, 85, -90, 90, -95, 95, -100, 100, -105, 105, -110, 110, -115, 115, -120, 120, -125, 125, -130, 130, -135, 135, -140, 140, -145, 145, -150, 150] | |
| self.rocketFireRateLevel = 1 | |
| self.rocketFireRateUpgradeCost = 1 | |
| self.rocketFragmentPenetrationLevel = 1 | |
| self.rocketFragmentPenetrationUpgradeCost = 1 | |
| self.rocketFragmentsLevel = 1 | |
| self.rocketFragmentsUpgradeCost = 1 | |
| self.laserPowerLevel = 1 | |
| self.laserPowerUpgradeCost = 1 | |
| profileLoaded = True | |
| else: | |
| file = self.playerName + ".txt" | |
| if path.exists(file): | |
| with open(file, 'r') as f: | |
| x = json.load(f) | |
| for item in x: | |
| print(item) | |
| """ | |
| playerName = x[0] | |
| maxSpeedLevel = x[1] | |
| numberOfProjectileLevel = x[2] | |
| listOfProjectiles = x[3] | |
| activeWeapon = x[4] | |
| laserFireRateLevel = x[5] | |
| defaultWeaponTimer = x[6] | |
| laserFireRateUpgradeCost = x[7] | |
| laserNumberOfLasersLevel = x[8] | |
| laserNumberOfLasersUpgradeCost = x[9] | |
| stageNumber = x[10] | |
| gameScore = x[11] | |
| listOfProjectilesX = x[12] | |
| weaponTimer = x[13] | |
| speed = x[14] | |
| score = x[15] | |
| listOfXOffsets = x[16] | |
| """ | |
| ## STORE TO BOTH, JUST TO BE SURE. NEED TO LOOK INTO THIS MORE | |
| self.playerName = x[0] | |
| self.maxSpeedLevel = x[1] | |
| self.numberOfProjectileLevel = x[2] | |
| self.listOfProjectiles = x[3] | |
| self.activeWeapon = x[4] | |
| self.laserFireRateLevel = x[5] | |
| self.defaultWeaponTimer = x[6] | |
| self.laserFireRateUpgradeCost = x[7] | |
| self.laserNumberOfLasersLevel = x[8] | |
| self.laserNumberOfLasersUpgradeCost = x[9] | |
| self.stageNumber = x[10] | |
| self.gameScore = x[11] | |
| self.listOfProjectilesX = x[12] | |
| self.weaponTimer = x[13] | |
| self.speed = x[14] | |
| self.score = x[15] | |
| self.listOfXOffsets = x[16] | |
| self.rocketFireRateLevel = x[17] | |
| self.rocketFireRateUpgradeCost = x[18] | |
| self.rocketFragmentPenetrationLevel = x[19] | |
| self.rocketFragmentPenetrationUpgradeCost = x[20] | |
| self.rocketFragmentsLevel = x[21] | |
| self.rocketFragmentsUpgradeCost = x[22] | |
| self.laserPowerLevel = x[23] | |
| self.laserPowerUpgradeCost = x[24] | |
| profileLoaded = True | |
| #self.playerName = playerName | |
| self.new_game() | |
| def showGameOverMenu(self): | |
| self.paused = True | |
| self.menu = MenuScene('Space Shooter', 'GAME OVER', ["CONTINUE", "QUIT"]) | |
| self.present_modal_scene(self.menu) | |
| def showPlayMenu(self): | |
| self.paused = True | |
| self.menu = MenuScene('Space Shooter', 'Ship Ready', ["Let's Go!"]) | |
| self.present_modal_scene(self.menu) | |
| def showStartMenu(self): | |
| self.paused = True | |
| self.menu = MenuScene('Space Shooter', 'Main Menu', ['Load Profile', 'New Profile', 'Reset Profile']) | |
| self.present_modal_scene(self.menu) | |
| #print(f'showStartMenu: {self.menu. | |
| def showPauseMenu(self): | |
| self.paused = True | |
| self.menu = MenuScene('Space Shooter', 'Paused', ['Continue', 'Reset Stage', 'Upgrades']) | |
| self.menu.bg = '#00FFCF' | |
| self.present_modal_scene(self.menu) | |
| def showUpgradesMenu(self): | |
| self.paused = True | |
| self.menu = MenuScene('Space Shooter', 'Upgrade Shop', ['Continue', 'Laser', 'Rocket']) | |
| # , 'Laser-Beam' | |
| self.present_modal_scene(self.menu) | |
| def showLaserUpgrades(self): | |
| self.score_label.text = self.siConvert(self.score) | |
| self.paused = True | |
| self.activeWeapon = 'laser' | |
| self.menu = MenuScene('Upgrade Shop', 'Laser Upgrades', ['Continue', f'Laser Fire Rate: {self.laserFireRateLevel} $' + self.siConvert(self.laserFireRateUpgradeCost), f'Laser Power: {self.laserPowerLevel} $' + self.siConvert(self.laserPowerUpgradeCost), f'Number of lasers: {self.laserNumberOfLasersLevel} $' + self.siConvert(self.laserNumberOfLasersUpgradeCost)]) | |
| self.present_modal_scene(self.menu) | |
| def showLaserBeamUpgrades(self): | |
| self.score_label.text = self.siConvert(self.score) | |
| self.paused = True | |
| self.activeWeapon = 'laserBeam' | |
| self.menu = MenuScene('Upgrade Shop', 'Laser-Beam Upgrades', ['Continue', f'Laser-Beam Tick Frequency: {self.laserBeamTickFrequencyLevel} $' + self.siConvert(self.laserBeamTickFrequencyUpgradeCost), f'Laser-Beam Power: {self.laserBeamPowerLevel} $' + self.siConvert(self.laserBeamPowerUpgradeCost), f'Laser-Beam Width: {self.laserBeamWidthLevel} $' + self.siConvert(self.laserBeamWidthUpgradeCost)]) | |
| self.present_modal_scene(self.menu) | |
| def showRocketUpgrades(self): | |
| self.score_label.text = self.siConvert(self.score) | |
| self.paused = True | |
| self.activeWeapon = 'rocket' | |
| self.menu = MenuScene('Upgrade Shop', 'Rocket Upgrades', ['Continue', f'Rocket Fire Rate: {self.rocketFireRateLevel} $' + self.siConvert(self.rocketFireRateUpgradeCost), f'Rocket Fragments: {self.rocketFragmentsLevel} $' + self.siConvert(self.rocketFragmentsUpgradeCost), f'Fragment Penetration: {self.rocketFragmentPenetrationLevel} $' + self.siConvert(self.rocketFragmentPenetrationUpgradeCost)]) | |
| self.present_modal_scene(self.menu) | |
| def purchaseUpgrade(self, title): | |
| ## LASERS | |
| if title.startswith('Laser Fire Rate: '): | |
| if self.score >= self.laserFireRateUpgradeCost: | |
| self.laserFireRateLevel += 1 | |
| #print(f'self.laserFireRateLevel: {self.laserFireRateLevel}') | |
| self.defaultWeaponTimer += 5 | |
| #print(f'self.defaultWeaponTimer: {self.defaultWeaponTimer}') | |
| self.score -= self.laserFireRateUpgradeCost | |
| self.laserFireRateUpgradeCost *= (self.upgradeCostMultiplier * 0.75) | |
| self.laserFireRateUpgradeCost = round(self.laserFireRateUpgradeCost) | |
| self.showLaserUpgrades() | |
| if title.startswith('Laser Power: '): | |
| if self.score >= self.laserPowerUpgradeCost: | |
| self.laserPowerLevel += 1 | |
| self.score -= self.laserPowerUpgradeCost | |
| self.laserPowerUpgradeCost *= self.upgradeCostMultiplier | |
| self.laserPowerUpgradeCost = round(self.laserPowerUpgradeCost) | |
| self.showLaserUpgrades() | |
| if title.startswith('Number of lasers: '): | |
| if self.score >= self.laserNumberOfLasersUpgradeCost: | |
| self.laserNumberOfLasersLevel += 1 | |
| self.score -= self.laserNumberOfLasersUpgradeCost | |
| self.laserNumberOfLasersUpgradeCost *= (self.upgradeCostMultiplier * 2) | |
| self.laserNumberOfLasersUpgradeCost = round(self.laserNumberOfLasersUpgradeCost) | |
| #print(f'self.laserNumberOfLasersLevel: {self.laserNumberOfLasersLevel}') | |
| self.showLaserUpgrades() | |
| ## ROCKETS | |
| if title.startswith('Rocket Fire Rate: '): | |
| if self.score >= self.rocketFireRateUpgradeCost: | |
| self.rocketFireRateLevel += 1 | |
| self.defaultWeaponTimer += 5 | |
| self.score -= self.rocketFireRateUpgradeCost | |
| self.rocketFireRateUpgradeCost *= self.upgradeCostMultiplier | |
| self.rocketFireRateUpgradeCost = round(self.rocketFireRateUpgradeCost) | |
| self.showRocketUpgrades() | |
| if title.startswith('Rocket Fragments: '): | |
| if self.score >= self.rocketFragmentsUpgradeCost: | |
| self.rocketFragmentsLevel += 1 | |
| self.score -= self.rocketFragmentsUpgradeCost | |
| self.rocketFragmentsUpgradeCost *= self.upgradeCostMultiplier | |
| self.rocketFragmentsUpgradeCost = round(self.rocketFragmentsUpgradeCost) | |
| self.showRocketUpgrades() | |
| if title.startswith('Fragment Penetration: '): | |
| if self.score >= self.rocketFragmentPenetrationUpgradeCost: | |
| self.rocketFragmentPenetrationLevel += 1 | |
| self.score -= self.rocketFragmentPenetrationUpgradeCost | |
| self.rocketFragmentPenetrationUpgradeCost *= self.upgradeCostMultiplier | |
| self.rocketFragmentPenetrationUpgradeCost = round(self.rocketFragmentPenetrationUpgradeCost) | |
| self.showRocketUpgrades() | |
| ## LASER-BEAM | |
| if title.startswith('Laser-Beam Tick: '): | |
| if self.score >= self.laserBeamTickFrequencyUpgradeCost: | |
| self.laserBeamTickFrequencyLevel += 1 | |
| self.defaultWeaponTimer += 5 | |
| self.score -= self.laserBeamTickFrequencyUpgradeCost | |
| self.laserBeamTickFrequencyUpgradeCost *= self.upgradeCostMultiplier | |
| self.laserBeamTickFrequencyUpgradeCost = round(self.laserBeamTickFrequencyUpgradeCost) | |
| self.showLaserBeamUpgrades() | |
| if title.startswith('Laser-Beam Power: '): | |
| if self.score >= self.laserBeamPowerUpgradeCost: | |
| self.laserBeamPowerLevel += 1 | |
| self.score -= self.laserBeamPowerUpgradeCost | |
| self.laserBeamPowerUpgradeCost *= self.upgradeCostMultiplier | |
| self.laserBeamPowerUpgradeCost = round(self.laserBeamPowerUpgradeCost) | |
| self.showLaserBeamUpgrades() | |
| if title.startswith('Laser-Beam Width: '): | |
| if self.score >= self.laserBeamWidthUpgradeCost: | |
| self.laserBeamWidthLevel += 1 | |
| self.score -= self.laserBeamWidthUpgradeCost | |
| self.laserBeamWidthUpgradeCost *= self.upgradeCostMultiplier | |
| self.laserBeamWidthUpgradeCost = round(self.laserBeamWidthUpgradeCost) | |
| self.showLaserBeamUpgrades() | |
| def menu_button_selected(self, title): | |
| global profileLoaded | |
| #print(f'self.ship.position: {self.ship.position}') | |
| upgradeTitle = title | |
| if title == "Let's Go!": | |
| self.dismiss_modal_scene() | |
| self.paused = False | |
| self.game_over = False | |
| if title == "CONTINUE": | |
| self.dismiss_modal_scene() | |
| self.new_game() | |
| if title == "QUIT": | |
| self.dismiss_modal_scene() | |
| console.alert('Your Progress has been Saved', "If things get too difficult, you can Reset your Profile!", hide_cancel_button = True) | |
| if title == 'Load Profile': | |
| self.dismiss_modal_scene() | |
| self.loadProfile() | |
| if title == 'New Profile': | |
| self.dismiss_modal_scene() | |
| self.createNewProfile() | |
| if title == 'Reset Profile': | |
| self.dismiss_modal_scene() | |
| self.resetProfile() | |
| if title == 'Upgrades': | |
| self.showUpgradesMenu() | |
| if title == 'Laser': | |
| self.showLaserUpgrades() | |
| if (title.startswith('Laser ') or title.startswith('Number of lasers: ')): | |
| self.purchaseUpgrade(title) | |
| if title == 'Rocket': | |
| self.showRocketUpgrades() | |
| if (title.startswith('Rocket ') or title.startswith('Fragment Penetration: ')): | |
| self.purchaseUpgrade(title) | |
| if title == 'Laser-Beam': | |
| self.showLaserBeamUpgrades() | |
| if (title.startswith('Laser-Beam Tick ') or title.startswith('Laser-Beam Power: ') or title.startswith('Laser-Beam Width')): | |
| self.purchaseUpgrade(title) | |
| if title == 'Leaderboard': | |
| self.showLeaderboard() | |
| if title == 'Dismiss': | |
| if self.paused: | |
| self.showPauseMenu() | |
| else: | |
| self.showStartMenu() | |
| if title == 'Reset Stage': | |
| self.dismiss_modal_scene() | |
| self.paused = False | |
| self.resetStage(playerName) | |
| if title in ('Continue', 'New Game', 'Play'): | |
| if title in ('New Game'): | |
| profileLoaded = False | |
| self.dismiss_modal_scene() | |
| self.menu = None | |
| #self.new_game() | |
| else: | |
| self.dismiss_modal_scene() | |
| self.menu = None | |
| self.paused = False | |
| def check_item_collisions(self): | |
| #self.ship.bbox = Rect(self.ship.bbox[0] + 5, self.ship.bbox[1] + 5, self.ship.bbox[2] - 10, self.ship.bbox[3] - 10) | |
| shipHitbox = self.ship.bbox | |
| #print(f'self.ship.bbox: {self.ship.bbox}') | |
| #shipHitbox = Rect(self.ship.position.x - 25, self.ship.position.y - 25, 40, 30) | |
| for item in list(self.items): | |
| if item.frame.intersects(shipHitbox): | |
| #if isinstance(item, Coin): | |
| #self.collect_item(item) | |
| if isinstance(item, Upgrade): | |
| self.collect_item(item, (1E12 * (self.stageNumber**3))) | |
| #elif isinstance(item, Coin100): | |
| #self.collect_item(item, (1000 * self.stageNumber)) | |
| #elif isinstance(item, Coin1K): | |
| #self.collect_item(item, (10000 * self.stageNumber)) | |
| #elif isinstance(item, Coin10K): | |
| #self.collect_item(item, (100000 * self.stageNumber)) | |
| #elif isinstance(item, Coin100K): | |
| #self.collect_item(item, (1000000 * self.stageNumber)) | |
| #elif isinstance(item, Coin1B): | |
| #self.collect_item(item, (1000000000 * (self.stageNumber**3))) | |
| #elif isinstance(item, MeteorTiny): | |
| #if item.destroyed: | |
| #self.collect_item(item, (100000000 * (self.stageNumber**3))) | |
| #else: | |
| #self.shipHit() | |
| else: | |
| self.shipHit() | |
| """ | |
| elif isinstance(item, Meteor): | |
| self.shipHit() | |
| elif isinstance(item, MeteorMedium): | |
| self.shipHit() | |
| elif isinstance(item, MeteorSmall): | |
| self.shipHit() | |
| """ | |
| elif not item.parent: | |
| if self.game_over == False: | |
| if isinstance(item, Meteor2): | |
| indexOfMeteor = self.items.index(item) | |
| self.listOfInactiveMeteor2.append(self.items.pop(indexOfMeteor)) | |
| #print('IT HAPPENED AGAIN') | |
| elif isinstance(item, MeteorMedium): | |
| indexOfMeteor = self.items.index(item) | |
| self.listOfInactiveMeteorMedium.append(self.items.pop(indexOfMeteor)) | |
| elif isinstance(item, MeteorSmall): | |
| indexOfMeteor = self.items.index(item) | |
| self.listOfInactiveMeteorSmall.append(self.items.pop(indexOfMeteor)) | |
| elif isinstance(item, MeteorTiny): | |
| indexOfMeteor = self.items.index(item) | |
| self.listOfInactiveMeteorTiny.append(self.items.pop(indexOfMeteor)) | |
| else: | |
| self.items.remove(item) | |
| ## RENAME THIS TO BE MORE 'INCLUSIVE'. | |
| ## PERHAPS 'checkProjectileCollisions' | |
| def check_laser_collisions(self): | |
| for projectile in list(self.projectiles): | |
| if not projectile.parent: | |
| #print(projectile) | |
| if type(projectile) == MiniRocket: | |
| #print('IT HAPPENED') | |
| self.add_child(projectile) | |
| indexOfProjectile = self.projectiles.index(projectile) | |
| self.listOfInactiveFragments.append(self.projectiles.pop(indexOfProjectile)) | |
| else: | |
| self.projectiles.remove(projectile) | |
| continue | |
| for item in self.items: | |
| if not isinstance(item, Meteor): | |
| if not isinstance(item, Meteor2): | |
| if not isinstance(item, Meteor3): | |
| if not isinstance(item, Meteor4): | |
| if not isinstance(item, Meteor5): | |
| if not isinstance(item, Meteor6): | |
| if not isinstance(item, MeteorMedium): | |
| if not isinstance(item, MeteorSmall): | |
| if not isinstance(item, MeteorTiny): | |
| continue | |
| if item.destroyed: | |
| #print("Entered if item.destroyed:") | |
| continue | |
| #print("Reached if projectile.position in item.frame:") | |
| if projectile.position in item.frame: | |
| if isinstance(projectile, Rocket): | |
| # sound.play_effect('arcade:Explosion_2') | |
| self.destroy_meteor(item, 1) | |
| #self.projectiles.remove(projectile) | |
| #projectile.remove_from_parent() | |
| fragmentsToCreate = round(self.rocketFragmentsLevel) | |
| fragmentMovementSpeed = 10 - (self.rocketFragmentsLevel * 0.1) | |
| if fragmentMovementSpeed <= 1.0: | |
| fragmentMovementSpeed = 1.0 | |
| #for i in range(fragmentsToCreate): | |
| for i in range(fragmentsToCreate): | |
| miniRocket = self.listOfInactiveFragments.pop(0) | |
| miniRocket.collisionsLeft = self.rocketFragmentPenetrationLevel | |
| miniRocket.scale = 0.25 | |
| miniRocket.color = '#07ff1c' | |
| miniRocket.z_position = 0 | |
| miniRocket.position = projectile.position | |
| fullCircle = random.uniform(0, pi*2) | |
| #upwardAngle = random.uniform(0, pi) | |
| dx, dy = cos(fullCircle) * self.size.h * 2, sin(fullCircle) * self.size.h * 2 | |
| #d = 1.25 | |
| #miniRocket.rotation = fullCircle | |
| #self.projectiles.append(miniRocket) | |
| self.add_child(miniRocket) | |
| actions = (A.sequence(A.move_by(dx, dy, fragmentMovementSpeed, TIMING_EASE_IN), A.remove())) | |
| #actions2 = (A.sequence(A.fade_to(1.0, fragmentMovementSpeed, TIMING_EASE_IN), A.remove())) | |
| miniRocket.run_action(A.group((actions))) | |
| #, (actions2))) | |
| self.projectiles.append(miniRocket) | |
| self.projectiles.remove(projectile) | |
| projectile.remove_from_parent() | |
| #m = SpriteNode(explosionTexture, scale = 0.50, color = '#ffaf57', parent=self) | |
| #m.position = projectile.position | |
| #m.run_action(A.sequence(A.fade_to(0, 0.3, TIMING_EASE_OUT), A.remove())) | |
| if isinstance(projectile, MiniRocket): | |
| #sound.play_effect('arcade:Explosion_2') | |
| self.destroy_meteor(item) | |
| projectile.collisionsLeft -= 1 | |
| if projectile.collisionsLeft <= 0: | |
| indexOfProjectile = self.projectiles.index(projectile) | |
| self.listOfInactiveFragments.append(self.projectiles.pop(indexOfProjectile)) | |
| #self.projectiles.remove(projectile) | |
| #projectile.remove_from_parent() | |
| #self.listOfInactiveFragments.append(self.listOfActiveFragments.pop(0)) | |
| #m = SpriteNode(explosionTexture, scale = 0.25, color = '#ffaf57', parent=self) | |
| #m.position = projectile.position | |
| #m.run_action(A.sequence(A.fade_to(0, 0.3, TIMING_EASE_OUT), A.remove())) | |
| if isinstance(projectile, Laser): | |
| self.destroy_meteor(item) | |
| self.destroy_meteor(item) | |
| projectile.collisionsLeft -= 2 | |
| if projectile.collisionsLeft <= 0: | |
| self.projectiles.remove(projectile) | |
| projectile.remove_from_parent() | |
| else: | |
| self.destroy_meteor(item) | |
| #self.projectiles.remove(projectile) | |
| #projectile.remove_from_parent() | |
| break | |
| """ | |
| if isinstance(projectile, LaserSlice): | |
| self.destroy_meteor(item) | |
| """ | |
| def destroy_meteor(self, meteor, isRocket = None): | |
| global brownMeteorMed | |
| global explosionTexture | |
| global smokeTextureMed | |
| global smokeTextureSmall | |
| global starTextureSilver | |
| #print(f'Entered destroy_meteor() with meteor: {meteor}') | |
| if isinstance(meteor, Meteor): | |
| # sound.load_effect('arcade:Explosion_2') | |
| # sound.play_effect('arcade:Explosion_2') | |
| m = SpriteNode(explosionTexture, scale = 0.25, parent=self) | |
| m.position = meteor.position | |
| m.run_action(A.sequence(A.fade_to(0, 0.3, TIMING_EASE_OUT), A.remove())) | |
| meteor.destroyed = True | |
| meteor.remove_from_parent() | |
| elif isinstance(meteor, Meteor2): | |
| if activeWeapon == 'laser': | |
| meteor.livesRemaining -= 9 | |
| meteor.livesRemaining -= 1 | |
| if meteor.livesRemaining <= 0: | |
| meteorPosition = meteor.position | |
| indexOfMeteor = self.items.index(meteor) | |
| self.listOfInactiveMeteor2.append(self.items.pop(indexOfMeteor)) | |
| meteor.remove_from_parent() | |
| #m = SpriteNode(explosionTexture, scale = 0.25, parent=self) | |
| #m.position = meteorPosition | |
| #m.run_action(A.sequence(A.fade_to(0, 0.3, TIMING_EASE_OUT), A.remove())) | |
| """ | |
| if random.random() < 0.25 * self.stageNumber: | |
| for i in range(2): | |
| meteorMedium = self.listOfInactiveMeteorMedium.pop(0) | |
| self.add_child(meteorMedium) | |
| #sound.play_effect('arcade:Explosion_2') | |
| meteorMedium.destroyed = False | |
| meteorMedium.livesRemaining = 10 * self.stageNumber | |
| meteorMedium.position = meteorPosition + (random.uniform(-30, 30), (-20 + random.uniform(-5, 5))) | |
| downwardAngle = random.uniform(pi, pi*2) | |
| dx, dy = cos(downwardAngle) * 80, sin(downwardAngle) * 80 | |
| d = random.uniform(8.0, 15.0) | |
| actions = [A.move_to(random.uniform(0, self.size.w), -25, d), A.remove()] | |
| meteorMedium.run_action(A.sequence(actions)) | |
| self.items.append(meteorMedium) | |
| """ | |
| else: | |
| #sound.play_effect('arcade:Hit_1') | |
| if meteor.livesRemaining <= (20 * self.stageNumber) * 0.25: | |
| meteor.alpha = 0.25 | |
| elif meteor.livesRemaining <= (20 * self.stageNumber) * 0.50: | |
| meteor.alpha = 0.5 | |
| elif meteor.livesRemaining <= (20 * self.stageNumber) * 0.75: | |
| meteor.alpha = 0.75 | |
| elif isinstance(meteor, MeteorMedium): | |
| if activeWeapon == 'laser': | |
| meteor.livesRemaining -= 9 | |
| meteor.livesRemaining -= 1 | |
| if meteor.livesRemaining <= 0: | |
| meteorPosition = meteor.position | |
| indexOfMeteor = self.items.index(meteor) | |
| self.listOfInactiveMeteorMedium.append(self.items.pop(indexOfMeteor)) | |
| meteor.remove_from_parent() | |
| """ | |
| if random.random() < 0.20 * self.stageNumber: | |
| for i in range(2): | |
| meteorSmall = self.listOfInactiveMeteorSmall.pop(0) | |
| self.add_child(meteorSmall) | |
| #sound.play_effect('arcade:Explosion_2') | |
| meteorSmall.destroyed = False | |
| meteorSmall.livesRemaining = 10 * self.stageNumber | |
| meteorSmall.position = meteorPosition + (random.uniform(-30, 30), (-20 + random.uniform(-5, 5))) | |
| downwardAngle = random.uniform(pi, pi*2) | |
| dx, dy = cos(downwardAngle) * 80, sin(downwardAngle) * 80 | |
| d = random.uniform(8.0, 15.0) | |
| actions = [A.move_to(random.uniform(0, self.size.w), -25, d), A.remove()] | |
| meteorSmall.run_action(A.sequence(actions)) | |
| self.items.append(meteorSmall) | |
| """ | |
| else: | |
| #sound.play_effect('arcade:Hit_1') | |
| if meteor.livesRemaining <= (10 * self.stageNumber) * 0.25: | |
| meteor.alpha = 0.25 | |
| elif meteor.livesRemaining <= (10 * self.stageNumber) * 0.50: | |
| meteor.alpha = 0.5 | |
| elif meteor.livesRemaining <= (10 * self.stageNumber) * 0.75: | |
| meteor.alpha = 0.75 | |
| elif isinstance(meteor, MeteorSmall): | |
| if activeWeapon == 'laser': | |
| meteor.livesRemaining -= 9 | |
| meteor.livesRemaining -= 1 | |
| if meteor.livesRemaining <= 0: | |
| meteorPosition = meteor.position | |
| indexOfMeteor = self.items.index(meteor) | |
| self.listOfInactiveMeteorSmall.append(self.items.pop(indexOfMeteor)) | |
| meteor.remove_from_parent() | |
| """ | |
| if random.random() < 0.20 * self.stageNumber: | |
| for i in range(2): | |
| meteorTiny = self.listOfInactiveMeteorTiny.pop(0) | |
| self.add_child(meteorTiny) | |
| #sound.play_effect('arcade:Explosion_2') | |
| meteorTiny.destroyed = False | |
| meteorTiny.livesRemaining = 10 * self.stageNumber | |
| meteorTiny.position = meteorPosition + (random.uniform(-30, 30), (-20 + random.uniform(-5, 5))) | |
| downwardAngle = random.uniform(pi, pi*2) | |
| dx, dy = cos(downwardAngle) * 80, sin(downwardAngle) * 80 | |
| d = random.uniform(8.0, 15.0) | |
| actions = [A.move_to(random.uniform(0, self.size.w), -25, d), A.remove()] | |
| meteorTiny.run_action(A.sequence(actions)) | |
| self.items.append(meteorTiny) | |
| """ | |
| else: | |
| #sound.play_effect('arcade:Hit_1') | |
| if meteor.livesRemaining <= (10 * self.stageNumber) * 0.25: | |
| meteor.alpha = 0.25 | |
| elif meteor.livesRemaining <= (10 * self.stageNumber) * 0.50: | |
| meteor.alpha = 0.5 | |
| elif meteor.livesRemaining <= (10 * self.stageNumber) * 0.75: | |
| meteor.alpha = 0.75 | |
| elif isinstance(meteor, MeteorTiny): | |
| #sound.play_effect('arcade:Explosion_7') | |
| if activeWeapon == 'laser': | |
| meteor.livesRemaining -= 9 | |
| meteor.livesRemaining -= 1 | |
| if meteor.livesRemaining <= 0: | |
| meteorPosition = meteor.position | |
| indexOfMeteor = self.items.index(meteor) | |
| self.listOfInactiveMeteorTiny.append(self.items.pop(indexOfMeteor)) | |
| meteor.remove_from_parent() | |
| elif isinstance(meteor, Meteor3): | |
| if self.stageNumber < 5: | |
| meteor.livesRemaining -= 50 | |
| else: | |
| if activeWeapon == 'laser': | |
| meteor.livesRemaining -= 9 | |
| meteor.livesRemaining -= 1 | |
| if meteor.livesRemaining <= 0: | |
| # sound.play_effect('arcade:Explosion_2') | |
| m = SpriteNode(explosionTexture, scale = 0.25, parent=self) | |
| m.position = meteor.position | |
| m.run_action(A.sequence(A.fade_to(0, 0.3, TIMING_EASE_OUT), A.remove())) | |
| meteor.destroyed = True | |
| meteor.remove_from_parent() | |
| else: | |
| # sound.play_effect('arcade:Hit_1') | |
| if meteor.livesRemaining <= (10 * self.stageNumber) * 0.25: | |
| meteor.alpha = 0.25 | |
| elif meteor.livesRemaining <= (10 * self.stageNumber) * 0.50: | |
| meteor.alpha = 0.5 | |
| elif meteor.livesRemaining <= (10 * self.stageNumber) * 0.75: | |
| meteor.alpha = 0.75 | |
| elif isinstance(meteor, Meteor4): | |
| if self.stageNumber < 5: | |
| meteor.livesRemaining -= 100 | |
| else: | |
| if activeWeapon == 'laser': | |
| meteor.livesRemaining -= 9 | |
| meteor.livesRemaining -= 1 | |
| if meteor.livesRemaining <= 0: | |
| # sound.play_effect('arcade:Explosion_2') | |
| m = SpriteNode(explosionTexture, scale = 0.50, parent=self) | |
| m.position = meteor.position | |
| m.run_action(A.sequence(A.fade_to(0, 0.3, TIMING_EASE_OUT), A.remove())) | |
| meteor.destroyed = True | |
| meteor.remove_from_parent() | |
| else: | |
| # sound.play_effect('arcade:Hit_1') | |
| if meteor.livesRemaining <= (20 * self.stageNumber) * 0.25: | |
| meteor.alpha = 0.25 | |
| elif meteor.livesRemaining <= (20 * self.stageNumber) * 0.50: | |
| meteor.alpha = 0.5 | |
| elif meteor.livesRemaining <= (20 * self.stageNumber) * 0.75: | |
| meteor.alpha = 0.75 | |
| elif isinstance(meteor, Meteor5): | |
| if self.stageNumber < 5: | |
| meteor.livesRemaining -= 250 | |
| else: | |
| if activeWeapon == 'laser': | |
| meteor.livesRemaining -= 9 | |
| meteor.livesRemaining -= 1 | |
| if meteor.livesRemaining <= 0: | |
| # sound.play_effect('arcade:Explosion_2') | |
| m = SpriteNode(explosionTexture, scale = 0.75, parent=self) | |
| m.position = meteor.position | |
| m.run_action(A.sequence(A.fade_to(0, 0.3, TIMING_EASE_OUT), A.remove())) | |
| meteor.destroyed = True | |
| meteor.remove_from_parent() | |
| else: | |
| # sound.play_effect('arcade:Hit_1') | |
| if meteor.livesRemaining <= (40 * self.stageNumber) * 0.25: | |
| meteor.alpha = 0.25 | |
| elif meteor.livesRemaining <= (40 * self.stageNumber) * 0.50: | |
| meteor.alpha = 0.5 | |
| elif meteor.livesRemaining <= (40 * self.stageNumber) * 0.75: | |
| meteor.alpha = 0.75 | |
| elif isinstance(meteor, Meteor6): | |
| if self.stageNumber < 5: | |
| meteor.livesRemaining -= 250 | |
| else: | |
| if activeWeapon == 'laser': | |
| meteor.livesRemaining -= 9 | |
| meteor.livesRemaining -= 1 | |
| if meteor.livesRemaining <= 0: | |
| # sound.play_effect('arcade:Explosion_2') | |
| m = SpriteNode(explosionTexture, scale = 1.00, parent=self) | |
| m.position = meteor.position | |
| m.run_action(A.sequence(A.fade_to(0, 0.3, TIMING_EASE_OUT), A.remove())) | |
| meteor.destroyed = True | |
| meteor.remove_from_parent() | |
| else: | |
| # sound.play_effect('arcade:Hit_1') | |
| if meteor.livesRemaining <= (80 * self.stageNumber) * 0.25: | |
| meteor.alpha = 0.25 | |
| elif meteor.livesRemaining <= (80 * self.stageNumber) * 0.50: | |
| meteor.alpha = 0.5 | |
| elif meteor.livesRemaining <= (80 * self.stageNumber) * 0.75: | |
| meteor.alpha = 0.75 | |
| #classmethod Action.move_to(x, y[, duration, timing_mode]) | |
| #Creates an action that moves a node to a new position. | |
| #actions = [A.move_to(self.ship.position[0], self.ship.position[1], d, TIMING_LINEAR), A.remove()] | |
| #actions = [A.move_by(0, -(self.size.h + 30), d), A.remove()] | |
| #meteor.run_action(A.sequence(actions)) | |
| def shipHit(self, resetFlag = None): | |
| self.game_over = True | |
| self.score_label.text = "GAME OVER" | |
| m = SpriteNode(explosionTexture, scale = 1.0, parent=self) | |
| m.position = self.ship.position | |
| actions = [sound.play_effect('arcade:Explosion_1'), A.move_by(0, (-1 * self.size.h), 1.0 * self.speed), A.wait(2*self.speed), sound.play_effect('arcade:Explosion_4', pitch = 0.5)] | |
| self.ship.run_action(A.sequence(actions)) | |
| m.run_action(A.sequence(A.fade_to(0, 1.0, TIMING_EASE_OUT), A.remove())) | |
| #self.showPauseMenu() | |
| self.ship.remove_from_parent() | |
| if resetFlag != None: | |
| self.showStartMenu() | |
| else: | |
| #print(f'self.listOfInactiveFragments: {self.listOfInactiveFragments}') | |
| #print(f'self.listOfActiveFragments: {self.listOfActiveFragments}') | |
| #print(f'len(self.listOfActiveFragments): {len(self.listOfActiveFragments)}') | |
| #print(f'len(self.listOfInactiveFragments): {len(self.listOfInactiveFragments)}') | |
| self.saveProfile(self.playerName) | |
| #print(f'self.projectiles: {self.projectiles}') | |
| self.showGameOverMenu() | |
| #self.paused = True | |
| #console.alert('Your Progress has been Saved', 'Please Close Window To Play Again', hide_cancel_button = True) | |
| #self.new_game() | |
| #self.showStartMenu() | |
| #self.writeToLeaderboard() | |
| ## THIS IS EXECUTED 1 OR MORE TIMES PER UPDATE() DEPENDING ON SPECIFIC UPGRADE LEVEL | |
| ## IT FLINGS PROJECTILES VERTICALLY | |
| ## THE NUMBER OF PROJECTILES DEPENDS ON AN UPGRADE SPECIFIC TO EACH PROJECTILE TYPE | |
| def fireWeapon(self, yOffset=None, customXOffset=None): | |
| listOfColors = ['#F00', '#F0F', '#00F', '#FF0', '#0FF'] | |
| projectileCounter = 2 | |
| xOffset = 0 | |
| if yOffset != None: | |
| yOffset = yOffset | |
| else: | |
| yOffset = 10 | |
| if customXOffset != None: | |
| customXOffset = customXOffset | |
| else: | |
| customXOffset = 0 | |
| if self.activeWeapon == 'laser': | |
| self.numberOfProjectileLevel = self.laserNumberOfLasersLevel | |
| elif self.activeWeapon == 'rocket': | |
| self.numberOfProjectileLevel = 1 | |
| if len(self.listOfProjectiles) > 1: | |
| self.listOfProjectiles.clear() | |
| while self.numberOfProjectileLevel > len(self.listOfProjectiles): | |
| self.listOfProjectiles.append(f'fire{projectileCounter}') | |
| projectileCounter += 1 | |
| self.listOfProjectilesX.append(self.listOfXOffsets.pop(0)) | |
| xInProjectileCounter = len(self.listOfProjectiles) - 1 | |
| if self.activeWeapon == 'rocket': | |
| #playSound = sound.play_effect('game:Woosh_1') | |
| actions = [A.move_by(0, self.size.height * 0.75, 1.25 * self.speed), A.remove()] | |
| #x = Rocket(parent=self) | |
| elif self.activeWeapon == 'laser': | |
| #playSound = sound.play_effect('arcade:Laser_6') | |
| actions = [A.move_by(0, self.size.h/2 + (5*self.laserPowerLevel), 0.25 * self.speed), A.remove()] | |
| #x = SpriteNode('spc:LaserBlue8', parent=self, y_scale = 0.10, x_scale = 0.25) | |
| for x in self.listOfProjectiles: | |
| xOffset = self.listOfProjectilesX[xInProjectileCounter] | |
| if self.activeWeapon == 'rocket': | |
| x = Rocket(parent=self) | |
| elif self.activeWeapon == 'laser': | |
| x = Laser(parent=self) | |
| x.z_position = 1 | |
| x.collisionsLeft = self.laserPowerLevel | |
| #x = SpriteNode('spc:LaserBlue8', parent=self, y_scale = 0.10, x_scale = 0.25) | |
| """ | |
| if self.activeWeapon == 'rocket': | |
| playSound = sound.play_effect('game:Woosh_1') | |
| actions = [A.move_by(0, self.size.height / 2.0, 1.25 * self.speed), playSound, A.remove()] | |
| x = Rocket(parent=self) | |
| #x.scale = 0.025 | |
| """ | |
| """ | |
| if self.activeWeapon == 'rocket': | |
| playSound = sound.play_effect('game:Woosh_1') | |
| actions = [A.move_by(0, self.size.h, 1.50 * self.speed), playSound, A.remove()] | |
| x = Rocket(parent=self) | |
| x.scale = 0.025 | |
| """ | |
| """ | |
| if self.activeWeapon == 'laser': | |
| playSound = sound.play_effect('arcade:Laser_6') | |
| actions = [A.move_by(0, self.size.h/2, 0.75 * self.speed), playSound, A.remove()] | |
| x = SpriteNode('spc:LaserBlue8', parent=self, y_scale = 0.10, x_scale = 0.25) | |
| """ | |
| x.position = self.ship.position + (xOffset + customXOffset, yOffset) | |
| xInProjectileCounter -= 1 | |
| x.run_action(A.sequence(actions)) | |
| self.projectiles.append(x) | |
| #print(f'x.collisionsLeft: {x.collisionsLeft}') | |
| if self.numberOfProjectileLevel >= 5: | |
| x.color = listOfColors[0] | |
| if self.numberOfProjectileLevel >= 10: | |
| x.color = listOfColors[1] | |
| if self.numberOfProjectileLevel >= 15: | |
| x.color = listOfColors[2] | |
| if self.numberOfProjectileLevel >= 20: | |
| x.color = listOfColors[3] | |
| if self.numberOfProjectileLevel >= 25: | |
| x.color = listOfColors[4] | |
| if self.numberOfProjectileLevel >= 30: | |
| x.color = 'white' | |
| """ | |
| if self.activeWeapon == 'rocket': | |
| fragmentsToCreate = round(self.rocketFragmentsLevel) | |
| fragmentMovementSpeed = 10 - (self.rocketFragmentsLevel * 0.2) | |
| if fragmentMovementSpeed <= 1.0: | |
| fragmentMovementSpeed = 1.0 | |
| for i in range(25): | |
| miniRocket = MiniRocket(parent=self) | |
| miniRocket.scale = 0.50 | |
| miniRocket.color = '#0ee0ff' | |
| #miniRocket.alpha = 0.25 | |
| miniRocket.position = self.ship.position[0], self.size.h / 2 | |
| #miniRocket.position = meteor.position + (random.uniform(-30, 30), (-20 + random.uniform(-5, 5))) | |
| fullCircle = random.uniform(0, pi*2) | |
| #upwardAngle = random.uniform(0, pi) | |
| dx, dy = cos(fullCircle) * 1000, sin(fullCircle) * 1000 | |
| #d = 1.25 | |
| #miniRocket.rotation = fullCircle | |
| actions = (A.sequence(A.move_by(dx, dy, fragmentMovementSpeed, TIMING_EASE_IN), A.remove())) | |
| #actions2 = (A.sequence(A.fade_to(1.0, fragmentMovementSpeed, TIMING_EASE_IN), A.remove())) | |
| miniRocket.run_action(A.group((actions))) | |
| #, (actions2))) | |
| self.projectiles.append(miniRocket) | |
| """ | |
| #print(f'xOffset = self.listOfProjectilesX[xInProjectileCounter]') | |
| #print(f'self.listOfProjectilesX: {self.listOfProjectilesX}') | |
| #print(f'xInProjectileCounter: {xInProjectileCounter}') | |
| #print(f'xOffset: {xOffset}') | |
| #print(f'self.listOfXOffsets: {self.listOfXOffsets}') | |
| #print(f'self.listOfProjectilesX: {self.listOfProjectilesX}') | |
| ############################################################################# | |
| ##################### BELOW THIS LINE IS NO LONGER USED ##################### | |
| ################ THIS WAS REPLACED BY THE LOOPING DONE ABOVE ################ | |
| ######################## LEAVE FOR FUTURE REFERENCE ######################### | |
| ############################################################################# | |
| """ | |
| def shoot_laser(self, numberOfLasers): | |
| # 1 | |
| if self.numberOfLasers == 1: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position=self.ship.position | |
| laser1.scale = 0.05 | |
| #laser1.color = 'pink' | |
| laser1.position = self.ship.position + (0, 30) | |
| laser1.z_position = -1 | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| laser1.run_action(A.sequence(actions)) | |
| self.lasers.append(laser1) | |
| sound.play_effect('digital:Laser1', pitch = 0.5) | |
| # 2 | |
| elif self.numberOfLasers == 2: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser2 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (-25, 30)) | |
| laser1.color = 'blue' | |
| laser2.position = (self.ship.position + (25, 30)) | |
| laser2.color = 'blue' | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser2', pitch = 0.5) | |
| sound.play_effect('digital:Laser9', pitch = 0.5) | |
| for x in (laser1, laser2): | |
| #x.parent = self | |
| x.scale = 0.05 | |
| x.z_position = -1 | |
| self.lasers.append(x) | |
| x.run_action(A.sequence(actions)) | |
| # 3 | |
| elif self.numberOfLasers == 3: | |
| laser1 = SpriteNode('laser.jpg', position=self.ship.position - (30, 0), scale = 0.05, color = 'red', parent=self) | |
| laser2 = SpriteNode('laser.jpg', position=self.ship.position + (0, 0), scale = 0.05, color = 'red', parent=self) | |
| laser3 = SpriteNode('laser.jpg', position=self.ship.position + (30, 0), scale = 0.05, color = 'red', parent=self) | |
| laser1.position = (self.ship.position + (0-30, 30)) | |
| laser1.z_position = -1 | |
| laser2.position = (self.ship.position + (0+30, 30)) | |
| laser2.z_position = -1 | |
| laser3.position = (self.ship.position + (0, 30)) | |
| laser3.z_position = -1 | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| laser1.run_action(A.sequence(actions)) | |
| laser2.run_action(A.sequence(actions)) | |
| laser3.run_action(A.sequence(actions)) | |
| sound.play_effect('digital:Laser3') | |
| self.lasers.append(laser1) | |
| self.lasers.append(laser2) | |
| self.lasers.append(laser3) | |
| # 4 | |
| elif self.numberOfLasers == 4: | |
| laser1 = SpriteNode('laser.jpg', position=self.ship.position - (30, 0), scale = 0.05, color = 'blue', parent=self) | |
| laser2 = SpriteNode('laser.jpg', position=self.ship.position - (15, 0), scale = 0.05, color = 'red', parent=self) | |
| laser3 = SpriteNode('laser.jpg', position=self.ship.position + (15, 0), scale = 0.05, color = 'red', parent=self) | |
| laser4 = SpriteNode('laser.jpg', position=self.ship.position + (30, 0), scale = 0.05, color = 'blue', parent=self) | |
| laser1.position = (self.ship.position + (0-30, 30)) | |
| laser1.z_position = -1 | |
| laser2.position = (self.ship.position + (0-15, 30)) | |
| laser2.z_position = -1 | |
| laser3.position = (self.ship.position + (15, 30)) | |
| laser3.z_position = -1 | |
| laser4.position = (self.ship.position + (30, 30)) | |
| laser4.z_position = -1 | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| laser1.run_action(A.sequence(actions)) | |
| laser2.run_action(A.sequence(actions)) | |
| laser3.run_action(A.sequence(actions)) | |
| laser4.run_action(A.sequence(actions)) | |
| sound.play_effect('digital:Laser4') | |
| self.lasers.append(laser1) | |
| self.lasers.append(laser2) | |
| self.lasers.append(laser3) | |
| self.lasers.append(laser4) | |
| # 5 | |
| elif self.numberOfLasers == 5: | |
| laser1 = SpriteNode('laser.jpg', position=self.ship.position - (40, 0), scale = 0.05, color = 'red', parent=self) | |
| laser2 = SpriteNode('laser.jpg', position=self.ship.position - (20, 0), scale = 0.05, color = 'blue', parent=self) | |
| laser3 = SpriteNode('laser.jpg', position=self.ship.position + (0, 0), scale = 0.05, color = 'blue', parent=self) | |
| laser4 = SpriteNode('laser.jpg', position=self.ship.position + (20, 0), scale = 0.05, color = 'blue', parent=self) | |
| laser5 = SpriteNode('laser.jpg', position=self.ship.position + (40, 0), scale = 0.05, color = 'red', parent=self) | |
| laser1.position = (self.ship.position + (0-40, 30)) | |
| laser1.z_position = -1 | |
| laser2.position = (self.ship.position + (0-20, 30)) | |
| laser2.z_position = -1 | |
| laser3.position = (self.ship.position + (0, 30)) | |
| laser3.z_position = -1 | |
| laser4.position = (self.ship.position + (20, 30)) | |
| laser4.z_position = -1 | |
| laser5.position = (self.ship.position + (40, 30)) | |
| laser5.z_position = -1 | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| laser1.run_action(A.sequence(actions)) | |
| laser2.run_action(A.sequence(actions)) | |
| laser3.run_action(A.sequence(actions)) | |
| laser4.run_action(A.sequence(actions)) | |
| laser5.run_action(A.sequence(actions)) | |
| sound.play_effect('digital:Laser5') | |
| self.lasers.append(laser1) | |
| self.lasers.append(laser2) | |
| self.lasers.append(laser3) | |
| self.lasers.append(laser4) | |
| self.lasers.append(laser5) | |
| # 6 | |
| elif self.numberOfLasers == 6: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser2 = SpriteNode('laser.jpg', parent=self) | |
| laser3 = SpriteNode('laser.jpg', parent=self) | |
| laser4 = SpriteNode('laser.jpg', parent=self) | |
| laser5 = SpriteNode('laser.jpg', parent=self) | |
| laser6 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (-30, 30)) | |
| laser1.color = 'blue' | |
| laser2.position = (self.ship.position + (-20, 30)) | |
| laser2.color = 'blue' | |
| laser3.position = (self.ship.position + (-10, 30)) | |
| laser3.color = 'blue' | |
| laser4.position = (self.ship.position + (10, 30)) | |
| laser4.color = 'blue' | |
| laser5.position = (self.ship.position + (20, 30)) | |
| laser5.color = 'blue' | |
| laser6.position = (self.ship.position + (30, 30)) | |
| laser6.color = 'blue' | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser6') | |
| for x in (laser1, laser2, laser3, laser4, laser5, laser6): | |
| #x.parent = self | |
| x.scale = 0.05 | |
| x.z_position = -1 | |
| self.lasers.append(x) | |
| x.run_action(A.sequence(actions)) | |
| # 7 | |
| elif self.numberOfLasers == 7: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser2 = SpriteNode('laser.jpg', parent=self) | |
| laser3 = SpriteNode('laser.jpg', parent=self) | |
| laser4 = SpriteNode('laser.jpg', parent=self) | |
| laser5 = SpriteNode('laser.jpg', parent=self) | |
| laser6 = SpriteNode('laser.jpg', parent=self) | |
| laser7 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (-30, 30)) | |
| laser1.color = 'magenta' | |
| laser2.position = (self.ship.position + (-20, 30)) | |
| laser2.color = 'magenta' | |
| laser3.position = (self.ship.position + (-10, 30)) | |
| laser3.color = 'blue' | |
| laser4.position = (self.ship.position + (0, 30)) | |
| laser4.color = 'blue' | |
| laser5.position = (self.ship.position + (10, 30)) | |
| laser5.color = 'blue' | |
| laser6.position = (self.ship.position + (20, 30)) | |
| laser6.color = 'magenta' | |
| laser7.position = (self.ship.position + (30, 30)) | |
| laser7.color = 'magenta' | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser7') | |
| for x in (laser1, laser2, laser3, laser4, laser5, laser6, laser7): | |
| #x.parent = self | |
| x.scale = 0.05 | |
| x.z_position = -1 | |
| self.lasers.append(x) | |
| x.run_action(A.sequence(actions)) | |
| # 8 | |
| elif self.numberOfLasers == 8: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser2 = SpriteNode('laser.jpg', parent=self) | |
| laser3 = SpriteNode('laser.jpg', parent=self) | |
| laser4 = SpriteNode('laser.jpg', parent=self) | |
| laser5 = SpriteNode('laser.jpg', parent=self) | |
| laser6 = SpriteNode('laser.jpg', parent=self) | |
| laser7 = SpriteNode('laser.jpg', parent=self) | |
| laser8 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (-40, 30)) | |
| laser1.color = 'magenta' | |
| laser2.position = (self.ship.position + (-30, 30)) | |
| laser2.color = 'magenta' | |
| laser3.position = (self.ship.position + (-20, 30)) | |
| laser3.color = 'magenta' | |
| laser4.position = (self.ship.position + (-10, 30)) | |
| laser4.color = 'magenta' | |
| laser5.position = (self.ship.position + (10, 30)) | |
| laser5.color = 'magenta' | |
| laser6.position = (self.ship.position + (20, 30)) | |
| laser6.color = 'magenta' | |
| laser7.position = (self.ship.position + (30, 30)) | |
| laser7.color = 'magenta' | |
| laser8.position = (self.ship.position + (40, 30)) | |
| laser8.color = 'magenta' | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser7') | |
| for x in (laser1, laser2, laser3, laser4, laser5, laser6, laser7, laser8): | |
| #x.parent = self | |
| x.scale = 0.05 | |
| x.z_position = -1 | |
| self.lasers.append(x) | |
| x.run_action(A.sequence(actions)) | |
| # 9 | |
| elif self.numberOfLasers == 9: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser2 = SpriteNode('laser.jpg', parent=self) | |
| laser3 = SpriteNode('laser.jpg', parent=self) | |
| laser4 = SpriteNode('laser.jpg', parent=self) | |
| laser5 = SpriteNode('laser.jpg', parent=self) | |
| laser6 = SpriteNode('laser.jpg', parent=self) | |
| laser7 = SpriteNode('laser.jpg', parent=self) | |
| laser8 = SpriteNode('laser.jpg', parent=self) | |
| laser9 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (-40, 30)) | |
| laser1.color = 'cyan' | |
| laser2.position = (self.ship.position + (-30, 30)) | |
| laser2.color = 'cyan' | |
| laser3.position = (self.ship.position + (-20, 30)) | |
| laser3.color = 'magenta' | |
| laser4.position = (self.ship.position + (-10, 30)) | |
| laser4.color = 'magenta' | |
| laser5.position = (self.ship.position + (0, 30)) | |
| laser5.color = 'magenta' | |
| laser6.position = (self.ship.position + (10, 30)) | |
| laser6.color = 'magenta' | |
| laser7.position = (self.ship.position + (20, 30)) | |
| laser7.color = 'magenta' | |
| laser8.position = (self.ship.position + (30, 30)) | |
| laser8.color = 'cyan' | |
| laser9.position = (self.ship.position + (40, 30)) | |
| laser9.color = 'cyan' | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser8') | |
| for x in (laser1, laser2, laser3, laser4, laser5, laser6, laser7, laser8, laser9): | |
| #x.parent = self | |
| x.scale = 0.05 | |
| x.z_position = -1 | |
| self.lasers.append(x) | |
| x.run_action(A.sequence(actions)) | |
| # 10 | |
| elif self.numberOfLasers == 10: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser2 = SpriteNode('laser.jpg', parent=self) | |
| laser3 = SpriteNode('laser.jpg', parent=self) | |
| laser4 = SpriteNode('laser.jpg', parent=self) | |
| laser5 = SpriteNode('laser.jpg', parent=self) | |
| laser6 = SpriteNode('laser.jpg', parent=self) | |
| laser7 = SpriteNode('laser.jpg', parent=self) | |
| laser8 = SpriteNode('laser.jpg', parent=self) | |
| laser9 = SpriteNode('laser.jpg', parent=self) | |
| laser10 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (-50, 30)) | |
| laser1.color = 'cyan' | |
| laser2.position = (self.ship.position + (-40, 30)) | |
| laser2.color = 'cyan' | |
| laser3.position = (self.ship.position + (-30, 30)) | |
| laser3.color = 'cyan' | |
| laser4.position = (self.ship.position + (-20, 30)) | |
| laser4.color = 'cyan' | |
| laser5.position = (self.ship.position + (-10, 30)) | |
| laser5.color = 'cyan' | |
| laser6.position = (self.ship.position + (10, 30)) | |
| laser6.color = 'cyan' | |
| laser7.position = (self.ship.position + (20, 30)) | |
| laser7.color = 'cyan' | |
| laser8.position = (self.ship.position + (30, 30)) | |
| laser8.color = 'cyan' | |
| laser9.position = (self.ship.position + (40, 30)) | |
| laser9.color = 'cyan' | |
| laser10.position = (self.ship.position + (50, 30)) | |
| laser10.color = 'cyan' | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser9') | |
| for x in (laser1, laser2, laser3, laser4, laser5, laser6, laser7, laser8, laser9, laser10): | |
| #x.parent = self | |
| x.scale = 0.05 | |
| x.z_position = -1 | |
| self.lasers.append(x) | |
| x.run_action(A.sequence(actions)) | |
| # 11 | |
| elif self.numberOfLasers == 11: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (0, 30)) | |
| laser1.color = 'red' | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser1') | |
| sound.play_effect('digital:Laser9') | |
| laser1.scale = 0.1 | |
| laser1.z_position = -1 | |
| self.lasers.append(laser1) | |
| laser1.run_action(A.sequence(actions)) | |
| # 12 | |
| elif self.numberOfLasers == 12: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser2 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (-25, 30)) | |
| laser1.color = 'blue' | |
| laser2.position = (self.ship.position + (25, 30)) | |
| laser2.color = 'blue' | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser2', pitch = 1.25) | |
| sound.play_effect('digital:Laser9', pitch = 1.25) | |
| for x in (laser1, laser2): | |
| #x.parent = self | |
| x.scale = 0.075 | |
| x.z_position = -1 | |
| self.lasers.append(x) | |
| x.run_action(A.sequence(actions)) | |
| # 13 | |
| elif self.numberOfLasers == 13: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser2 = SpriteNode('laser.jpg', parent=self) | |
| laser3 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (-25, 30)) | |
| laser1.color = 'blue' | |
| laser2.position = (self.ship.position + (0, 30)) | |
| laser2.color = 'blue' | |
| laser3.position = (self.ship.position + (25, 30)) | |
| laser3.color = 'blue' | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser3', pitch = 1.25) | |
| sound.play_effect('digital:Laser9', pitch = 1.25) | |
| for x in (laser1, laser2, laser3): | |
| #x.parent = self | |
| x.scale = 0.075 | |
| x.z_position = -1 | |
| self.lasers.append(x) | |
| x.run_action(A.sequence(actions)) | |
| # 14 | |
| elif self.numberOfLasers == 14: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser2 = SpriteNode('laser.jpg', parent=self) | |
| laser3 = SpriteNode('laser.jpg', parent=self) | |
| laser4 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (-40, 30)) | |
| laser1.color = 'blue' | |
| laser2.position = (self.ship.position + (-20, 30)) | |
| laser2.color = 'blue' | |
| laser3.position = (self.ship.position + (20, 30)) | |
| laser3.color = 'blue' | |
| laser4.position = (self.ship.position + (40, 30)) | |
| laser4.color = 'blue' | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser4', pitch = 1.25) | |
| sound.play_effect('digital:Laser9', pitch = 1.25) | |
| for x in (laser1, laser2, laser3, laser4): | |
| #x.parent = self | |
| x.scale = 0.075 | |
| x.z_position = -1 | |
| self.lasers.append(x) | |
| x.run_action(A.sequence(actions)) | |
| # 15 | |
| elif self.numberOfLasers == 15: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser2 = SpriteNode('laser.jpg', parent=self) | |
| laser3 = SpriteNode('laser.jpg', parent=self) | |
| laser4 = SpriteNode('laser.jpg', parent=self) | |
| laser5 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (-40, 30)) | |
| laser1.color = 'blue' | |
| laser2.position = (self.ship.position + (-20, 30)) | |
| laser2.color = 'blue' | |
| laser3.position = (self.ship.position + (0, 30)) | |
| laser3.color = 'blue' | |
| laser4.position = (self.ship.position + (-20, 30)) | |
| laser4.color = 'blue' | |
| laser5.position = (self.ship.position + (-40, 30)) | |
| laser5.color = 'blue' | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser5', pitch = 1.25) | |
| sound.play_effect('digital:Laser9', pitch = 1.25) | |
| for x in (laser1, laser2, laser3, laser4, laser5): | |
| #x.parent = self | |
| x.scale = 0.075 | |
| x.z_position = -1 | |
| self.lasers.append(x) | |
| x.run_action(A.sequence(actions)) | |
| # 16 | |
| elif self.numberOfLasers == 16: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser2 = SpriteNode('laser.jpg', parent=self) | |
| laser3 = SpriteNode('laser.jpg', parent=self) | |
| laser4 = SpriteNode('laser.jpg', parent=self) | |
| laser5 = SpriteNode('laser.jpg', parent=self) | |
| laser6 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (-60, 30)) | |
| laser1.color = 'blue' | |
| laser2.position = (self.ship.position + (-40, 30)) | |
| laser2.color = 'blue' | |
| laser3.position = (self.ship.position + (-20, 30)) | |
| laser3.color = 'blue' | |
| laser4.position = (self.ship.position + (20, 30)) | |
| laser4.color = 'blue' | |
| laser5.position = (self.ship.position + (40, 30)) | |
| laser5.color = 'blue' | |
| laser6.position = (self.ship.position + (60, 30)) | |
| laser6.color = 'blue' | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser6', pitch = 1.25) | |
| sound.play_effect('digital:Laser9', pitch = 1.25) | |
| for x in (laser1, laser2, laser3, laser4, laser5, laser6): | |
| #x.parent = self | |
| x.scale = 0.075 | |
| x.z_position = -1 | |
| self.lasers.append(x) | |
| x.run_action(A.sequence(actions)) | |
| # 17 | |
| elif self.numberOfLasers == 17: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser2 = SpriteNode('laser.jpg', parent=self) | |
| laser3 = SpriteNode('laser.jpg', parent=self) | |
| laser4 = SpriteNode('laser.jpg', parent=self) | |
| laser5 = SpriteNode('laser.jpg', parent=self) | |
| laser6 = SpriteNode('laser.jpg', parent=self) | |
| laser7 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (-60, 30)) | |
| laser1.color = 'blue' | |
| laser2.position = (self.ship.position + (-40, 30)) | |
| laser2.color = 'blue' | |
| laser3.position = (self.ship.position + (-20, 30)) | |
| laser3.color = 'blue' | |
| laser4.position = (self.ship.position + (0, 30)) | |
| laser4.color = 'blue' | |
| laser5.position = (self.ship.position + (20, 30)) | |
| laser5.color = 'blue' | |
| laser6.position = (self.ship.position + (40, 30)) | |
| laser6.color = 'blue' | |
| laser7.position = (self.ship.position + (60, 30)) | |
| laser7.color = 'blue' | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser7', pitch = 1.25) | |
| sound.play_effect('digital:Laser9', pitch = 1.25) | |
| for x in (laser1, laser2, laser3, laser4, laser5, laser6, laser7): | |
| #x.parent = self | |
| x.scale = 0.075 | |
| x.z_position = -1 | |
| self.lasers.append(x) | |
| x.run_action(A.sequence(actions)) | |
| # 18 | |
| elif self.numberOfLasers == 18: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser2 = SpriteNode('laser.jpg', parent=self) | |
| laser3 = SpriteNode('laser.jpg', parent=self) | |
| laser4 = SpriteNode('laser.jpg', parent=self) | |
| laser5 = SpriteNode('laser.jpg', parent=self) | |
| laser6 = SpriteNode('laser.jpg', parent=self) | |
| laser7 = SpriteNode('laser.jpg', parent=self) | |
| laser8 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (-60, 30)) | |
| laser1.color = 'blue' | |
| laser2.position = (self.ship.position + (-40, 30)) | |
| laser2.color = 'blue' | |
| laser3.position = (self.ship.position + (-20, 30)) | |
| laser3.color = 'blue' | |
| laser4.position = (self.ship.position + (-10, 30)) | |
| laser4.color = 'blue' | |
| laser5.position = (self.ship.position + (10, 30)) | |
| laser5.color = 'blue' | |
| laser6.position = (self.ship.position + (20, 30)) | |
| laser6.color = 'blue' | |
| laser7.position = (self.ship.position + (40, 30)) | |
| laser7.color = 'blue' | |
| laser8.position = (self.ship.position + (60, 30)) | |
| laser8.color = 'blue' | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser8', pitch = 1.25) | |
| sound.play_effect('digital:Laser9', pitch = 1.25) | |
| for x in (laser1, laser2, laser3, laser4, laser5, laser6, laser7, laser8): | |
| #x.parent = self | |
| x.scale = 0.075 | |
| x.z_position = -1 | |
| self.lasers.append(x) | |
| x.run_action(A.sequence(actions)) | |
| # 19 | |
| elif self.numberOfLasers == 19: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser2 = SpriteNode('laser.jpg', parent=self) | |
| laser3 = SpriteNode('laser.jpg', parent=self) | |
| laser4 = SpriteNode('laser.jpg', parent=self) | |
| laser5 = SpriteNode('laser.jpg', parent=self) | |
| laser6 = SpriteNode('laser.jpg', parent=self) | |
| laser7 = SpriteNode('laser.jpg', parent=self) | |
| laser8 = SpriteNode('laser.jpg', parent=self) | |
| laser9 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (-60, 30)) | |
| laser1.color = 'blue' | |
| laser2.position = (self.ship.position + (-40, 30)) | |
| laser2.color = 'blue' | |
| laser3.position = (self.ship.position + (-20, 30)) | |
| laser3.color = 'blue' | |
| laser4.position = (self.ship.position + (-10, 30)) | |
| laser4.color = 'blue' | |
| laser5.position = (self.ship.position + (0, 30)) | |
| laser5.color = 'blue' | |
| laser6.position = (self.ship.position + (10, 30)) | |
| laser6.color = 'blue' | |
| laser7.position = (self.ship.position + (20, 30)) | |
| laser7.color = 'blue' | |
| laser8.position = (self.ship.position + (40, 30)) | |
| laser8.color = 'blue' | |
| laser9.position = (self.ship.position + (60, 30)) | |
| laser9.color = 'blue' | |
| actions = [A.move_by(0, self.size.h, 1.0 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser9', pitch = 1.25) | |
| sound.play_effect('digital:Laser9', pitch = 1.25) | |
| for x in (laser1, laser2, laser3, laser4, laser5, laser6, laser7, laser8, laser9): | |
| #x.parent = self | |
| x.scale = 0.075 | |
| x.z_position = -1 | |
| self.lasers.append(x) | |
| x.run_action(A.sequence(actions)) | |
| # 20 | |
| elif self.numberOfLasers == 20: | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser2 = SpriteNode('laser.jpg', parent=self) | |
| laser3 = SpriteNode('laser.jpg', parent=self) | |
| laser4 = SpriteNode('laser.jpg', parent=self) | |
| laser5 = SpriteNode('laser.jpg', parent=self) | |
| laser6 = SpriteNode('laser.jpg', parent=self) | |
| laser7 = SpriteNode('laser.jpg', parent=self) | |
| laser8 = SpriteNode('laser.jpg', parent=self) | |
| laser9 = SpriteNode('laser.jpg', parent=self) | |
| laser10 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (-50, 30)) | |
| laser1.color = 'cyan' | |
| laser2.position = (self.ship.position + (-40, 30)) | |
| laser2.color = 'cyan' | |
| laser3.position = (self.ship.position + (-30, 30)) | |
| laser3.color = 'cyan' | |
| laser4.position = (self.ship.position + (-20, 30)) | |
| laser4.color = 'cyan' | |
| laser5.position = (self.ship.position + (-10, 30)) | |
| laser5.color = 'cyan' | |
| laser6.position = (self.ship.position + (10, 30)) | |
| laser6.color = 'cyan' | |
| laser7.position = (self.ship.position + (20, 30)) | |
| laser7.color = 'cyan' | |
| laser8.position = (self.ship.position + (30, 30)) | |
| laser8.color = 'cyan' | |
| laser9.position = (self.ship.position + (40, 30)) | |
| laser9.color = 'cyan' | |
| laser10.position = (self.ship.position + (50, 30)) | |
| laser10.color = 'cyan' | |
| actions = [A.move_by(0, self.size.h, 1.3 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser9') | |
| for x in (laser1, laser2, laser3, laser4, laser5, laser6, laser7, laser8, laser9, laser10): | |
| #x.parent = self | |
| x.scale = 0.075 | |
| x.z_position = -1 | |
| self.lasers.append(x) | |
| x.run_action(A.sequence(actions)) | |
| elif self.numberOfLasers == 21: | |
| #self.defaultweaponTimer = 5 | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (0, 30)) | |
| laser1.color = 'red' | |
| actions = [A.move_by(0, self.size.h, 0.9 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser1', pitch = 1.5) | |
| sound.play_effect('digital:Laser1', pitch = 1.5) | |
| laser1.scale = 0.1 | |
| laser1.z_position = -1 | |
| self.lasers.append(laser1) | |
| laser1.run_action(A.sequence(actions)) | |
| elif self.numberOfLasers >= 22: | |
| #self.defaultweaponTimer = 8 | |
| laser1 = SpriteNode('laser.jpg', parent=self) | |
| laser1.position = (self.ship.position + (0, 30)) | |
| laser1.color = 'red' | |
| actions = [A.move_by(0, self.size.h, 0.75 * self.speed), A.remove()] | |
| sound.play_effect('digital:Laser1', pitch = 2.0) | |
| sound.play_effect('digital:Laser1', pitch = 2.0) | |
| laser1.scale = 0.1 | |
| laser1.z_position = -1 | |
| self.lasers.append(laser1) | |
| laser1.run_action(A.sequence(actions)) | |
| """ | |
| run(MyScene(), PORTRAIT) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment