def main():
first = Spaceship(
"Corsair", 3, 20, 465,
[TitaniumArmor(), FlareEngine(), EmpCannon(), MolecularMirror()])
second = Spaceship(
"Phoenix", 2, 15, 480,
[AbsorptionShield(), ProtonTorpedoes(), TeleportingModule()])
print(f"{first.get_name()} ({first.get_remaining_hp()}/{first.get_max_hp()})")
print(f"{second.get_name()} ({second.get_remaining_hp()}/{second.get_max_hp()})")
game = Game(first, second)
if game.is_stalemate():
print("Neither of the ships can attack! This is a stalemate!")
else:
print("Beginning battle!")
turn = 1
while not game.game_over():
print(f"\n====== Turn {turn}: ======")
game.execute_turn()
print(f"{first.get_name()} ({first.get_remaining_hp()}/{first.get_max_hp()})")
print(f"{second.get_name()} ({second.get_remaining_hp()}/{second.get_max_hp()})")
turn += 1
winner = first if second.is_destroyed() else second
loser = second if winner == first else first
print(f"{loser.get_name()} has been destroyed! {winner.get_name()} wins!")
def __init__(self, width, height, frame_rate):
self.font = pygame.font.SysFont("Times New Roman", 36)
self.font2 = pygame.font.SysFont("Courier New", 20)
self.frame_rate = frame_rate
self.text_color = (255, 0, 0)
self.width = width
self.height = height
self.upper_limit = self.width / 3
self.spaceship_width = 20
self.spaceship_height = 10
self.spaceship = Spaceship(self.spaceship_width, self.spaceship_height,
0, (self.height / 2) - 10, (255, 255, 255))
self.spaceship_speed = 5
self.bullets = []
self.bullet_width = 2
self.bullet_height = 80
self.bullet_color = (255, 50, 50)
self.powerups = []
self.powerup_width = 20
self.powerup_height = 20
self.powerup_color = (50, 255, 50)
self.destroyers = []
self.destroyer_width = 200
self.destroyer_height = 200
self.destroyer_color = (255, 0, 0)
self.baddies = []
self.baddie_width = 20
self.baddie_height = 20
self.baddie_color = (255, 0, 0)
self.score = 0
self.baddie_kills = 0
self.life = 5
return
def enter():
global player, spaceship, timer, count
gfw.world.init(['bg','spaceship','enemy_bullet','enemy','flying_enemy','bullet','player','timer'])
player = Player()
timer = Timer()
bg.init(player)
spaceship = Spaceship()
gfw.world.add(gfw.layer.bg,bg)
gfw.world.add(gfw.layer.spaceship, spaceship)
gfw.world.add(gfw.layer.player, player)
gfw.world.add(gfw.layer.timer, timer)
count = 0
Enemy.load_all_images()
Flying_Enemy.load_all_images()
global bg_music, flip_wav, enemy_die_wav, spaceship_wav
bg_music = load_music('./res/main_state_sound.mp3')
bg_music.set_volume(60)
bg_music.repeat_play()
flip_wav = load_wav('./res/beshot.wav')
enemy_die_wav = load_wav('./res/enemy_die.wav')
spaceship_wav = load_wav('./res/spaceship_die.wav')
flip_wav.set_volume(100)
enemy_die_wav.set_volume(200)
def test_blow_up():
a = Spaceship(params['SPACE'])
assert not hasattr(a, 'debris')
assert a.intact
a.blow_up(100)
assert len(a.debris) == 3
assert not a.intact
def run_game():
# 初始化游戏
pygame.init()
# 设置屏幕分辨率
setting = Settings()
screen = pygame.display.set_mode(
(setting.screen_width, setting.screen_height))
pygame.display.set_caption("飞机大战")
# 创建小飞机
plane = Plane(screen, setting)
# print(bg_img)
spaceship = Spaceship(setting, screen)
# 开始游戏的主循环
while True:
# 不关闭窗口
fg.check_events()
# 绘制图像
fg.update_screen(screen, setting.bg_img, plane)
def test_constructor():
# Test minimal required constructor args
a = Spaceship(params['SPACE'])
assert a.SPACE['w'] == 100 and \
a.SPACE['h'] == 200 and \
hasattr(a, "intact") and \
hasattr(a, "x") and hasattr(a, "y") and\
hasattr(a, "x_vel") and hasattr(a, "y_vel")
def prepare_spaceships(self):
self.spaceships = pygame.sprite.Group()
for spaceship_number in range(self.stats.spaceship_left):
spaceship = Spaceship(self.ai_game)
spaceship.rect.x = 20 + spaceship_number * spaceship.rect.width
spaceship.rect.y = 10
self.rect.left = self.screen_rect.left
self.spaceships.add(spaceship)
def run_game():
"""Initialize game and create a screen object"""
pygame.init()
# Initialize the settings
settings = Settings(1.5)
# Initialize the game statistics
stats = GameStats(settings)
game_screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption("Alien Attack")
# Make the Play button
play_button = Button(settings, game_screen, "Play")
# Initialize the spaceship
spaceship = Spaceship(game_screen, settings)
# Play the background music
pygame.mixer.music.load("background_music.mp3")
# Set volume from zero to one
pygame.mixer.music.set_volume(0.5)
# endless loop
pygame.mixer.music.play(-1)
# Make a group to store bullets in
# list but with extra functionality
bullets = Group()
# Initialize alien fleet then update it
aliens = Group()
gf.create_fleet(settings, game_screen, aliens, spaceship)
# Initialize the scoreboard
scoreboard = Scoreboard(settings, game_screen, stats)
# Beginning of the main loop that starts the game
while True:
# Handling of keyboard and mouse events
gf.check_events(settings, spaceship, bullets, game_screen, stats, play_button,
aliens, scoreboard)
if stats.game_active:
# Updating ship position after checking key events
spaceship.update()
# Update bullet positions(update() call on elements)
bullets.update()
# Getting rid of bullets outside of game screen
gf.update_bullets(settings, game_screen, spaceship, bullets, aliens, stats,
scoreboard)
# Update the positions of the aliens
gf.update_aliens(aliens, settings, spaceship, bullets, stats, game_screen, scoreboard)
# Updating screen
gf.update_screen(game_screen, spaceship, settings, bullets,
aliens, play_button, stats, scoreboard)
def reset(self):
self.ship = Spaceship(scale=.3, speed=0.06, rotationspeed=10)
self.asteroids = []
self.bullets = []
self.frame = np.zeros((config.SCREEN_HEIGHT, config.SCREEN_WIDTH, 3), dtype="uint8")
self.last_astroid = utils.get_now()
self.now = utils.get_now()
self.score = 0
self.stars = []
self.add_stars()
def __init__(self, SPACE, fadeout):
"""Initialize the game controller"""
self.SPACE = SPACE
self.fadeout = fadeout
self.spaceship_hit = False
self.asteroid_destroyed = False
self.asteroids = [Asteroid(self.SPACE)]
self.laser_beams = []
self.spaceship = Spaceship(self.SPACE)
def _reset(self):
self.spaceship = Spaceship()
self.aliens.reset()
self.barricades = Barricades()
self.score = Score()
self.life_counter = LifeCounter()
self.is_game_over = False
self.delay_since_game_over = 0
self.is_playing = True
def __init__(self):
pg.init()
if os.path.exists('ExoFont.otf'):
d.FONT = pg.font.Font("ExoFont.otf", 18)
else:
d.FONT = pg.font.Font(None, 18)
if not d.solo:
d.spaceships = [Spaceship(NeuralNetWork(d.INPUT_COUNT, d.HIDDEN_LAYERS, 1)) for _ in range(d.POPULATION_COUNT)]
d.alive_ships = d.spaceships[:]
else:
self.spaceship = Spaceship(NeuralNetWork(d.INPUT_COUNT, d.HIDDEN_LAYERS, 1))
d.alive_ships = [self.spaceship]
# Setup asteroids
d.asteroids = []
for _ in range(d.AST_COUNT):
d.asteroids.append(Asteroid(random.randint(1, 4)))
self.update_text()
def run_game():
pygame.init()
r_settings = Settings()
screen = pygame.display.set_mode(
(r_settings.screen_width, r_settings.screen_height))
pygame.display.set_caption("WIELKA KURWA RAKIETA")
spaceship = Spaceship(screen)
while True:
f.check_events(spaceship)
spaceship.update(r_settings.speed_factor)
f.update_screen(r_settings.background, screen, spaceship)
def __init__(self, SPACE, fadeout):
"""Initialize the game controller"""
self.SPACE = SPACE
self.fadeout = fadeout
self.spaceship_hit = False
self.asteroid_destroyed = False
self.asteroids = [Asteroid(self.SPACE)]
self.laser_beams = []
self.spaceship = Spaceship(self.SPACE)
# Problem 3: set lifespan for passing to laserbeam class
self.lifespan = 100
# magic number for laser beam run out of lifespan
self.DIE = 0
def update(self): for event in pygame.event.get(): if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE): raise KeyboardInterrupt() if event.type == KEYUP and event.key == K_TAB: pygame.display.toggle_fullscreen() if not self.player.sprite.health: self.dead.play() if not self.lives: raise GameOver() self.lives -= 1 if not len(self.invaders) and not self.nextLevel(): raise GameWin() if not self.player.sprite.health: self.player.add(Spaceship(self, 12 * 32 + 16, 18 * 32 + 16, cooldown = 80)) toRemove = [] for explosion in self.explosions: if explosion.health <= 0: toRemove.append(explosion) self.explosions.remove(toRemove) toRemove = [] for bullet in self.bullets: if bullet.health <= 0: toRemove.append(bullet) self.bullets.remove(toRemove) toRemove = [] for invader in self.invaders: if invader.health <= 0: toRemove.append(invader) self.invaders.remove(toRemove) toRemove = [] for asteroid in self.asteroids: if asteroid.health <= 0: toRemove.append(asteroid) self.asteroids.remove(toRemove) self.explosions.update() self.bullets.update() self.invaders.update() self.asteroids.update() self.player.update()
def nextLevel(self):
self.level += 1
try:
self.invaders, self.asteroids = level.load('data/level'+str(self.level)+'.dat', self)
except:
return False
self.invaders = pygame.sprite.Group(self.invaders)
self.asteroids = pygame.sprite.Group(self.asteroids)
self.explosions = pygame.sprite.Group()
self.bullets = pygame.sprite.Group()
self.player = pygame.sprite.GroupSingle(Spaceship(self, 12 * 32 + 16, 18 * 32 + 16))
return True
def run_game():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption('Alien Invasion')
spaceship = Spaceship(ai_settings, screen)
bullets = Group()
bg_color = (230, 230, 230)
while True:
gf.check_events(ai_settings, screen, spaceship, bullets)
spaceship.update()
bullets.update()
gf.update_screen(ai_settings, screen, spaceship, bullets)
def __init__(self, initial_lives, screen_dims, invader_icons,
spaceship_img):
self.lives = initial_lives
self.screen_dims = screen_dims
self.invader_manager = InvaderManager(screen_dims=screen_dims,
invader_icons_x=invader_icons)
self.spaceship = Spaceship(spaceship_img=spaceship_img)
self.laser_manager = LaserManager(screen_dims=screen_dims)
self.score_board = ScoreBoard(screen_dims=screen_dims)
self.lives_board = PlayerLives(screen_dims=screen_dims,
initial_lives=self.lives)
self.game_over = False
self.space_invader_collective_pos = 0
random.seed()
self.space_invader_move_direction = random.choice(["Left", "Right"])
def _create_spaceship(self, number_spaceship, number_column):
# Creatings spaceship and setting the position
spaceship = Spaceship(self)
spaceship_width, spaceship_height = spaceship.rect.size
spaceship.y = spaceship_height + (2 * spaceship_height *
number_spaceship)
spaceship.rect.y = spaceship.y
spaceship.x = (self.settings.screen_width -
(2 * spaceship_width +
(2 * spaceship_width * number_column)))
spaceship.rect.x = spaceship.x
self.spaceships.add(spaceship)
def __init__(self, window, alien_spawn_adress):
self.window = window
self.alien_spawn_adress = alien_spawn_adress
self.spaceship = Spaceship(window)
self.enemy = Enemy(window, alien_spawn_adress)
self.bullet = Bullet(window)
self.border = {
"left": 0,
"right": 0,
"up": 0,
"down": 0
}
self.clock = 0
self.level = 1
self.point_total = 0
self.life = GVar.LIVES
def create_ship(self):
'''Create ship'''
ship_image = pyglet.image.load(IMAGES_SHIP[self.ship_img_idx])
ship_image.anchor_x = ship_image.width // 2
ship_image.anchor_y = ship_image.height // 2
ship_sprite = pyglet.sprite.Sprite(ship_image, batch=self.batch)
engine_image = pyglet.image.load(IMAGES_ENGINE)
engine_image.anchor_x = engine_image.width // 2
engine_image.anchor_y = engine_image.height + ship_image.height // 2
engine_sprite = pyglet.sprite.Sprite(engine_image,
batch=self.batch_effects)
ship = Spaceship(self.width // 2, self.height // 2, ship_sprite,
engine_sprite, self.width, self.height)
self.ships.append(ship)
def __init__(self):
pygame.init()
self.settings = st()
self.clock = pygame.time.Clock()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
self.surf_rect = self.screen.get_rect()
self.ship = Spaceship(self.screen, self.settings)
self.bullets = Group()
self.aliens = Group()
self.create_aliens_flot()
self.stats = Stats(self.settings)
self.button = Button(self.settings, self.screen,
'To start new game press "n" button')
self.active_game = True
def reset(self):
""" Reset the population and asteroids """
if d.solo:
# Only reset the player
self.spaceship = Spaceship(NeuralNetWork(d.INPUT_COUNT, d.HIDDEN_LAYERS, 1))
d.alive_ships = [self.spaceship]
else:
# Load the new generation
d.best_ship = None
d.spaceships = d.next_gen
d.alive_ships = d.spaceships
d.dead_ships = []
# Reset the asteroids
d.asteroids = []
for _ in range(d.AST_COUNT):
d.asteroids.append(Asteroid(random.randint(1, 4)))
def _create_fleet(self):
'''Create a fleet of spaceship'''
spaceship = Spaceship(self)
spaceship_height, spaceship_width = spaceship.rect.size
# Number of spaceships that fit on the screen vertically
shooter_width = self.shooter.rect.width
available_space_y = self.settings.screen_height - (2 *
spaceship_height)
number_spaceship_y = available_space_y // (1 * spaceship_height)
# Number of spaceships that fit on the screen horizontally
available_space_x = (self.settings.screen_width -
(3 * spaceship_width) - (shooter_width))
number_columns = available_space_x // (3 * spaceship_width)
for number_column in range(number_columns):
for number_spaceship in range(number_spaceship_y):
self._create_spaceship(number_spaceship, number_column)
def reset():
nonlocal player_ship,aliens,game_over,started,seconds,seconds_text,start_time,second_text_rect,wave,wave_text,time_text,time_text_rect,time_passed
wave = 1
wave_text = wave_font.render(f"WAVE: {wave}",True,WHITE)
player_ship = pygame.sprite.GroupSingle(Spaceship(WIDTH,HEIGHT))
aliens = Aliens(WIDTH)
enemy_ships.empty()
items.empty()
enemy_objects.empty()
#for sprite in items:
#sprite.kill()
started = False
game_over = False
#seconds =3
seconds_text = font.render(texts[len(texts) - seconds],True,WHITE)
second_text_rect =seconds_text.get_rect(center=(WIDTH//2,HEIGHT//2 + gap_from_center))
time_passed =0
time_text = second_font.render(str(time_passed),True,WHITE)
time_text_rect = time_text.get_rect(center=(WIDTH//2,second_top_gap + time_text.get_height()//2))
start_time = time.time()
start_sound.play()
def run_game():
# Initialize game and create a screen object
pygame.init()
# create a GameSettings object to make screen
gameSettings = GameSettings()
# make a screen with provided dimensions
screen = pygame.display.set_mode((gameSettings.screen_width, gameSettings.screen_height))
pygame.display.set_caption("Alien Shooting Game")
# Draw the SpaceShip
spaceShip = Spaceship(screen)
# main loop to control the game
while True:
# use screen.fill to fill in the background color
screen.fill(gameSettings.background_color)
spaceShip.draw()
gf.events_check(spaceShip)
spaceShip.update()
gf.screen_update(screen = screen, gameSettings = gameSettings, spaceShip = spaceShip)
def run(self):
pygame.init()
"""Game's settings initialized"""
game_settings = Settings()
screen = pygame.display.set_mode((game_settings.screen_width, game_settings.screen_height))
pygame.display.set_caption(game_settings.caption_display)
# Ship
spaceship = Spaceship(screen)
# Event monitoring
while True:
for event in pygame.event.get():
screen.fill(game_settings.background_color)
spaceship.blit_ss()
if event.type == pygame.QUIT:
print("You just exited the game.")
sys.exit()
# Latest screen frame
pygame.display.flip()
def __init__(self):
"""Inicializa o jogo e cria os recursos do mesmo"""
pygame.init()
self.settings = Settings()
self.clock = pygame.time.Clock()
# Carregando a janela do jogo
self.screen = pygame.display.set_mode(
(self.settings.width, self.settings.height))
pygame.display.set_caption('Alien Invasion')
self.game_stats = GameStats(self)
self.scoreboard = Scoreboard(self)
self.easy_game_button = button.EasyModeButton(self, 'Easy')
self.normal_game_button = button.NormalModeButton(self, 'Normal')
self.hard_game_button = button.HardModeButton(self, 'Hard')
self.spaceship = Spaceship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
def __init__(self, pygameInstance, windowScreen):
self.pygameLib = pygameInstance
self.window = windowScreen
self.screenSize = self.window.get_size()
self.myfont = self.pygameLib.font.SysFont('Comic Sans MS', 30)
self.screenTitle = self.myfont.render('Game Screen', False,
(255, 0, 0))
self.gameHero = Spaceship()
self.gameHero.image = pygame.image.load(
self.gameHero.imagePath).convert_alpha()
self.gameHero.x = (self.screenSize[0] /
2) - (self.gameHero.imageWidth / 2)
self.gameHero.y = self.screenSize[1] - self.gameHero.imageHeight
for i in range(0, 3):
enemy = EnemyShip()
enemy.image = pygame.image.load(enemy.imagePath).convert_alpha()
enemy.x = (enemy.imageWidth * i) + 5
enemy.y = 50
self.enemyShips.append(enemy)
def __init__(self):
pygame.init()
self.settings = settings()
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption("Alien Invasion")
self.spaceship = Spaceship(self)
self.game_screen = gamescreen(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self.music = Music_button(self)
self.create_fleet()
self.settings.increase_speed()
self.stats = gamestats(self)
self.scoreboard = scoreboard(self)
self.play_button = button(self, "play")
self.clock = pygame.time.Clock()
self.game_music = pygame.mixer.music.load('sounds/theme_song.mp3')
pygame.mixer.music.play(-1)
self.bullet_sound = pygame.mixer.Sound(
"sounds/GunShooting() (online-audio-converter.com).wav")
self.alien_destroying = pygame.mixer.Sound('sounds/Explosion.wav')
