def create_alien(s1, screen, aliens, alien_number, row_number):
alien = Enemy(s1, screen)
alien_width = alien.rect.width
alien.x = alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien_height = alien.rect.height
alien.y = alien_height + 2 * alien_height * row_number
alien.rect.y = alien.y
aliens.add(alien)
def generate_world(self, data, win):
for y, row in enumerate(data):
for x, tile in enumerate(row):
if tile >= 0:
img = img_list[tile - 1]
rect = img.get_rect()
rect.x = x * TILE_SIZE
rect.y = y * TILE_SIZE
tile_data = (img, rect)
if tile == 1:
self.wall_list.append(tile_data)
if tile in (4, 7):
ramp = Ramp(x * TILE_SIZE, y * TILE_SIZE, 1, tile_data)
self.ramp_list.append(ramp)
if tile in (5, 8):
ramp = Ramp(x * TILE_SIZE, y * TILE_SIZE, 2, tile_data)
self.ramp_list.append(ramp)
if tile == 6:
self.water_list.append(tile_data)
if tile in (11, 21):
spike = Spikes(x * TILE_SIZE, y * TILE_SIZE, tile_data)
self.objects_group[0].add(spike)
if tile == 16:
exit = Exit(x * TILE_SIZE, y * TILE_SIZE)
self.objects_group[4].add(exit)
if tile == 19:
checkpoint = Checkpoint(x * TILE_SIZE, y * TILE_SIZE)
self.objects_group[5].add(checkpoint)
if tile == 20:
life = Life(x * TILE_SIZE, y * TILE_SIZE, tile_data)
self.objects_group[6].add(life)
if tile == 23:
inflator = Inflator(x * TILE_SIZE, y * TILE_SIZE,
tile_data)
self.objects_group[1].add(inflator)
if tile in (12, 13, 22):
deflator = Deflator(x * TILE_SIZE, y * TILE_SIZE,
tile_data)
self.objects_group[2].add(deflator)
if tile == 27:
enemy = Enemy(x * TILE_SIZE, y * TILE_SIZE, 1,
self.wall_list)
self.objects_group[3].add(enemy)
if tile == 28:
enemy = Enemy(x * TILE_SIZE, y * TILE_SIZE, 2,
self.wall_list)
self.objects_group[3].add(enemy)
def spawn(self, interval=5):
if (isinstance(self, Level_08) or isinstance(self, Level_09)
or isinstance(self, Level_10)):
for __ in range(interval):
self.enemy_list.append(
Enemy(SCREEN_WIDTH, random.randrange(50, SCREEN_HEIGHT),
self.player, self, random.randrange(-9, 9)))
else:
for __ in range(interval):
self.enemy_list.append(
Enemy(
SCREEN_WIDTH,
random.randrange(
round(SCREEN_HEIGHT - SCREEN_HEIGHT / 4,
SCREEN_HEIGHT)), self.player, self,
random.randrange(-5, 1)))
def create_wave(user_info, group, level_name):
global ENEMY_SPACING, ENEMY_NUMBER, CREATE_WAVE
# Store wave variables
try:
wave = eval(level_name + str(user_info.wave))
except AttributeError:
return
spacing = wave[0]
wave_pause = wave[1]
pos = wave[2]
next_tile = wave[3]
# Create enemy every .2 seconds, with a .5 break every spacing
pause = 0.2
if ENEMY_NUMBER % spacing == 0:
pause += wave_pause
ENEMY_SPACING += DT
if ENEMY_SPACING >= pause:
if ENEMY_NUMBER + 4 < len(wave):
specs = wave[ENEMY_NUMBER + 4]
enemy = Enemy(specs[0], specs[1], pos, next_tile)
all_sprites.add(enemy)
group.add(enemy)
ENEMY_NUMBER += 1
ENEMY_SPACING = 0
else:
CREATE_WAVE = False
ENEMY_NUMBER = 0
def update(self):
if self.game_over:
self.lost()
if self.game_won:
self.win()
if self.running and not self.menu:
if not self.ship.all_collected():
#ensures there are always enough enemies on screen
if self.enemies != None:
exp_num_enemies = self.game_level * Screen.NUM_ENEMIES_PER_LEVEL
while len(self.enemies) < exp_num_enemies:
self.enemies.append(Enemy(self.surface, self.game_level))
for i in self.enemies:
i.update(self.platform_rects)
if self.collectables:
self.collectables.update(self.platform_rects)
if self.player:
self.player.move_player(self.key_register)
self.game_over = self.player.update(self.platform_rects, self.enemies,
self.collectables, self.ship)
if self.game_over:
self.sound = self.set_sound("sounds/gameover.ogg")
self.sound.play()
if self.ship:
self.game_won = self.ship.update()
else:
pass
def __event_handler(self):
for event in pygame.event.get():
#判断是否退出游戏
if event.type == pygame.QUIT:
self.__game_over()
elif event.type == CREATE_ENEMY_EVENT:
# 创建敌机精灵
enemy = Enemy()
# 将敌机精灵添加到敌机精灵组
self.enemy_group.add(enemy)
elif event.type == HERO_FIRE_EVENT:
self.hero.fire()
# 使用键盘提供的方法获取键盘按键-按键元组
keys_pressed = pygame.key.get_pressed()
# 判断元组中对应的按键索引值
if keys_pressed[pygame.K_RIGHT]:
self.hero.speed = 2
elif keys_pressed[pygame.K_LEFT]:
self.hero.speed = -2
else:
self.hero.speed = 0
def run(self):
# initialize all variables and do all the setup for the games startup
self.all_sprites = pg.sprite.Group()
self.enemies_sprites = pg.sprite.Group()
self.tower_foundation_sprites = pg.sprite.Group()
self.enemy = Enemy(self, (-32, 96), self.map.path)
for pos in self.map.tower_foundations_pos:
TowerFoundation(self, pos)
# Run the game
while self.running:
if self.state == 'start':
self.menu.draw()
self.menuControls()
elif self.state == 'playing':
self.playingControls()
self.playing_update()
self.playing_draw()
elif self.state == 'highscores':
highscores(self.screen)
self.highscoreControls()
elif self.state == 'game over':
# Game over state
pass
else:
self.running = False
self.clock.tick(settings.FPS)
pg.quit()
sys.exit()
def run_game():
# Initalize pygame, defined settings, and the screen
pygame.init
conductor_settings = Settings()
screen = pygame.display.set_mode(
(conductor_settings.screen_width, conductor_settings.screen_heigth))
pygame.display.set_caption("Star Killer- Redsnip8")
# Make PC Ship
star_killer = Ship(conductor_settings, screen,
"images/star-killer-ani.png", 8, 8)
# Make projectile storage
projectiles = Group()
# Make Enemy
enemy = Enemy(conductor_settings, screen)
# Game loop
while True:
gmf.check_player_events(conductor_settings, screen, star_killer,
projectiles)
star_killer.update()
gmf.update_projectiles(projectiles)
gmf.update_screen(conductor_settings, screen, star_killer, enemy,
projectiles)
def __init__(self, player):
Level.__init__(self, player)
self.sky = pygame.image.load("assets/sky.png").convert()
self.background = pygame.image.load("assets/background2new.png").convert()
self.level_limit = 4550
enemy_space = 0
enemy1 = Enemy()
self.enemies.add(enemy1)
enemy2 = Enemy()
self.enemies.add(enemy2)
enemy3 = Enemy()
self.enemies.add(enemy3)
enemy4 = Enemy()
self.enemies.add(enemy4)
enemy5 = Enemy()
self.enemies.add(enemy5)
enemy6 = Enemy()
self.enemies.add(enemy6)
enemy7 = Enemy()
self.enemies.add(enemy7)
for enemy in self.enemies:
enemy_space += 700
enemy.rect.x = enemy_space
enemy.rect.y = 307 - enemy.rect.height
def initialize_enemies(self, level):
enemies_list = []
for i in range(45):
if i < 15:
j = i
elif i < 30:
j = i - 15
else:
j = i - 30
enemy = Enemy(IMAGES_PATH + 'UFO-icon.png', level)
x = 20 + j * enemy.width * 1.3
y = math.floor(i / 15) * 65 + 18
enemy.set_position(x, y)
enemies_list.append(enemy)
return enemies_list
def _create_enemy(self):
"""Create one enemy and place in the screen."""
enemy = Enemy(self)
enemy_width, enemy_height = enemy.rect.size
enemy.rect.x = self.screen_rect.right
# print(self.screen_rect.right)
enemy.rect.y = randint(0,
self.settings.screen_height - 2 * enemy_height)
# print(enemy.rect.y)
self.enemies.add(enemy)
def createEnemies(level):
global lvlEnemies
lvlEnemies = []
enemyTypes = []
gc.collect()
thisXLeft = 0
thisXRight = 100
thisY = 2
if level == 0:
enemyTypes.append([0, 0, 0, 0, 0])
elif level == 1:
enemyTypes.append([0, 0, 0, 0, 1])
elif level == 2:
enemyTypes.append([0, 1, 0, 1, 0])
elif level == 3:
enemyTypes.append([0, 0, 2, 0, 2])
elif level == 4:
enemyTypes.append([1, 1, 0, 2, 2])
elif level == 5:
enemyTypes.append([1, 1, 0, 2, 2])
else:
enemyTypes.append([random.getrandbits(2), random.getrandbits(2), random.getrandbits(2), random.getrandbits(2), random.getrandbits(2)])
for slot in range(5):
if slot == 0 or slot == 2 or slot == 4:
if slot == 0:
lvlEnemies.append(Enemy(enemyTypes[0][slot], thisXLeft + 20, thisY, 1, 1))
else:
lvlEnemies.append(Enemy(enemyTypes[0][slot], thisXLeft, thisY, 1, 1))
else:
lvlEnemies.append(Enemy(enemyTypes[0][slot], thisXRight, thisY, -1, 1))
thisY += 16
def __init__(self):
pygame.init()
#graphics dimenions: width and height
self.screenW = 900
self.screenH = 600
self.charR = 50 #image radius
self.charW = 50 #15 * 3.5
self.charH = 100 #25 * 4
self.score = 0
self.lastBulletTime = 0
self.groundH = 50 #ground height
#player
self.cat = Player(self.screenW, self.screenH, self.charW, self.charH,
self.groundH)
#positions of platforms
self.platforms = [
Platform(200, 400),
Platform(700, 500),
Platform(500, 350)
]
self.enemies = [Enemy(200, 300), Enemy(400, 200)] #list of enemies
self.bullets = [] #list of bullets
#gameState
self.gameover = False
#manage how fast the screen updates
self.clock = pygame.time.Clock()
#set window width and height [width/2, height/2]
self.screen = pygame.display.set_mode((self.screenW, self.screenH))
#loop until the user clicks close button.
self.done = False
self.myfont = pygame.font.SysFont('arial bold', 40)
def __create_monster(self):
msg = "\n\t\t---- CURRENT MONSTERS ----"
msg += "\n\t++++++++++++++++++++++++++++++++++++++"
for i in range(NUMBER_ENEMIES):
n = random.randint(1, NUMBER_ENEMIES)
self.enemies.append(Enemy(n, self.current_stage))
if len(self.enemies) > 0:
for enemy in self.enemies:
msg += "\n\t" + enemy.__str__()
msg += "\n\t++++++++++++++++++++++++++++++++++++++"
return msg
def run_game():
'''
运行游戏主程序
:return:
'''
# background_image_filename = 'resources/images/level_1.png' #'/Users/lufan/Python_CODE_03/super_mario_level_01/resources/images/level_1.png'
# 初始化游戏并创建一个屏幕对象
pygame.init()
ai_settings = Settings()
# 创建一个窗口
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
# 设置窗口标题
pygame.display.set_caption('Super Mario Bros')
# 背景图片
# background = pygame.image.load(background_image_filename).convert()
# 放置Mario
mario = Mario(ai_settings, screen)
# 敌人
enemy = Enemy(ai_settings, screen)
while True:
#监视键盘和鼠标事件
gf.check_events(ai_settings, screen, mario)
# 将背景图画上去
# screen.blit(background, (0, 577))
centerx = mario.update()
# print(centerx)
enemy.update()
gf.update_screen(ai_settings, screen, mario, enemy, centerx)
def make_world(self):
"""
Parsing a two-dimensional array and filling in sprite groups
"""
try:
dirt_img = pygame.image.load('img/dirt.png').convert_alpha()
grass_img = pygame.image.load('img/grass.png').convert_alpha()
except pygame.error as err:
raise SystemExit(err)
# fill background with data
for row_count, row in enumerate(self.data):
for tile_count, tile in enumerate(row):
if tile == 1:
img = pygame.transform.scale(dirt_img,
(tile_size, tile_size))
img_rect = img.get_rect()
img_rect.x = tile_count * tile_size
img_rect.y = row_count * tile_size
self.tile_list.append((img, img_rect))
elif tile == 2:
img = pygame.transform.scale(grass_img,
(tile_size, tile_size))
img_rect = img.get_rect()
img_rect.x = tile_count * tile_size
img_rect.y = row_count * tile_size
self.tile_list.append((img, img_rect))
elif tile == 3:
blob = Enemy(tile_count * tile_size,
row_count * tile_size + 15)
self.blob_group.add(blob)
elif tile == 4:
platform = Platform(tile_count * tile_size,
row_count * tile_size, 1, 0)
self.platform_group.add(platform)
elif tile == 5:
platform = Platform(tile_count * tile_size,
row_count * tile_size, 0, 1)
self.platform_group.add(platform)
elif tile == 6:
lava = Lava(tile_count * tile_size,
row_count * tile_size + (tile_size // 2))
self.lava_group.add(lava)
elif tile == 7:
coin = Coin(tile_count * tile_size + (tile_size // 2),
row_count * tile_size + (tile_size // 2))
self.coin_group.add(coin)
elif tile == 8:
level_exit = Exit(tile_count * tile_size,
row_count * tile_size - (tile_size // 2))
self.exit_group.add(level_exit)
def playGame(screen, myfont):
scene.starting(screen, myfont)
enemyList = [Enemy() for i in range(50)] #difficulty
iterations = 0
while True:
screen.fill(Settings.backgroundColor)
if not Settings.pause:
Player.xCoord, Player.yCoord = pygame.mouse.get_pos(
) #delete this line to use keys
pygame.draw.circle(screen,
Player.color, [Player.xCoord, Player.yCoord],
round(Player.size)) #draws the Player
for enemy in enemyList:
enemy.draw(screen)
if (not Settings.pause) and (iterations % enemy.speed == 0):
enemy.move(
) #makes enemies move in a set direction(determined from the __init__() function)
for enemy in enemyList:
if not gf.checkBoundary(enemy):
enemyList[enemyList.index(enemy)] = Enemy()
time.sleep(Player.speed)
gf.checkEvents(Player)
gf.checkCollision(Player, enemyList)
textsurface = myfont.render(
'Size: ' + str(round(Player.actualSize)) + " " * 30 +
"About the width of : " +
str(Settings.stageToObject(Settings.stage)), False,
Settings.colors['WHITE']) #shows score
screen.blit(textsurface, (0, 0))
gf.nextTerm(enemyList)
pygame.display.flip()
if Settings.quit:
break
iterations += 1
scene.endCredits(screen, myfont)
def main():
global screen
# interval at which enemies should spawn in milliseconds
spawn_interval = 3000
# variable to store the last spawn time
last_spawned = 0
game_over = False
# add a Player object to the player group
player.add(Player((width//2, height-50)))
while True:
clock.tick(60)
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
if event.type == KEYDOWN:
# screen controls
if event.key == K_f:
screen = pygame.display.set_mode(size, FULLSCREEN)
elif event.key == K_ESCAPE:
screen = pygame.display.set_mode(size)
if not game_over:
# controls, checks for currently pressed keys
keys = pygame.key.get_pressed()
if keys[K_RIGHT]:
player.sprite.right()
if keys[K_LEFT]:
player.sprite.left()
# check if it is time to spawn an enemy
if pygame.time.get_ticks() - spawn_interval > last_spawned:
last_spawned = pygame.time.get_ticks()
# spawn a normal enemy 80% of the time
if random.randint(1, 100) < 80:
enemies.add(Enemy((random.randint(50, width - 50), -100)))
else:
# spawn a Firing Enemy
enemies.add(FiringEnemy((random.randint(50, width - 50), -100)))
# update the sprite groups
enemies.update()
player.update(enemies) # pass in enemy group for collision handling
# check if the game is over
if len(player) == 0:
game_over = True
screen.fill(color)
player.draw(screen)
enemies.draw(screen)
pygame.display.flip()
def checkCollision(player, enemyList):
for enemy in enemyList:
deltaX = abs(enemy.xCoord - player.xCoord)
deltaY = abs(enemy.yCoord - player.yCoord)
if (((deltaX**2) +
(deltaY**2))**(1 / 2)) < (enemy.size + player.size -
(player.size * 0.6)): #touching enemy
if player.size - player.size * 0.1 > enemy.size:
player.size += 1
player.actualSize += 1
enemyList[enemyList.index(enemy)] = Enemy()
elif (enemy.size - player.size * 0.1 > player.size) and (enemy.age
> 50):
print(enemy.color)
Settings.quit = True
Settings.killedBy = enemy
def create_enemy(self):
enemy_data = self.strand_data['enemy']
new_enemy = Enemy(self.screen,
enemy_data['spd'],
enemy_data['collision_layer'],
enemy_data['collision_mask'],
enemy_data['c_width'],
enemy_data['c_height'],
self.strand_data['path'],
enemy_data['points'],
_sprite=enemy_data['sprite'],
_strand=self,
_object_handler=self.handler)
self.handler.add_object_to_game(new_enemy)
self.enemy_list.append(new_enemy)
self.enemies_count -= 1
if not self.strand_started:
self.strand_started = True
def lit_treasure_room(self):
print(
"You light the torch, sending a flickering glow about the room you reside in.\n"
)
self.player.current_room.n_to = self.room['treasure']
self.player.current_room = self.player.current_room.n_to
self.player.current_room.enemy = Enemy("Goblin")
print(
f"The lit {self.items['torch'].name} has been placed upon a holster on the nearby wall. It has been removed from your inventory.\n"
)
time.sleep(1)
self.player.current_room.print_room_details()
time.sleep(1)
self.player.current_room.enemy.print_description()
time.sleep(1)
battle = Battle(self.player, self.player.current_room.enemy)
battle.main_battle_loop()
self.player.current_room.enemy = None
def run_game():
# Init all the pygame stuff
pygame.init()
# set up a tuple for a screen size (horizontal, vertical)
screen_size = (1000, 800)
# tuple for background color (R, G, B)
background_color = (82, 111, 53)
# create a pygame to us
screen = pygame.display.set_mode(screen_size)
# set a caption on the terminal window
pygame.display.set_caption("3rd Person Shooter")
the_shooter = Player(screen, './images/Hero.png', 100, 100)
the_shooter_group = Group()
the_shooter_group.add(the_shooter)
bad_guy = Enemy(screen)
enemies = Group()
enemies.add(bad_guy)
bullets = Group()
tick = 0
# Main game loop run forever...(or until break)
# could also use Boolean instead of 1...
while 1:
tick += 1
if tick % 40 == 0:
enemies.add(Enemy(screen))
screen.fill(background_color)
check_events(the_shooter, screen, bullets)
# Draw the shooter
for shooter in the_player_group:
the_shooter.draw_me()
for bad_gu in enemies:
bad_guy.update_me(the_shooter)
bad_guy.draw_me()
hero_died = groupcollide(the_shooter_group, enemies, True, False)
bullet_hit = groupcollide(bullets, enemies, True, True)
print bullet_hit
# clear the screen for the next time throught the loop
pygame.display.flip()
[0,0,1,0,0,1,0,0,1,0,0,1,0,0]
]
# General graphics
livesImg = graphics.g_player.lives
numbers = [graphics.g_numbers.n0, graphics.g_numbers.n1, graphics.g_numbers.n2, graphics.g_numbers.n3, graphics.g_numbers.n4, graphics.g_numbers.n5, graphics.g_numbers.n6, graphics.g_numbers.n7, graphics.g_numbers.n8, graphics.g_numbers.n9]
impImages = [graphics.g_imps.imp0_0, graphics.g_imps.imp1_0, graphics.g_imps.imp2_0, graphics.g_imps.imp3_0, graphics.g_imps.imp4_0, graphics.g_imps.imp5_0]
levelImages = [[graphics.g_tiles.tile01, graphics.g_teleporters.tele01], [graphics.g_tiles.tile02, graphics.g_teleporters.tele02], [graphics.g_tiles.tile03, graphics.g_teleporters.tele03], [graphics.g_tiles.tile04, graphics.g_teleporters.tele04], [graphics.g_tiles.tile05, graphics.g_teleporters.tele05], [graphics.g_tiles.tile06, graphics.g_teleporters.tele06]]
bullet = graphics.g_enemies.bullet
# Init classes
instructions = Interface()
bg = Background(0, 0)
player = Player(0, 2, -12, 106)
audio = Audio(g_sound)
lvlEnemies = Enemy(0, -20, -20, 0, 0)
bonusItem.append(Drops(-20, -20, 0))
aLevel = Levels([levelMaps[random.getrandbits(4)], levelMaps[random.getrandbits(4)], levelMaps[random.getrandbits(4)], levelMaps[random.getrandbits(4)], levelMaps[random.getrandbits(4)]])
levelImps = Imps(-20, -20, impImages[0], 0)
flashText = Text(1, 1, "", True, -5)
tmpImpId = random.getrandbits(2)
impId = tmpImpId + random.getrandbits(2)
if impId > 5:
impId = 5
#############################################
def update():
global gameState, levelComplete, movePlayerX, impsOnScreen, impId, rndLevel, bonusItem, playerLives, bonusItemDropRate, score, aLevel, tmpImpId
global cheatsOn, flashPlayer, flashText, freezeTimer, freezeTimerMax, freezeEnemies, bulletVisible, bulletX, bulletY, bulletDir, bulletSpeed, warpPlayed
# Randomize imps during splash
def __init__(self):
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
Enemy.__init__(self, ai_settings, screen)
self.kill()
from hero import Hero
from enemies import Enemy
from enemies import Boss
# Create the tk environment as usual
image_size = 72
board_size = 12
root = Tk()
canvas = Canvas(root,
width=image_size * board_size,
height=image_size * board_size)
# Creating a box that can draw itself in a certain position
grid = Grid(board_size)
hero = Hero(board_size)
enemy = Enemy(board_size)
boss = Boss(board_size)
background = Resource()
def on_key_press(e):
# When the keycode is 111 (up arrow) we move the position of our box higher
print(e.keycode)
if e.keycode == 65:
hero.i = hero.i - 1
elif e.keycode == 68:
hero.i = hero.i + 1
elif e.keycode == 83:
hero.j = hero.j + 1
elif e.keycode == 87:
hero.j = hero.j - 1
def create_fleet(s1, screen, aliens):
for row_number in range(s1.number_rows):
for alien_number in range(s1.number_aliensx):
alien = Enemy(s1, screen)
create_alien(s1, screen, aliens, alien_number, row_number)
def setUp(self):
self.enemy = Enemy(100, 100, 20)
self.dead_enemy = Enemy(0, 0, 10)
class TestingEnemies(unittest.TestCase):
def setUp(self):
self.enemy = Enemy(100, 100, 20)
self.dead_enemy = Enemy(0, 0, 10)
def test_initialisation(self):
self.assertIsInstance(self.enemy, Enemy)
def test_attack(self):
self.assertEqual(self.enemy.attack("weapon"), 0)
self.assertEqual(self.enemy.attack("spell"), 0)
self.assertEqual(self.enemy.attack(), 20)
w = Weapon("Hammer", 10)
self.enemy.equip(w)
s = Spell("Potion", 20, 25, 1)
self.enemy.learn(s)
self.assertEqual(self.enemy.attack("weapon"), 10)
self.assertEqual(self.enemy.attack("spell"), 20)
with self.assertRaises(ValueError):
self.enemy.attack("hammer")
def main():
""" Main Program """
#pygame.init()
#main_menu()
# Set the height and width of the screen
size = [constants.SCREEN_WIDTH, constants.SCREEN_HEIGHT]
screen = pygame.display.set_mode(size)
pygame.display.set_caption("Danga")
### Main score song we pause for debug
song = pygame.mixer.Sound("sounds/danga.wav")
song.play(-1)
score = 0
# Create the player
player = Player()
player_shot = None
# Create the enemy
enemy = Enemy()
enemies = pygame.sprite.Group()
npcs = pygame.sprite.Group()
#Prepare for enemy_shots
enemy_shots = pygame.sprite.Group()
npc = Npc()
# Create all the levels
level_list = []
level_list.append(levels.Level_01(player))
level_list.append(levels.Level_02(player))
# Set the current level
current_level_no = 0
current_level = level_list[current_level_no]
active_sprite_list = pygame.sprite.Group()
player.level = current_level
enemy.level = current_level
npc.level = current_level
player.rect.x = 340
player.rect.y = constants.SCREEN_HEIGHT - player.rect.height
active_sprite_list.add(player)
enemy.rect.x = constants.SCREEN_WIDTH - enemy.rect.width
enemy.rect.y = 0 #constants.SCREEN_HEIGHT - enemy.rect.height
active_sprite_list.add(enemy)
enemies.add(enemy)
npc.rect.x = constants.SCREEN_WIDTH - enemy.rect.width
npc.rect.y = 0 #constants.SCREEN_HEIGHT - enemy.rect.height
#aggiungiano un NPC ?
#active_sprite_list.add(npc)
#npcs.add(npc)
#Loop until the user clicks the close button.
done = False
# Used to manage how fast the screen updates
clock = pygame.time.Clock()
# -------- Main Program Loop -----------
while not done:
for event in pygame.event.get(): # User did something
if event.type == pygame.QUIT: # If user clicked close
done = True # Flag that we are done so we exit this loop
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
player.go_left()
if event.key == pygame.K_RIGHT:
player.go_right()
if event.key == pygame.K_UP:
player.jump()
if event.key == pygame.K_SPACE:
player.yell()
if event.key == pygame.K_LCTRL:
#shots.append(Shot(player.rect.center, player.direction))
player_shot = Shot(player.rect.center, player.direction)
active_sprite_list.add(player_shot)
#if event.key == pygame.K_RCTRL:
#shots.append(EnemyShot(enemy.rect.center))
#active_sprite_list.add(EnemyShot(enemy.rect.center, player))
if event.type == pygame.KEYUP:
if event.key == pygame.K_LEFT and player.change_x < 0:
player.stop()
if event.key == pygame.K_RIGHT and player.change_x > 0:
player.stop()
### ENEMY SHOTS
time_now = pygame.time.get_ticks()
#print (str(time_now - enemy.last_shot))
if time_now - enemy.last_shot > 1500:
current_shot = EnemyShot(enemy.rect.center, player)
enemy_shots.add(current_shot)
active_sprite_list.add(current_shot)
enemy.last_shot = time_now
#draw_text('COLLIDE!', font40, constants.WHITE, int( constants.SCREEN_WIDTH / 2 - 100), int( constants.SCREEN_HEIGHT / 2 + 50))
### MAIN COLLISION (Player Shot)
if player_shot:
if pygame.sprite.collide_rect(player_shot, enemy):
#print("COLLIDE")
explosion = Explosion(enemy.rect.centerx, enemy.rect.centery, 4)
active_sprite_list.add(explosion)
score += 10
### MAIN COLLISION (Enemy Shot)
if pygame.sprite.collide_rect(current_shot, player):
#print("COLLIDE")
explosion = DeathExplosion(player.rect.centerx, player.rect.centery, 4)
active_sprite_list.add(explosion)
player.shield = player.shield -3
### SHIELD, DEATH, LIVES AND GAME OVER
if player.shield <= 0:
player_die_sound.play()
death_explosion = DeathExplosion(player.rect.centerx, player.rect.centery, 4)
active_sprite_list.add(death_explosion)
# running = False ## GAME OVER 3:D
player.hide()
player.lives -= 1
player.shield = 100
## if player died and the explosion has finished, end game
if player.lives == 0 and not death_explosion.alive():
done = True
#draw_text(screen, "GAME OVER", 30, constants.SCREEN_WIDTH/2, constants.SCREEN_HEIGHT/2)
### SPRITE UPDATES
# Update the player.
active_sprite_list.update()
# Update items in the level
current_level.update()
### PLAYER SCREEN LIMITS
# print ('x:'+str(player.rect.x))
# print ('y:'+str(player.rect.y))
# If the player gets near the right side, shift the world left (-x)
if player.rect.x >= 500:
diff = player.rect.x - 500
player.rect.x = 500
current_level.shift_world(-diff)
# If the player gets near the left side, shift the world right (+x)
if player.rect.x <= 120:
diff = 120 - player.rect.x
player.rect.x = 120
current_level.shift_world(diff)
# If the player gets to the end of the level, go to the next level
current_position = player.rect.x + current_level.world_shift
if current_position < current_level.level_limit:
player.rect.x = 120
if current_level_no < len(level_list)-1:
current_level_no += 1
current_level = level_list[current_level_no]
player.level = current_level
### DRAWS
# ALL CODE TO DRAW SHOULD GO BELOW THIS COMMENT
current_level.draw(screen)
active_sprite_list.draw(screen)
draw_text(screen, str(score), 18, constants.SCREEN_WIDTH / 2, 10) ## 10px down from the screen
#draw_shield_bar(screen, 5, 5, 100)
draw_shield_bar(screen, 5, 5, player.shield)
# Draw lives
draw_lives(screen, constants.SCREEN_WIDTH - 100, 5, player.lives, player_mini_img)
# ALL CODE TO DRAW SHOULD GO ABOVE THIS COMMENT
# Limit to 60 frames per second
clock.tick(60)
# Go ahead and update the screen with what we've drawn.
pygame.display.flip()
game_over()
main_menu()
def update():
global aPressed, gameMode, bPressed, cPressed, shuttleTimer, enemyTimer, bossTimer
global gameState, scoreCtr, score, highscore, shakeX, bulletCount, health, rockSizes, crystalSizes, enemyShipSizes, bossShipSizes
global upPressed, downPressed, leftPressed, rightPressed, explosionList, explosionFrames
global shuttle, enemyList, bulletList, dropList, bombs, bossList, spaceman, pauseGame
destroyScreen = False
shipHitShuttle = False
# Get screen shake amount (use on all x positions of objects!)
######################################
shakeX = shake.update()
if gameState != STATE_PAUSE:
# Update stars
######################################
for star in starList:
star.update()
# Update rocks
######################################
for boulders in rockList:
boulders.update(rockSizes)
######################################
# Game state
######################################
if gameState == STATE_GAME:
# Update the score for player survival
######################################
scoreCtr += 1
if scoreCtr % 10 == 0:
score += 1
if cPressed:
gameState = STATE_PAUSE
cPressed = False
# Bomb button
######################################
if bPressed:
bPressed = False
if bombs > 0:
bombs -= 1
destroyScreen = True
# Move player
######################################
shipXMove = 0
shipYMove = 0
if upPressed:
shipYMove = -2
if downPressed:
shipYMove = 2
if leftPressed:
shipXMove = -2
if rightPressed:
shipXMove = 2
player.movePlayer(shipXMove, shipYMove)
# Update player ship flames
######################################
for flame in flameList:
flame.update(player.getPlayerPos()[0], player.getPlayerPos()[1] + 20)
# Update drops
######################################
if len(dropList) > 0:
tmpCtr = 0
for dropItem in dropList:
# Delete drop if out of screen
if dropItem.update():
del dropList[tmpCtr]
break
# Check if player is over drop
if detectHit(player.getPlayerPos()[0] + 7, player.getPlayerPos()[1] + 7, dropItem.returnPos()[0] - 2, dropItem.returnPos()[1] - 2, 14):
# Health / green
if dropItem.getType() == 0:
audio.playSfx(sounds.health)
health = 10
# Extra bullet / orange
elif dropItem.getType() == 1:
audio.playSfx(sounds.extraBullet)
if bulletCount == 8:
bulletCount += 1
elif bulletCount < 8:
bulletCount += 2
# Explosion/bonus / blue
else:
audio.playSfx(sounds.bonus)
score += 100
if bombs < 10:
bombs += 1
del dropList[tmpCtr]
break
tmpCtr += 1
# Delete drop object
######################################
if tmpCtr > 0:
gc.collect()
# Check crystal collisions
######################################
if len(crystalList) > 0:
crystalCtr = 0
delCrystal = False
for crystal in crystalList:
crystal.update()
# Has player hit crystal?
if detectHit(player.getPlayerPos()[0] + 7, player.getPlayerPos()[1] + 7, crystal.returnPos()[0], crystal.returnPos()[1], crystal.getSize()):
del crystalList[crystalCtr]
delCrystal = True
score += 50
audio.playSfx(sounds.bonus)
if crystal.returnPos()[1] >= 100:
del crystalList[crystalCtr]
delCrystal = True
# Destroy if player bombed
if destroyScreen:
explosionList.append(Explosion(crystal.returnPos()[0], crystal.returnPos()[1], len(explosionFrames)))
del crystalList[crystalCtr]
delCrystal = True
crystalCtr += 1
if delCrystal:
gc.collect()
# Check to see if new crystals need to be spawned
######################################
if random.getrandbits(7) > 126:
tmpX = random.getrandbits(7)
spdX = random.getrandbits(1)
spdY = random.getrandbits(2)
if spdY == 0:
spdY = 1
crystalId = random.getrandbits(3)
# Only 6 crystals to choose from
if crystalId > 5:
crystalId = 0
crystalList.append(Crystal(tmpX, -20, spdX, spdY, crystalId, crystalSizes[crystalId]))
# Check rock collisions
######################################
for boulders in rockList:
if detectHit(player.getPlayerPos()[0] + 7, player.getPlayerPos()[1] + 7, boulders.returnPos()[0], boulders.returnPos()[1], boulders.getSize()) and not shake.isShaking():
shake.setShake()
explosionList.append(Explosion(boulders.returnPos()[0], boulders.returnPos()[1], len(explosionFrames)))
boulders.resetYPos(rockSizes) # Reset as if it has exploded
health -= 1
audio.playSfx(sounds.explosion01)
if health <= 0:
gameState = STATE_GAMEOVER
audio.playSfx(sounds.gameOver)
# Destroy if player bombed
if destroyScreen:
shake.setShake()
explosionList.append(Explosion(boulders.returnPos()[0], boulders.returnPos()[1], len(explosionFrames)))
boulders.resetYPos(rockSizes)
# Update explosion
######################################
if len(explosionList) > 0:
tmpId = 0
tmpCtr = 0
for explody in explosionList:
tmpId += 1
if explody.getFrame() >= len(explosionFrames):
tmpCtr = tmpId
break
explody.update()
# Delete explosion object
######################################
if tmpCtr > 0:
del explosionList[tmpCtr - 1]
gc.collect()
# Create random shuttle
######################################
if scoreCtr % shuttleTimer == 0:
if random.getrandbits(1) == 1:
shuttle[2] = True
# Update shuttle
######################################
if shuttle[2]:
shuttle[1] += 1
if destroyScreen:
explosionList.append(Explosion(shuttle[0], shuttle[1], len(explosionFrames)))
audio.playSfx(sounds.explosion01)
# Spawn drop
dropList.append(Drop(shuttle[0], shuttle[1]))
# Check if player ship hit shuttle
if detectHit(player.getPlayerPos()[0] + 7, player.getPlayerPos()[1] + 7, shuttle[0], shuttle[1], 10):
explosionList.append(Explosion(shuttle[0], shuttle[1], len(explosionFrames)))
audio.playSfx(sounds.explosion01)
# Spawn drop
dropList.append(Drop(shuttle[0], shuttle[1]))
shipHitShuttle = True
health -= 1
if health <= 0:
gameState = STATE_GAMEOVER
audio.playSfx(sounds.gameOver)
if shuttle[1] > 90 or destroyScreen or shipHitShuttle:
shuttle[2] = False # Hide it
shuttle[1] = -30 # Set y pos to top
shuttle[0] = random.getrandbits(7) # Random x pos
# Update spaceman
######################################
if spaceman[2]:
spcX = 0
spcY = 0
# Check if player caught him
if detectHit(player.getPlayerPos()[0] + 7, player.getPlayerPos()[1] + 7, spaceman[0], spaceman[1], 12):
score += 50
audio.playSfx(sounds.dropItem)
# Reset him
spaceman = [0, 0, False]
# Move him down
if spaceman[0] > -12 and spaceman[0] < 122:
if spaceman[1] > -12 and spaceman[1] < 100:
spcX = random.getrandbits(3)
spcY = random.getrandbits(3)
if spcX < 3:
spcX = -1
else:
spcX = 1
if spcY < 3:
spcY = -1
else:
spcY = 1
spaceman[0] += spcX
spaceman[1] += spcY
# disappear him if needed
if spaceman[0] < 0 or spaceman[0] > 110:
if spaceman[1] < 0 or spaceman[1] > 88:
spaceman = [0, 0, False]
# Then update enemies
######################################
if len(enemyList) > 0:
tmpId = 0
tmpCtr = 0
for en in enemyList:
tmpId += 1
# Check if enemy can shoot
if en.update():
# Horizontal enemy
if en.getSize() == 0:
if en.returnPos()[0] > 0:
bulletList.append(Bullet(en.returnPos()[0] + 4, en.returnPos()[1] + 15, 0, 2, 1))
audio.playSfx(sounds.enemyShot)
# All others
else:
if en.returnPos()[1] > 0:
bulletList.append(Bullet(en.returnPos()[0] + 4, en.returnPos()[1] + 15, -1, 2, 2))
bulletList.append(Bullet(en.returnPos()[0] + 4, en.returnPos()[1] + 15, 1, 2, 2))
audio.playSfx(sounds.enemyShot)
# Is enemy out of the screen yet?
if en.outOfScreen():
tmpCtr = tmpId
break
if destroyScreen:
explosionList.append(Explosion(en.returnPos()[0], en.returnPos()[1], len(explosionFrames)))
# Spawn drop
dropList.append(Drop(en.returnPos()[0], en.returnPos()[1]))
del enemyList[tmpCtr - 1]
# Delete enemy object
######################################
if tmpCtr > 0:
del enemyList[tmpCtr - 1]
gc.collect()
# Create random enemies
######################################
if scoreCtr % enemyTimer == 0:
if len(enemyList) > 3:
enemyListTmp = enemyList[len(enemyList) - 1]
enemyList = [enemyListTmp]
else:
enemyList.append(Enemy())
# Create random bosses
######################################
if len(bossList) > 0:
tmpId = 0
tmpCtr = 0
for boss in bossList:
tmpId += 1
bossId = boss.getId()
bossX = boss.returnPos()[0]
bossY = boss.returnPos()[1]
# Check if enemy can shoot
if boss.update():
# Horizontal enemy
if boss.getId() == 0 or boss.getId() == 2:
if boss.returnPos()[0] > 0:
bulletList.append(Bullet(bossX + (bossShipSizes[bossId] // 2), bossY + 17, 0, 2, bossId + 1))
audio.playSfx(sounds.enemyShot)
# All others
else:
if boss.returnPos()[1] > 0:
bulletList.append(Bullet(bossX + (bossShipSizes[bossId] // 2), bossY + 17, -1, 2, bossId + 1))
bulletList.append(Bullet(bossX + (bossShipSizes[bossId] // 2), bossY + 17, 1, 2, bossId + 1))
audio.playSfx(sounds.enemyShot)
# Is enemy out of the screen yet?
if boss.outOfScreen():
tmpCtr = tmpId
break
if destroyScreen:
explosionList.append(Explosion(boss.returnPos()[0], boss.returnPos()[1], len(explosionFrames)))
# Spawn drop
dropList.append(Drop(boss.returnPos()[0], boss.returnPos()[1]))
del bossList[tmpCtr - 1]
# Delete enemy object
######################################
if tmpCtr > 0:
del bossList[tmpCtr - 1]
gc.collect()
# Create random bosses
######################################
if scoreCtr % bossTimer == 0:
if len(bossList) > 1:
bossListTmp = bossList[len(bossList) - 1]
bossList = [bossListTmp]
else:
bossList.append(Boss())
# Fire button
######################################
if aPressed:
aPressed = False
if bulletCount > 0:
bulletList.append(Bullet(player.getPlayerPos()[0] + 5, player.getPlayerPos()[1], 0, -3, 0))
bulletCount -= 1
audio.playSfx(sounds.playerShot)
# Update bullet positions
######################################
if len(bulletList) > 0:
tmpId = 0
tmpCtr = 0
for bul in bulletList:
tmpId += 1
bullX = bul.returnPos()[0] + 3
bullY = bul.returnPos()[1] + 2
bullId = bul.getId()
# Check bullet collisions
######################################
# Check against shuttle
if detectHit(bullX, bullY, shuttle[0], shuttle[1], 10) and bullId == 0:
explosionList.append(Explosion(shuttle[0], shuttle[1], len(explosionFrames)))
# Spawn drop
dropList.append(Drop(shuttle[0], shuttle[1]))
# Spawn spaceman
spaceman[0] = shuttle[0]
spaceman[1] = shuttle[1]
spaceman[2] = True
# Reset shuttle
shuttle[2] = False # Hide it
shuttle[1] = -20 # Set y pos to top
shuttle[0] = random.getrandbits(7) # Random x pos
tmpCtr = tmpId # Kill this bullet
audio.playSfx(sounds.explosion01) # Explosion
break
# Check against enemies
######################################
tmpId2 = 0
tmpCtr2 = 0
for en in enemyList:
tmpId2 += 1
enX = en.returnPos()[0]
enY = en.returnPos()[1]
if detectHit(bullX, bullY, enX, enY, enemyShipSizes[en.getSize()]) and bullId == 0:
explosionList.append(Explosion(enX, enY, len(explosionFrames)))
tmpCtr = tmpId # Kill this bullet
tmpCtr2 = tmpId2 # Kill this enemy
audio.playSfx(sounds.explosion01) # Explosion
# Spawn drop
dropList.append(Drop(enX, enY))
break
# Delete enemy object
######################################
if tmpCtr2 > 0:
del enemyList[tmpCtr2 - 1]
# Check against bosses
######################################
tmpId3 = 0
tmpCtr3 = 0
for boss in bossList:
tmpId3 += 1
bossId = boss.getId()
bossX = boss.returnPos()[0]
bossY = boss.returnPos()[1]
if detectHit(bullX, bullY, bossX, bossY, bossShipSizes[bossId]) and bullId == 0:
explosionList.append(Explosion(bossX + (bossShipSizes[bossId] // 2), bossY + 10, len(explosionFrames)))
tmpCtr = tmpId # Kill this bullet
# Check boss hitpoints
if boss.getHitPoints() > 0:
boss.addHitPoint(1)
else:
tmpCtr3 = tmpId3 # Kill this boss
audio.playSfx(sounds.explosion01) # Explosion
# Spawn drop
dropList.append(Drop(bossX + (bossShipSizes[bossId] // 2), bossY + 10))
break
# Delete boss object
######################################
if tmpCtr3 > 0:
del bossList[tmpCtr3 - 1]
# Check against rocks
######################################
for boulders in rockList:
boulderX = boulders.returnPos()[0]
boulderY = boulders.returnPos()[1]
if detectHit(bullX, bullY, boulderX, boulderY, boulders.getSize()) and bullId == 0:
explosionList.append(Explosion(boulderX, boulderY, len(explosionFrames)))
tmpCtr = tmpId # Kill this bullet
boulders.resetYPos(rockSizes) # Reset as if it has exploded
audio.playSfx(sounds.explosion01) # Explosion
break
# Check against player
######################################
if detectHit(bullX, bullY, player.getPlayerPos()[0], player.getPlayerPos()[1], 16) and not shake.isShaking() and bullId != 0:
shake.setShake()
explosionList.append(Explosion(player.getPlayerPos()[0] + 7, player.getPlayerPos()[1] + 7, len(explosionFrames)))
audio.playSfx(sounds.explosion01) # Explosion
health -= 1
if health <= 0:
gameState = STATE_GAMEOVER
audio.playSfx(sounds.gameOver) # Explosion
# Check if bullet is out of screen bounds
######################################
if bul.update():
tmpCtr = tmpId
break
# Delete bullet object
######################################
if tmpCtr > 0:
del bulletList[tmpCtr - 1]
gc.collect()
# Slowly speed up object timers to make game harder over time
######################################
if scoreCtr % 80 == 0:
if enemyTimer > 100:
enemyTimer -= 1
if bossTimer > 200:
bossTimer -=1
######################################
# PAUSE
######################################
if gameState == STATE_PAUSE:
if cPressed:
cPressed = False
gameState = STATE_GAME
######################################
# Game over state
######################################
if gameState == STATE_GAMEOVER:
# Save score if more than highscore
if score > highscore:
updateScore("save", score)
highscore = score
if cPressed:
cPressed = False
gameState = STATE_MENU
def move_down(player, enemies):
'''function in charge of movig character up an down'''
enemies_left = enemies[0]
for element in enemies:
try:
if element.x_coord == last[1] and element.y_coord == (last[0] +
change):
enemy = element
except AttributeError:
pass
try:
if board[last[0] + change][last[1]] == ' ':
# movement only on floor that is " "
board[last[0] + change][last[1]] = character
board[last[0]][last[1]] = " "
return True
elif board[last[0] + change][last[1]] == '0':
#here goes the things that sage wants to say
if player.if_sage == False:
player.if_sage = sage()
else:
shop(player)
return False
elif board[last[0] +
change][last[1]] == Colors.portal + '$' + Colors.end:
board[last[0]][last[1]] = " "
output = 2
return (True, output)
elif board[last[0] +
change][last[1]] == Colors.portal + '*' + Colors.end:
if player.level >= 2:
board[last[0]][last[1]] = ' '
output = 3
return (True, output)
else:
return False
elif board[last[0] +
change][last[1]] == Colors.portal + '^' + Colors.end:
from enemies import Enemy
enemy = Enemy(3)
fight(player, enemy)
from win import wingame as win
#win()
elif '<' in board[last[0] + change][last[1]]:
fight(player, enemy)
if enemy.life == 0:
board[enemy.y_coord][
enemy.x_coord] = Colors.money + 'o' + Colors.end
args['enemies'][0] -= 1
player.enemies_killed += 1
return False
elif 'o' in board[last[0] + change][last[1]]:
player.gold += enemy.level * randint(1, 10)
board[last[0] + change][last[1]] = character
board[last[0]][last[1]] = ' '
return True
elif board[last[0] + change][last[1]] == '=':
if doors():
board[last[0] + change][last[1]] = ' '
return False
else:
idle()
return False
except IndexError:
idle()
return False
#print_maze(lvl_1, []);
def newinput():
stdout.write("\u001b[31mDisease Name: " + disease + "\u001b[37m") #+ str(player.health) + "/4\u001b[37m")
#\u001b[31m
#\u001b[37m
stdout.flush()
player.move_dir = str(readkey())
enemyList = [];
# xx,yy=random_x_y(lvl_1)
# e1 = Enemy(xx,yy, "Einfacher Fiend")
# xx,yy=random_x_y(lvl_1) # 2 different enemies
# e2 = Enemy(xx,yy, random_enemy())
# e1.findPathTo(lvl_1, player.x, player.y);
# enemyList.append(e1);
# enemyList.append(e2)
#enemyList.append(Enemy())
enemyList.append(Enemy(2, 2,enemy_type=random_enemy()));
while True:
os.system("clear")
print_maze(lvl_1,enemyList)
newinput()
player.move(lvl_1)