def run_game(): # Initialize game and create a screen object. pygame.init() settings = Settings() screen = pygame.display.set_mode((settings.screen_width, settings.screen_height)) pygame.display.set_caption("Domesday") # Make the play button. play_button = PlayButton(screen, "PLAY") # Create an instance to store game statistics and create scoreboard. stats = GameStats(settings) sb = Scoreboard(settings, screen, stats) # Make a spaceship, a group of bullets and a group of aliens. spaceship = SpaceShip(settings, screen) bullets = Group() aliens = Group() # Create the fleet of aliens. gf = GameFunctions() gf.create_fleet(settings, screen, spaceship, aliens) # Start the main loop for the game. while True: gf.check_events(settings, screen, stats, sb, play_button, spaceship, aliens, bullets) if stats.game_active: spaceship.update() # bullets.update() -> to-do old version of updating bullets. # Get rid of bullets that have disappeared. gf.update_bullets(settings, screen, stats, sb, spaceship, aliens, bullets) gf.update_aliens(settings, screen, stats, sb, spaceship, aliens, bullets) gf.update_screen(settings, screen, stats, sb, spaceship, aliens, bullets, play_button)
def __init__(self, space_game, **kwargs): kwargs['orientation'] = 0 SpaceShip.__init__(self, space_game, **kwargs) self.score = 0 self.gun_fire_interval = 0.1 if self._keyboard == None and platform not in ("android", "ios"): self._keyboard = Window.request_keyboard(self._keyboard_closed, self) self._keyboard.bind(on_key_down=self._on_key_down) self._keyboard.bind(on_key_up=self._on_key_up) self.gun = RepeaterGun(space_game=self.space_game) self.add_widget(self.gun) self.gun.center_x = self.center_x self.gun.center_y = self.center_y self.boom = load_sound('sounds/boom.ogg', volume=FX_VOLUME) # Add touch events layer self.player_speed = Vector(0, 0) self.bullet_rate = 0.0 self.player_motion = None self.bullet_fire = None touch_layer = FloatLayout(pos_hint=(0, 0), size_hint=(1., 1.)) touch_layer.bind( on_touch_down=self.on_touch_down, on_touch_move=self.on_touch_move, on_touch_up=self.on_touch_up, ) self.add_widget(touch_layer) self._update_event = Clock.schedule_interval(self.update, FPS)
def _create_spaceship(self, spaceship_number, row_number): """Create an spaceship and place it in the row.""" spaceship = SpaceShip(self) spaceship_width, spaceship_height = spaceship.rect.size spaceship.x = spaceship_width + 2 * spaceship_width * spaceship_number spaceship.rect.x = spaceship.x spaceship.rect.y = 3.5 * spaceship.rect.height + 2 * spaceship.rect.height * row_number self.spaceships.add(spaceship)
def prep_spaceships(self): """Show how many ships are left.""" self.spaceships = Group() for spaceship_number in range(self.stats.spaceships_left): spaceship = SpaceShip(self.settings, self.screen) spaceship.rect.x = 10 + spaceship_number * spaceship.rect.width spaceship.rect.y = 10 self.spaceships.add(spaceship)
def create_player(self): self.players.append( SpaceShip(x=10, y=10, w=self.player_img.get_width(), h=self.player_img.get_height(), v=10, win=self.win, img=self.player_img, proj_img=self.proj_img))
def create_enemy(self): self.enemies.append( SpaceShip(x=randint(0, config.WIN_SIZE[0] - 50), y=randint(0, config.WIN_SIZE[1] / 2), w=self.enemy_img.get_width(), h=self.enemy_img.get_height(), v=randint(3, 10), win=self.win, img=self.enemy_img, proj_img=self.proj_img))
def __init__ (self): self.screensize = self.assembleImages() self.screen = pygame.display.set_mode(self.screensize, 0, 32) self.volume = 0.5 self.player = SpaceShip(self.screensize) HealthBar(self.player, self.screen, True) self.clock = pygame.time.Clock() self.level = 1 self.boss = None self.font = pygame.font.Font("GearsOfPeace.ttf", 12) self.med_font = pygame.font.Font("GearsOfPeace.ttf", 30) self.big_font = pygame.font.Font("GearsOfPeace.ttf", 50) self.notify = {"msg": None, "timer": [60*3, 0]} self.spawner = {"max_enemies": 2, "enemy_killed": 0, "spawn_delay": (60 * 2.2), "spawn_counter": 0, "boss_out": False,} self.running = True
def _create_fleet(self): """Create the fleet of spaceships.""" # Create an spaceship and find the number of spaceships in a row. # Spacing between each spaceship is equal to one spaceship width. spaceship = SpaceShip(self) spaceship_width, spaceship_height = spaceship.rect.size # Calculate the number of spaceships in a row # (2 * spaceship_width) creates margins on either side of a screen available_space_x = self.settings.screen_width - (2 * spaceship_width) number_spaceships_x = available_space_x // (2 * spaceship_width) # Determine the number of rows of spaceships that fit on the screen. rocket_height = self.rocket.rect.height available_space_y = (self.settings.screen_height - (18 * spaceship_height) - rocket_height) number_rows = available_space_y // (2 * spaceship_height) # Create the full fleet of spaceships. for row_number in range(number_rows): for spaceship_number in range(number_spaceships_x): self._create_spaceship(spaceship_number, row_number)
def __init__(self, space_game, **kwargs): SpaceShip.__init__(self, space_game) Actor.__init__(self, **kwargs) self.min_y = dp(200) self.boom = load_sound("sounds/boom.ogg")
def main(): # Conncets to the server n = Network() print("Connected to the server.") bullets = [] game = n.connect() # Configures the window win = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("SpaceShip Game") # Creates the spaceships at the beginning if n.id == 0: e_id = 1 spaceship = SpaceShip(0, 0) enemy_spaceship = SpaceShip(1, 1) else: e_id = 0 spaceship = SpaceShip(0, 1) enemy_spaceship = SpaceShip(1, 0) clock = pygame.time.Clock() # Starts the game loop run = True lost = False while run: clock.tick(500) for event in pygame.event.get(): if event.type == pygame.QUIT: quit() if game.finished(): font = pygame.font.SysFont("timesnewroman", 100) if game.lost[n.id]: text = font.render("You lost!", 1, (255, 255, 255)) else: text = font.render("You won!", 1, (255, 255, 255)) x_text = WIDTH / 2 - text.get_width() / 2 y_text = HEIGHT / 2 - text.get_height() / 2 win.blit(text, (x_text, y_text)) pygame.display.update() sleep(3) quit() elif game.isready(): # Updates the spaceship if game.spaceships[n.id] is not None: spaceship = game.spaceships[n.id] if game.spaceships[e_id] is not None: enemy_spaceship.x = (WIDTH - game.spaceships[e_id].x - enemy_spaceship.width) enemy_spaceship.hp = game.spaceships[e_id].hp #Updates the bullets bullets = game.bullets for bullet in bullets: if bullet.id == n.id: bullet.x = (1200 - bullet.x - 10) bullet.y = (900 - bullet.y - 30) # Checks for moves spaceship.move() spaceship.shoot(bullets, n) # Draws things win.fill((0, 0, 0)) spaceship.draw(win) for bullet in bullets: bullet.draw(win, n.id) enemy_spaceship.draw(win) #Displays Hp font = pygame.font.SysFont("timesnewroman", 50) text = font.render(f"HP: {spaceship.hp}", 1, (255, 255, 255)) x_text = WIDTH * 0.02 y_text = HEIGHT * 0.02 win.blit(text, (x_text, y_text)) pygame.display.update() # Sends the spaceship to the server game = n.communicate(spaceship) if spaceship.hp <= 0: game = n.communicate("Lost") else: font = pygame.font.SysFont("timesnewroman", 100) text = font.render("Waiting for player...", 1, (255, 255, 255)) x_text = WIDTH / 2 - text.get_width() / 2 y_text = HEIGHT / 2 - text.get_height() / 2 win.blit(text, (x_text, y_text)) pygame.display.update() game = n.communicate("Waiting")
from constants import * from spaceship import SpaceShip from player import Player from shot import Shot from enemies import Enemies WIDTH=800 HEIGHT=600 TITLE="Space shooter game" ICON="spacecrafticon.png" scroll_speed = 2 player = Player() spacecraft = SpaceShip("spacecraft", (400,480)) spacecraft.set_speed(4) enemies = Enemies((WIDTH,HEIGHT), "enemies.dat") # List to track shots shots = [] # shot last fired timestamp - to ensure don't fire too many shots shot_last_fired = 0 # time in seconds time_between_shots = 0.5 scroll_position = 0 # spacecraft hit points # positions relative to spacecraft centre which classes as a collide
class Game: def __init__ (self): self.screensize = self.assembleImages() self.screen = pygame.display.set_mode(self.screensize, 0, 32) self.volume = 0.5 self.player = SpaceShip(self.screensize) HealthBar(self.player, self.screen, True) self.clock = pygame.time.Clock() self.level = 1 self.boss = None self.font = pygame.font.Font("GearsOfPeace.ttf", 12) self.med_font = pygame.font.Font("GearsOfPeace.ttf", 30) self.big_font = pygame.font.Font("GearsOfPeace.ttf", 50) self.notify = {"msg": None, "timer": [60*3, 0]} self.spawner = {"max_enemies": 2, "enemy_killed": 0, "spawn_delay": (60 * 2.2), "spawn_counter": 0, "boss_out": False,} self.running = True def openingScene (self): to_play = [sfx.AI_greeting, sfx.AI_mission] running = True for index, sound in enumerate(to_play): sound.play() while running: self.time_passed = self.clock.tick(60)/1000.0 if not pygame.mixer.get_busy(): break for event in pygame.event.get(): if event.type == QUIT: running = False self.running = False return if event.type == KEYDOWN and event.key == K_ESCAPE: running = False sound.stop() return self.manageSprite(Background.container) text = "SPACEBAR = FIRE ZE LASERS" surface = self.font.render(text, True, (255,255,255)) self.screen.blit(surface, (self.screensize[0]/2-120, 250)) text = "M = FIRE A MISSILE" surface = self.font.render(text, True, (255,255,255)) self.screen.blit(surface, (self.screensize[0]/2-120, 280)) text = "N = LAUNCH NUCLEAR WARHEAD" surface = self.font.render(text, True, (255,255,255)) self.screen.blit(surface, (self.screensize[0]/2-120, 310)) text = "E = EMP (Scorpion Upgrade Line)" surface = self.font.render(text, True, (255,255,255)) self.screen.blit(surface, (self.screensize[0]/2-120, 340)) text = "R = Repair (Collect Wrenches)" surface = self.font.render(text, True, (255,255,255)) self.screen.blit(surface, (self.screensize[0]/2-120, 370)) text = "PRESS Esc TO SKIP INTRO" surface = self.med_font.render(text, True, (255,255,255)) self.screen.blit(surface, (self.screensize[0]/2-250, 450)) self.manageSprite(self.player.container) pygame.display.flip() def assembleImages(self): image_path = os.path.join("backgrounds", choice(BACKGROUNDS)) backgroundTL = ScrollingBackground(image_path) backgroundBL = ScrollingBackground(image_path) backgroundTL.rect.bottom = backgroundBL.rect.top width = backgroundTL.rect.width height = backgroundTL.rect.height global screenrect screenrect = Rect(0,0,backgroundTL.rect.width,backgroundTL.rect.height) display = pygame.display.Info() if display.current_h < 1000: height = display.current_h return (width, height) def manageSprite (self, container): container.update(self.time_passed) container.draw(self.screen) def spawnEnemies (self): spwn = self.spawner if spwn["spawn_counter"] >= spwn["spawn_delay"]: if len(Enemy.container) < spwn["max_enemies"]: if self.level -3 in range(3): enemy = choice([Drone, Warship])(self.screensize, self.player, self.level) elif self.level > 6: enemy = choice([Drone, Warship, Bomber])(self.screensize, self.player, self.level) else: enemy = Drone(self.screensize, self.player, self.level) if self.level > 10: enemy.armor["T"] *= 2 enemy.armor["M"] *= 2 HealthBar(enemy, self.screen) spwn["spawn_counter"] = 0 else: if not spwn["boss_out"]: spwn["spawn_counter"] += 1 if spwn["enemy_killed"] >= spwn["max_enemies"]+( 5+self.level*3) and (spwn["boss_out"] == False): sfx.stab.play() self.boss = Boss(self.screensize, self.player, self.level) self.boss.rect.midbottom = (self.screensize[0]/2, 0) spwn["enemy_killed"] = 0 spwn["boss_out"] = True spwn["max_enemies"] += 1 HealthBar(self.boss, self.screen) def gameOver (self): # Do all the game over stuff here... self.running = False # True for debugging purposes - set to False to end game def playerDamage (self, enemy, projectiles): for proj in projectiles: proj.explode() if enemy.decreaseHealth(proj.damage) <= 0: if type(enemy).__name__ == "Guard": self.boss.guards_out -= 1 self.player.exp += enemy.armor["M"] enemy.die(sfx.muffled_explosion) return self.spawner["enemy_killed"] += 1 if type(enemy).__name__ == "Drone": self.player.exp += enemy.armor["M"]+1 else: self.player.exp += enemy.armor["M"] chance = randint(1,13) if chance in [12, 13]: new_powerup = Wrench() new_powerup.rect.center = enemy.rect.center PowerUpGlow(new_powerup) elif chance == 2: new_powerup = Bullet() new_powerup.rect.center = enemy.rect.center PowerUpGlow(new_powerup) elif chance == 3: new_powerup = MissileReload() new_powerup.rect.center = enemy.rect.center PowerUpGlow(new_powerup) elif chance == 4: new_powerup = GunUpgrade() new_powerup.rect.center = enemy.rect.center PowerUpGlow(new_powerup) enemy.die(sfx.muffled_explosion) break def collisionCheck (self, collide): # Check if the player has shot an enemy (non boss) kpow = collide(Enemy.container, Fireball.container, False, True) if kpow: for enemy in kpow: self.playerDamage(enemy, kpow[enemy]) # Check if an enemy has shot the player boom = collide(EnemyFireball.container, self.player.container, True, False) if boom: if self.player.decreaseHealth(1) <= 0: self.player.die() # Check if the player crashed into an enemy bang = collide(Enemy.container, self.player.container, False, False) if bang: for enemy in bang: e_armor = enemy.armor["T"] if type(enemy).__name__ == "Guard": self.boss.guards_out -= 1 enemy.die(sfx.muffled_explosion) if self.player.decreaseHealth(e_armor) <= 0: self.player.die() # Check if the player has shot a boss bash = collide(Fireball.container, Boss.container, True, False) if bash: for projectile in bash: if not self.boss.invincible: if self.boss.decreaseHealth(projectile.damage) <= 0: self.spawner["boss_out"] = False self.player.exp += self.boss.armor["M"] self.level += 1 self.boss.die(sfx.muffled_explosion) self.boss = None self.player.ranks["remaining"] += 1 text = "New Upgrades! (Press ESC)" self.notify["msg"] = self.med_font.render(text, True, (255,255,255)) break projectile.explode() # Check if the player has grabbed a PowerUp ding = collide(PowerUp.container, self.player.container, True, False) if ding: for power in ding: power.effect(self.player) def showStats (self): fr = self.font.render if self.player.lives < 0: text = "Game Over..." surface = self.big_font.render(text, True, (255,255,255)) self.screen.blit(surface, (200, self.screensize[1]/2-75)) text = "EXP: %s -- LEVEL: %s" %(game.player.exp, game.level) surface = fr(text, True, (255,255,255)) self.screen.blit(surface, (350, self.screensize[1]/2)) else: text = "Level: %s" %(game.level) surface = fr(text, True, (255,255,255)) self.screen.blit(surface, (10, 10)) text = "EXP: %s" %(int(round(game.player.exp))) surface = fr(text, True, (255,255,255)) self.screen.blit(surface, (10, 30)) text = "Escape Pods: %s" %(game.player.lives) surface = fr(text, True, (255,255,255)) self.screen.blit(surface, (10, 50)) text = game.player.getHitPercentage() surface = fr(text, True, (255,255,255)) self.screen.blit(surface, (10, 70)) text = "Armor: %s/%s" % (game.player.armor["T"], game.player.armor["M"]) surface = fr(text, True, (255,255,255)) self.screen.blit(surface, (10, self.screensize[1]-50)) text = "Missiles: %s" %(self.player.missiles) surface = fr(text, True, (255,255,255)) self.screen.blit(surface, (self.screensize[0]-180, 10)) text = "Repair Drones: %s" %(self.player.wrenches) surface = fr(text, True, (255,255,255)) self.screen.blit(surface, (self.screensize[0]-180, 30)) text = "Nukes: %s" %(game.player.nukes) surface = fr(text, True, (255,255,255)) self.screen.blit(surface, (self.screensize[0]-180, 50)) if self.player.missile: text = "NEXT MISSILE: 0:%s" %(round(game.player.missile_timer[1],1)) surface = fr(text, True, (255,255,255)) self.screen.blit(surface, (self.screensize[0]-180, 70)) if self.player.emp: text = "NEXT EMP: 0:%s" %(round(game.player.emp["timer"][1],1)) surface = fr(text, True, (255,255,255)) self.screen.blit(surface, (self.screensize[0]-180, 90)) def displayNotifications (self): if not self.notify["msg"]: return if self.notify["timer"][1] >= self.notify["timer"][0]: self.notify["msg"] = None self.notify["timer"][1] = 0 else: self.screen.blit(self.notify["msg"], (275, int(self.screensize[1]/3-50))) self.notify["timer"][1] += 1 def eventCheck(self, event): if event.type == QUIT: self.running = False if event.type == KEYDOWN: if event.key == K_p or event.key == K_ESCAPE: # Pause the game and open the menu self.menu = MainMenu(self) self.menu.run() if event.key == K_SPACE: self.player.shooting = True if event.key == K_UP: self.player.moving.add("forward") if event.key == K_DOWN: self.player.moving.add("back") if event.key == K_RIGHT: self.player.moving.add("right") if event.key == K_LEFT: self.player.moving.add("left") if event.key == K_e: if self.player.emp: self.player.triggerEmp(self.screen, Enemy.container, self.boss) if event.key == K_m: self.player.missile(Enemy.container, self.boss) if event.key == K_n: self.player.nuke(self.screen, Enemy.container, self.boss) if event.key == K_r: self.player.repair() if event.key == K_EQUALS: self.volume += 0.1 if self.volume > 1: self.volume = 1.0 pygame.mixer.music.set_volume(self.volume) if event.key == K_MINUS: self.volume -= 0.1 if self.volume < 0: self.volume = 0.0 pygame.mixer.music.set_volume(self.volume) if event.type == KEYUP: if event.key == K_SPACE: self.player.shooting = False if event.key == K_UP: self.player.moving.remove("forward") if event.key == K_DOWN: self.player.moving.remove("back") if event.key == K_RIGHT: self.player.moving.remove("right") if event.key == K_LEFT: self.player.moving.remove("left") def run (self): #self.notify["msg"] = self.med_font.render("Pew Pew Space", True, (255,255,255)) self.openingScene() sfx.play_music() collide = pygame.sprite.groupcollide while self.running: self.time_passed = self.clock.tick(60)/1000.0 pygame.display.set_caption("[FPS -- %s]" %(int(self.clock.get_fps()))) for event in pygame.event.get(): self.eventCheck(event) self.spawnEnemies() self.manageSprite(Background.container) # Background self.showStats() # Stats self.displayNotifications() # Notifications self.manageSprite(Passive.container) # Passive sprites self.manageSprite(Animation.container) # Animations self.manageSprite(Fireball.container) # Player's bullets self.manageSprite(Missile.container) # Player missiles self.manageSprite(Boss.container) # Boss self.manageSprite(EnemyFireball.container) # Enemy's bullets self.manageSprite(Enemy.container) # Enemies self.manageSprite(HealthBar.container) # Healthbars self.manageSprite(PowerUp.container) # PowerUps self.manageSprite(self.player.container) # Player self.collisionCheck(collide) # Collisions pygame.display.flip() # Update dislplay
def main(): game = SpaceShip() game.setup() arcade.run()
from turtle import Screen from time import sleep from spaceship import SpaceShip from aliens import Invaders from scoreboard import ScoreBoard # setting up the game screen game_screen = Screen() game_screen.setup(width=600, height=650) game_screen.bgcolor("black") game_screen.title("Space Invaders") game_screen.tracer(0) game_screen.listen() # setup and display each game component space_ship = SpaceShip() aliens = Invaders() scores = ScoreBoard() game_on = True loops = 0 def end_game(): """A function that ends the game abruptly""" global game_on game_on = False # move the spaceship left and right on key presses
class Game(): def __init__(self,root,canvas,settings={},cursor_scroll=False): # tkinter properties that are passed down self.root = root self.canvas = canvas # 3d graphics engine self.engine = Engine(self.canvas,WIDTH,HEIGHT) self.stopped = False self.cursor_scroll = cursor_scroll ### BEGIN SETTINGS values ### self.settings = settings self.fps_speed_adjustment = 1 # movement self.speed = 1 self.rot_velocity = math.pi/180/5 self.noclip = False ### END SETTINGS values ### self.objects = [] # key bindings / checking self.keys_down = [] self.key_mapping = { KEYS["W"]: self.forward, KEYS["S"]: self.backward, KEYS["A"]: self.left, KEYS["D"]: self.right, KEYS["SHIFT"]: self.down, KEYS["SPACE"]: self.up, KEYS["ESC"]: self.stop, KEYS["R"]: self.reset, KEYS["LEFT_ARROW"]: self.rot_left, KEYS["RIGHT_ARROW"]: self.rot_right, KEYS["UP_ARROW"]: self.rot_up, KEYS["DOWN_ARROW"]: self.rot_down } # methods to be run once a key has stopped being pressed self.key_up_mapping = { KEYS["W"]: self.kill_zvelocity, KEYS["S"]: self.kill_zvelocity, KEYS["A"]: self.kill_xvelocity, KEYS["D"]: self.kill_xvelocity, KEYS["SHIFT"]: self.kill_yvelocity, KEYS["SPACE"]: self.kill_yvelocity, KEYS["T"]: self.toggle_noclip } # rotation based on whether or not the mouse will be used # event bindings self.canvas.bind("<KeyPress>",self.keydown) self.canvas.bind("<KeyRelease>",self.keyup) if self.cursor_scroll: self.canvas.bind("<Motion>",self.rot) # camera init values self.xvelocity = 0 self.zvelocity = 0 self.yvelocity = 0 # camera's offset from the spaceship's position self.xoffset = 10 self.yoffset = 20 self.zoffset = -10 # space ship self.ship = SpaceShip( (0,0,0), self.speed, self.rot_velocity, self.engine, ObjectFile("objects/spaceship.obj", scale=0.25, pos=(10,0,20) ) ) self.objects.append(self.ship) # game stats self.fps = 0 self.mousex = 0 self.mousey = 0 # init canvas self.canvas.pack() self.canvas.focus_set() def add_object(self,obj): obj.init(self.engine) self.objects.append(obj) def reset(self): self.engine.roty = 0 self.engine.rotz = 0 def get_adjusted_speed(self,speed): """Returns the speed adjusted to the frame rate, so if frames drop or spike, the in game speed remains the same.""" # for whatever reason, I've found that the relationship between speed and fps # does not feel normal when it is linear, so I've played around and landed on this equation that feels natural return speed * math.sqrt(self.fps_speed_adjustment/self.fps) def toggle_noclip(self): self.noclip = not self.noclip def rot_up(self): if self.noclip: self.engine.roty += self.get_adjusted_speed(self.rot_velocity) else: self.ship.rot_up() def rot_down(self): if self.noclip: self.engine.roty -= self.get_adjusted_speed(self.rot_velocity) else: self.ship.rot_down() def rot_left(self): if self.noclip: self.engine.rotz -= self.get_adjusted_speed(self.rot_velocity) else: self.ship.rot_left() def rot_right(self): if self.noclip: self.engine.rotz += self.get_adjusted_speed(self.rot_velocity) else: self.ship.rot_right() def up(self): if self.noclip: self.yvelocity = self.get_adjusted_speed(self.speed) else: self.ship.up() def down(self): if self.noclip: self.yvelocity = -self.get_adjusted_speed(self.speed) else: self.ship.down() def stop(self): self.root.destroy() self.stopped = True sys.exit(0) def rot(self,event): if not self.intro: win32api.SetCursorPos((int(WIDTH/2),int(HEIGHT/2))) x,y = event.x, event.y self.mousex += x - WIDTH/2 self.mousey += y - HEIGHT/2 if self.noclip: self.engine.rotz = self.mousex*(math.pi*2/WIDTH) self.engine.roty = -(self.mousey*(math.pi*2/HEIGHT)) def forward(self): if self.noclip: self.zvelocity = self.get_adjusted_speed(self.speed) else: self.ship.forward() def backward(self): if self.noclip: self.zvelocity = -self.get_adjusted_speed(self.speed) else: self.ship.backward() def right(self): if self.noclip: self.xvelocity = self.get_adjusted_speed(self.speed) else: self.ship.right() def left(self): if self.noclip: self.xvelocity = -self.get_adjusted_speed(self.speed) else: self.ship.left() def kill_zvelocity(self): if self.noclip: self.zvelocity = 0 else: self.ship.kill_zvelocity() def kill_xvelocity(self): if self.noclip: self.xvelocity = 0 else: self.ship.kill_xvelocity() def kill_yvelocity(self): if self.noclip: self.yvelocity = 0 else: self.ship.kill_yvelocity() def update_pos(self): """ Update the camera's position based velocity, as well as incorperating the direction to make xz axis movement feel natural. """ if self.noclip: xv, zv, yv = self.xvelocity, self.zvelocity, self.yvelocity rotz = self.engine.rotz self.engine.x += zv*math.sin(rotz) + xv*math.cos(rotz) self.engine.z += zv*math.cos(rotz) - xv*math.sin(rotz) self.engine.y += yv else: self.ship.update_pos() def move_to_ship(self): if not self.noclip: x = self.ship.x y = self.ship.y z = self.ship.z # rotate camera around ship # find the mid point of the xy axis to rotate around midx = x + (self.ship.upperx-self.ship.lowerx)/2 midy = y + (self.ship.uppery-self.ship.lowery)/2 midz = z + (self.ship.upperz-self.ship.lowerz)*0.75 # slightly off the middle to make it look nicer x += self.xoffset y += self.yoffset z += self.zoffset# + -0.25*self.ship.zvelocity x -= midx y -= midy z -= midz y,z = self.engine.rot2d((y,z),-self.ship.roty) x,z = self.engine.rot2d((x,z),-self.ship.rotz) x += midx y += midy z += midz self.engine.x = x self.engine.y = y self.engine.z = z self.engine.rotz = self.ship.rotz self.engine.roty = self.ship.roty def run_key_events(self): for i in self.keys_down: if i in self.key_mapping: self.key_mapping[i]() def keydown(self,event): """Appends key codes that are being pressed into the object's list, if they are not already there.""" if event.keycode not in self.keys_down: self.keys_down.append(event.keycode) def keyup(self,event): """Removes key codes that are being pressed when the keys are released.""" k = event.keycode if k in self.keys_down: if k in self.key_up_mapping: self.key_up_mapping[k]() self.keys_down.remove(k) def update_objects(self): objects = [] for o in self.objects: o.update() objects += o.get_polygons() self.engine.update_objects(objects) def render(self): # clear the current screen self.engine.clear() # re load all the objects self.engine.render_objects() def intro(self): self.intro = True self.ship.x = -10 self.ship.z = 20 self.ship.rotx = 20*math.pi/180 self.ship.velocity_rot = False title = self.canvas.create_text(WIDTH/2,100,text="Sanic Speed",font=("Fixedsys",69),fill="white") f = font.Font(family="Verdana",slant=font.ITALIC,size=10) subtitle = self.canvas.create_text(WIDTH/2,170,text="A three dimensional space flight simulator, in pure python tkinter.",font=f,fill="white") escape_phrase = self.canvas.create_text(5,10,text="[ESC] to Quit",font=("Courier New",14),fill="white",anchor="w") global done done = False INSTRUCTIONS = """ Welcome to Sanic Speed! Standard WASD controls are used for movement. [W] : forward, [S] : backwards [A] : left, [D] : right The arrow keys are used for rotation. The forward and backward keys are inverted to give an intuitive feel to the flight. If at any point you wish to fly around the world not bound to the plane, simply press [t] to toggle "noclip". To quit, press escape [ESC]. Thanks for playing! """ def test(): global done done = True def instructions(): toplevel = tkinter.Toplevel() toplevel.title("Sanic Speed Instructions") label1 = tkinter.Label(toplevel, text=INSTRUCTIONS, font=("Helvetica",14), height=0, width=100) label1.pack() b = tkinter.Button(self.root, text="OK", command=test, width=30, height=2) b.pack() b.place(x=WIDTH/2 - 100,y=HEIGHT*0.75) b2 = tkinter.Button(self.root, text="INSTRUCTIONS", command=instructions, width=30, height=2) b2.pack() b2.place(x=WIDTH/2 - 100, y=HEIGHT*0.75 + 50) while not done: if 27 in self.keys_down: self.stop() self.ship.rotz_velocity = 0.1 self.update_pos() self.update_objects() self.render() self.root.update() self.intro = False # clear away intro screen stuff for gameplay # reset ship self.ship.rotz_velocity = 0 self.ship.rotz = 0 self.ship.roty = 0 self.ship.rotx = 0 # clear away widgets b.destroy() b2.destroy() self.canvas.delete(title) self.canvas.delete(escape_phrase) self.canvas.delete(subtitle) self.root.config(cursor='none') def run(self): t = time.clock() if self.cursor_scroll: win32api.SetCursorPos((int(WIDTH/2),int(HEIGHT/2))) self.root.config(cursor='none') fps_text = self.canvas.create_text(10,10,text="",font="ansifixed",anchor="w",fill="white") #zs = self.canvas.create_text(10,20,text="",font="ansifixed",anchor="w",fill="white") #xs = self.canvas.create_text(10,30,text="",font="ansifixed",anchor="w",fill="white") #rzs = self.canvas.create_text(10,40,text="",font="ansifixed",anchor="w",fill="white") while not self.stopped: # update the keys that are down self.run_key_events() # move the camera/spaceship based on keys self.update_pos() # move the camera based on the spaceship self.move_to_ship() # update all objects in the Game and the Engine self.update_objects() # then render self.render() # updating fps t2 = time.clock() self.fps = 1/(t2-t) # debugging messages self.canvas.itemconfig(fps_text,text="fps: " + str(int(self.fps))) #self.canvas.itemconfig(zs,text="zs: " + str(self.ship.zvelocity)) #self.canvas.itemconfig(xs,text="xs: " + str(self.ship.xvelocity)) #self.canvas.itemconfig(rzs,text="rzs: " + str(self.ship.rotz_velocity)) # keep track of time for fps t = time.clock() # update the tkinter window (draw the buffer to the display) self.root.update()
game_over = create_game_over_text() # Create New hi-score text hi_score = create_hiscore_text() # Create wall groups wall_group_list = [] for group in range(WALLS): wall_group_list.append(pygame.sprite.Group()) # Create walls, pixel by pixel build_wall(wall_group_list) # Create spaceship spaceship = SpaceShip(SPACESHIP_PATH) # Create shot group shots = pygame.sprite.Group() # Create alien shot group alien_shots = pygame.sprite.Group() # Create alien fleet fleet_group = [] alien_count = 0 # Create fleet of aliens alien_count = create_alien_fleet(fleet_group) # Create boss - boss is randomly created during gameplay
def __init__(self,root,canvas,settings={},cursor_scroll=False): # tkinter properties that are passed down self.root = root self.canvas = canvas # 3d graphics engine self.engine = Engine(self.canvas,WIDTH,HEIGHT) self.stopped = False self.cursor_scroll = cursor_scroll ### BEGIN SETTINGS values ### self.settings = settings self.fps_speed_adjustment = 1 # movement self.speed = 1 self.rot_velocity = math.pi/180/5 self.noclip = False ### END SETTINGS values ### self.objects = [] # key bindings / checking self.keys_down = [] self.key_mapping = { KEYS["W"]: self.forward, KEYS["S"]: self.backward, KEYS["A"]: self.left, KEYS["D"]: self.right, KEYS["SHIFT"]: self.down, KEYS["SPACE"]: self.up, KEYS["ESC"]: self.stop, KEYS["R"]: self.reset, KEYS["LEFT_ARROW"]: self.rot_left, KEYS["RIGHT_ARROW"]: self.rot_right, KEYS["UP_ARROW"]: self.rot_up, KEYS["DOWN_ARROW"]: self.rot_down } # methods to be run once a key has stopped being pressed self.key_up_mapping = { KEYS["W"]: self.kill_zvelocity, KEYS["S"]: self.kill_zvelocity, KEYS["A"]: self.kill_xvelocity, KEYS["D"]: self.kill_xvelocity, KEYS["SHIFT"]: self.kill_yvelocity, KEYS["SPACE"]: self.kill_yvelocity, KEYS["T"]: self.toggle_noclip } # rotation based on whether or not the mouse will be used # event bindings self.canvas.bind("<KeyPress>",self.keydown) self.canvas.bind("<KeyRelease>",self.keyup) if self.cursor_scroll: self.canvas.bind("<Motion>",self.rot) # camera init values self.xvelocity = 0 self.zvelocity = 0 self.yvelocity = 0 # camera's offset from the spaceship's position self.xoffset = 10 self.yoffset = 20 self.zoffset = -10 # space ship self.ship = SpaceShip( (0,0,0), self.speed, self.rot_velocity, self.engine, ObjectFile("objects/spaceship.obj", scale=0.25, pos=(10,0,20) ) ) self.objects.append(self.ship) # game stats self.fps = 0 self.mousex = 0 self.mousey = 0 # init canvas self.canvas.pack() self.canvas.focus_set()
# ################################################################################### # Helper Functions End # ################################################################################### # ################################################################################### # Game initialization # ################################################################################### pygame.init() # The clock will be used to control how fast the screen updates clock = pygame.time.Clock() # area which displays game and score background = pygame.image.load("assets/background.jpg").convert() position = HEIGHT hero = SpaceShip() spaceships = pygame.sprite.Group() # For multiplayer support spaceships.add(hero) # single player for now missiles = pygame.sprite.Group() missiles_alien = pygame.sprite.Group() aliens = pygame.sprite.Group() clock_alien = pygame.time.Clock() # used to keep track of alien respawn time_elapsed = spawn_alien(RESPAWN_TIME_ALIEN) # start game with one alien explosions = pygame.sprite.Group() scores = pygame.sprite.Group() # For multiplayer support score = Score("Score", 0, HEIGHT - 30) scores.add(score)
pg.display.set_caption("Asteroids!") font = pg.font.Font(None, 30) clock = pg.time.Clock() def spawnAsteroid() : randomAngle = math.radians(randrange(0, 360)) randDist = randrange(200, 400) ax = 400 + (randDist * math.cos(randomAngle)) ay = 300 + (randDist * math.sin(randomAngle)) g.asteroids.append(Asteroid(ax, ay, randomAngle, 60)) for i in range(10) : g.ships.append(SpaceShip()) for i in range(10) : spawnAsteroid() def update(dt) : for ship in g.ships : distances = [] for asteroid in g.asteroids : g.distance(ship, asteroid) distances.append(g.distance(ship, asteroid)) input = heapq.nsmallest(6, distances) ship.update(dt, input)