def test_is_alive(self):
enemy1 = Enemy(100, 200, 30)
enemy2 = Enemy(100, 200, 30)
enemy2.__dict__["health"] = 0
self.assertTrue(enemy1.is_alive())
self.assertFalse(enemy2.is_alive())
def __init__(self):
# initialize game window, etc
pg.init()
pg.mixer.init()
# dimension of window
self.winWidth = 500
self.winLength = 281
# window set-up
self.screen = pg.display.set_mode(size=(self.winWidth, self.winLength))
pg.display.set_caption("Shinobi Warrior")
self.keys = pg.key.get_pressed()
self.clock = pg.time.Clock()
self.background_no = 1
self.last_update = 0
self.playing = False
self.running = True
self.score = 0
self.font2 = pg.font.Font('../fonts/Bank_Gothic_Medium_BT.ttf', 15)
self.font = pg.font.Font('../fonts/Bank_Gothic_Medium_BT.ttf', 20)
self.red = Enemy(420, 188)
self.health_bar = pg.sprite.Group()
self.enemies = pg.sprite.Group()
self.kunais = pg.sprite.Group()
self.red = Enemy(420, 188)
self.health_bar.add(Health(30, 10))
self.health_bar.add(Health(60, 10))
self.health_bar.add(Health(90, 10))
self.enemies.add(self.red)
self.kunais.add(Kunai())
def run_game():
pygame.init()
pygame.font.init()
screen = pygame.display.set_mode((500, 500))
pygame.display.set_caption("Goomba")
goomba = Enemy(screen, 50, 50, "Goomba")
screenrect = screen.get_rect()
koopa = Enemy(screen, 100, 100, "Koopa")
while True:
screen.fill((255, 255, 255))
goomba.update()
goomba.blitme()
koopa.update()
koopa.blitme()
pygame.display.flip()
if goomba.rect.left < screenrect.left:
goomba.collide()
elif goomba.rect.right > screenrect.right:
goomba.collide()
if koopa.rect.left < screenrect.left:
koopa.collide()
elif koopa.rect.right > screenrect.right:
koopa.collide()
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
if not koopa.alive:
koopa.hit_shell()
print("DIE!")
goomba.death()
koopa.death()
def placeEnemies(BombermanBoard): # Place enemies on the board
for i in range(0, MAX_ENEMY):
block = Enemy(BombermanBoard.height, BombermanBoard.width)
while not BombermanBoard.placeObject(block.x_pos, block.y_pos, EM):
block = Enemy(BombermanBoard.height, BombermanBoard.width)
# Append the enemies to the alive enemy list
EnemyList.append(block)
def createEnemy(self):
for i in range(self.EnemyCount):
direction = random.choice([1, -1])
if 4 - i > 1:
enemy = Enemy(4 - i, direction, 1)
else:
enemy = Enemy(2, direction, 1)
self.EnemyList.append(enemy)
for j in range(self.EnemyPieceCount):
if direction == -1:
if j == 0:
self.EnemyList[i].pieces.append(EnemyPiece(self.screenwidth + (j - 1) * 25, (i + 2) * 25, "Head", 0, direction, 1))
else:
self.EnemyList[i].pieces.append(EnemyPiece(self.screenwidth + (j - 1) * 25, (i + 2) * 25, "Tail", 0, direction, 1))
elif direction == 1:
if j == 0:
self.EnemyList[i].pieces.append(EnemyPiece((-j) * 25, (i + 2) * 25, "Head", 180, direction, 1))
else:
self.EnemyList[i].pieces.append(EnemyPiece((-j) * 25, (i + 2) * 25, "Tail", 180, direction, 1))
self.EnemyFeetSprites.add(self.EnemyList[i].pieces[-1].feet)
self.levelSprites.add(self.EnemyList[i].pieces[-1].feet)
self.EnemyPieces.add(enemy.pieces)
self.levelSprites.add(enemy.pieces)
def move_hero(self, direction):
direction = direction.lower()
x = self.hero_position_X
y = self.hero_position_Y
if direction == 'up':
x -= 1
if direction == 'down':
x += 1
if direction == 'left':
y -= 1
if direction == 'right':
y += 1
if x in range(0, self.X) and y in range(0, self.Y):
enemy = Enemy(self.level * 15, self.level * 10)
fight = Fight(self.hero, enemy, self.tmp_map, self.X, self.Y)
if self.tmp_map[x][y] != '#':
self.hero.take_mana()
if self.tmp_map[x][y] == 'T':
self.treasure_found()
if self.tmp_map[x][y] == 'E':
enemy = Enemy(self.level * 15, self.level * 10)
fight.fight()
self._update_tmp_map(x, y)
if self.hero.can_cast():
fight.remote_battle(x, y)
return True
else:
print('Invalid. Your move was out of the map!')
return False
def main():
entity_table = [
Player(100, 0, "player.dat"),
Enemy("Knight", 15, 0, "boss.dat"),
Enemy("Guard", 15, 0, "boss2.dat")
]
game = GameGui(entity_table)
game.run()
def test(self, move, B, P):
if self.name == "Start":
if move == "start game":
self.body[0] = True
print("You see two marauding goblins approaching! \n")
print("Type '(a)ttack' to fight them, before they get you!")
B.enemies = [
Enemy("Goblin1", "Goblin"),
Enemy("Goblin2", "Goblin")
]
B.Done = False
if self.name == "Forest":
if P.pos == "forest":
self.body[0] = True
print("A large figure approaches you.")
print("Goblin King: I am the king of these lands.")
print(
"Goblin King: If you wish to stay alive, you must complete my quests."
)
print("Type '(t)alk' to talk whoever is in your location. \n")
if self.name == "Goblin King":
if B.King.hp <= 0:
print("You have defeated the Goblin King!")
time.sleep(5)
print("Epilogue:")
time.sleep(3)
print("The goblin village has gotten a bit better.")
time.sleep(3)
print("But it is slightly melancholic.")
time.sleep(3)
print("You have killed the king, but for what.")
time.sleep(3)
print("All he ever wanted was a friend.")
time.sleep(3)
print("He had started to think that maybe you were a friend.")
time.sleep(3)
print("You think that he needed you to go on those quests?")
time.sleep(3)
print("No.")
time.sleep(3)
print("He just wanted to build a friendship.")
time.sleep(3)
print("And you killed him.")
time.sleep(3)
print("I hope you're happy with you 'decision'.")
time.sleep(3)
exit()
def run_game():
global frame
# ** -- INIT ALL PYGAME STUFF -- **
pygame.init()
# ** -- set up a tuple for the screen size, horiz, vert -- **
screen_size = (1000, 800)
# ** -- setting background color with RGB -- **
background_color = (Red, Green, Blue)
# if (frame % 600 == 0):
# background_color = (randint(0,255), randint(0,255), randint(0,255))
# ** -- create screen size -- **
screen = pygame.display.set_mode(screen_size)
# ** -- set a caption on terminal window -- **
pygame.display.set_caption("A Heroic 3rd Person Shooter")
the_player = Player(screen, './images/Hero.png', 100, 100)
bad_dude = Enemy(screen)
the_player_group = Group()
the_player_group.add(the_player)
enemies = Group()
enemies.add(bad_dude)
bullets = Group()
# ** -- Main game loop. Run forever or until break -- **
while 1:
frame += 1
if (frame % 100 == 0):
enemies.add(Enemy(screen))
# ** -- Fill screen with background color -- **
screen.fill(background_color)
if (frame % 3600 == 0):
background_color = (randint(0,255), randint(0,255), randint(0,255))
# snail_rave(screen,frame,background_color)
# ** -- the escape hatch (from while) -- **
check_events(screen,the_player,bullets)
# clear the screen for the next time through the loop
for player in the_player_group:
the_player.draw_me()
for bad_dude in enemies:
bad_dude.draw_me()
bad_dude.update_me(the_player)
# update and draw the bullets
for bullet in bullets:
bullet.draw_bullet()
bullet.update()
hero_died = groupcollide(the_player_group,enemies,True,False)
bullet_death = groupcollide(bullets,enemies,True,True)
pygame.display.flip()
def run_game():
#Init all pygame stuff
pygame.init() #pygame is an object and init() is a method
#Set up a tuple for the screen_size(horiz, vert)
screen_size = (1000, 800)
#Set up a tuple for the background color
background_color = (82, 111, 53) #RGB
#Create a pygame screen to use
screen = pygame.display.set_mode(
screen_size) #set_mode is looking for a tuple from the pygame docs
#Set a caption on the terminal window
pygame.display.set_caption("A Heroic 3rd Person Shooter")
the_player = Player(screen, "./images/Hero.png", 100, 100)
bad_guy = Enemy(screen)
the_player_group = Group()
the_player_group.add(
the_player) #"add" is like append since this is owned by pygame
enemies = Group()
enemies.add(bad_guy)
bullets = Group()
tick = 0
#Main game loop. Run forever... (or until break)
while 1: #use "while 1" if the code is fairly simple (game_on = True for more complex)
tick += 1
if tick % 50 == 0:
enemies.add(Enemy(screen))
screen.fill(background_color)
check_events(the_player, screen, bullets)
#Draw the player
for player in the_player_group: #player will only be drawn based on hero_died below
player.draw_me()
#Update and draw the bullets
for bullet in bullets:
bullet.update()
bullet.draw_bullet()
#Update and draw the bad guy
for bad_guy in enemies:
bad_guy.update_me(the_player)
bad_guy.draw_me()
#Check for collisions...
hero_died = groupcollide(the_player_group, enemies, True,
False) #will make hero die when they collide
# print hero_died
groupcollide(bullets, enemies, True, True)
#Clear the screen for the next time through the loop
pygame.display.flip()
def make_entity(self):
choice = random.randint(1, 100)
if choice <= 3:
self.entities.append(
Powerup(p_up_path, (e1_init_x, e_PU_init_y),
self.ground.speed))
return
elif choice <= 10:
self.entities.append(
Enemy(enemy_RS_path, (e2_init_x, e_RS_init_y),
self.ground.speed))
self.entities.append(
Enemy(enemy_RS_path, (e1_init_x, e_RS_init_y), self.ground.speed))
def create_world():
global pacman, ghost, item_set, world_map, font_guide, font_life
pacman = Player()
ghost = [
Enemy(35, 565, 1),
Enemy(565, 35, 2),
Enemy(565, 565, 3),
Enemy(350, 390, 4)
]
# item_set = [item(100, 100, 0), item(200, 200, 0), item(300, 300, 0), item(400, 400, 0)
# ,item(100, 200, 4), item(200, 300, 5), item(300, 400, 6), item(400, 500, 7)]
world_map = map()
font_guide = load_font('resource/Pixel.ttf', 30)
font_life = load_font('resource/CrackMan.ttf', 30)
def setBoard():
walls = Walls()
bricks = Brick()
player = Player()
bmb = Bomb()
Enemy.instances = [] # Previous game's Enemies are destroyed
Board.board = [[' ' for j in range(0, 68)] for i in range(0, 34)]
Board.board = walls.buildWalls(Board.board)
Board.board = player.putBlock(Board.board, 2, 4)
Board.board = bricks.placeRandom(Board.board, 15)
# New Enemies are created here
enemy1 = Enemy(Board.board, placeRandom())
enemy2 = Enemy(Board.board, placeRandom())
enemy3 = Enemy(Board.board, placeRandom())
return [player, bmb]
def generate(self):
if self.wait_time_counter < self.enemy_rate:
self.wait_time_counter += 1
else:
self.male = not self.male
self.wait_time_counter = 0
return Enemy(self.x, self.y, self.male)
def makeAsteroids(speed, counter, group):
if counter == 0:
# THIS IS ONLY IF NO GRAPHICS ARE USED:
###wrnd = random.randint(12, 36)
###hrnd = random.randint(12, 36)
#setting asteroid, x-pos, y-pos, velocity(vertical)
vyrnd = random.randint(1, 4)
vxrnd = (random.randint(0, 40) / 10) - 2
arnd = random.choice(
[AST_SMALL, AST_SMALL, AST_SMALL, AST_MED, AST_MED, AST_BIG])
asteroid = Enemy(BLACK, 0, 0)
asteroid.convertToPic(arnd, 1)
asteroid.rotate(random.randint(0, 359))
xrnd = random.randint(asteroid.rect.w, WINDOWWIDTH - asteroid.rect.w)
y = -asteroid.rect.h
asteroid.setCenterPos(xrnd, y)
asteroid.moveY(-vyrnd)
asteroid.moveX(vxrnd)
group.add(asteroid)
counter += 1
elif counter >= speed:
counter = 0
else:
counter += 1
return counter
def run_game(self):
'''
This method implements a single game frame.
It will work depends on
'''
if self.__current_game_state is GAME_MENU:
try:
if self.__game_start_mode is LOAD_GAME:
player_position, dungeon_map = DungeonGameSaveLoad.load_game()
self.__dungeon_map.init_from_load(player_position, dungeon_map)
else:
map_size = int(input('Map size (>= 5): '))
self.__dungeon_map.generate_new_map(map_size)
except NoSavedDataFileError as error:
logging.error(f'User have chosen to load the game but we can\'t find game save data on address:\
{error}.')
logging.info('Sorry, but there is no game save data. Please, save the game firstly or find the\
save data file.')
self.process_game_start()
else:
self.__character = Character('User', DungeonGameConfig.PLAYER_HP, self.__dungeon_map)
self.__enemy = Enemy('Enemy', self.__character, self.__dungeon_map)
self.__current_game_state = GAMEPLAY
self.__update_list.add_children(self.__dungeon_map, self.__character)
self.__enemy.start_moving()
elif self.__current_game_state is GAMEPLAY:
logging.info(f'Current character stats: hp - {self.__character.get_hp()}, num of treasures - \
{self.__character.get_treasures_number()}')
self.__update_list.update()
def event_handling(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
sys.exit(0)
if not self.paused:
if event.type == self.ENEMY_SPRITE_INTERVAL:
self.enemy_group.update("INTERVAL", self.rate)
elif event.type == self.ENEMY_SPAWN_INTERVAL:
new_group = Enemy()
self.enemy_group.add(new_group)
self.player.update_dir("mid") # normally keep dir to mid
elif event.type == pygame.MOUSEMOTION: # player movement
self.player_mechanics()
if event.type == KEYDOWN:
if event.key == pygame.K_ESCAPE:
print("game paused")
if not self.paused:
self.paused = True
pygame.mouse.set_visible(True)
pygame.time.set_timer(self.ENEMY_SPAWN_INTERVAL, 0)
else:
self.paused = False
pygame.mouse.set_visible(False)
pygame.time.set_timer(self.ENEMY_SPAWN_INTERVAL,
self.current_spawn_rate)
def NextLevel(self):
self.Enm.stopMovement = True
self.Lvl = self.Lvl + 1
self.canvas.itemconfig(self.image_id, image=self.images[1])
self.LinesPropertiesY.clear()
self.LinesPropertiesX.clear()
self.LinesPropertiesY.append(('y', 6, 6, 608, False))
self.LinesPropertiesY.append(('y', 608, 6, 608, False))
self.LinesPropertiesX.append(('x', 6, 6, 608, False))
self.LinesPropertiesX.append(('x', 608, 6, 608, False))
self.AllPoints.clear()
self.AllPoints = [(6, 6, True), (608, 6, True), (608, 608, True), (6, 608, True)]
self.canvas.delete(self.Shp.MainLn)
del self.Shp
MainLn = self.canvas.create_polygon(6, 6, 608, 6, 608, 608, 6, 608, 6, 6, fill='grey', width=1)
self.Shp = Shape(MainLn, self)
self.Plr.Player.pack_forget()
self.Plr.Player.destroy()
frmPlayer = tk.Frame(self.canvas, bg='#FF0000')
self.Plr = Player(frmPlayer, self)
self.Enm.EnemyV.pack_forget()
self.Enm.EnemyV.destroy()
frmEnemy = tk.Frame(self.canvas, bg='#00FF00')
self.Enm = Enemy(frmEnemy, self)
def createLevel():
GameState.clean()
GameState.level += 1
stairUp = Item("stairs_up.png", (SCALE, SCALE), GameState.triggerLoad)
GameState.dynamics.add(stairUp)
playerPos = None
maze = genMaze(MAPSIZE+GameState.level)
floors = sum(sum(maze.data))
spawns = [lambda pos: HealItem(pos, 1) for _ in range(int(0.02*floors))]
spawns += [lambda pos: Enemy("enemy_placeholder.png", pos) for _ in range(int(0.05*floors))]
for x in range(maze.M+2):
for y in range(maze.N+2):
if not maze[x-1,y-1]:
GameState.statics.add(Sprite(wallimg, (x*SCALE, y*SCALE)))
elif playerPos is None:
playerPos = x*SCALE, y*SCALE
elif random.random() < .01 and x < maze.M/2 and y < maze.N:
playerPos = x*SCALE, y*SCALE
else:
if random.random() < max(len(spawns)/floors, .05) and spawns:
i = random.randrange(len(spawns))
GameState.dynamics.add(spawns[i]((x*SCALE,y*SCALE)))
del spawns[i]
floors -= 1
stairUp.rect.x, stairUp.rect.y = x*SCALE, y*SCALE
GameState.initBackground()
GameState.player.rect.topleft = playerPos
def StartGame(self, cpu: bool) -> None:
"""Transitions from not started to started."""
if self.game_not_started:
self.game.player = Player(
1, (CANVAS_WIDTH // 2 - STARTING_OFFSET, FLOOR_HEIGHT + 10),
FLOOR_HEIGHT)
if cpu:
self.game.enemy = Enemy(
2,
(CANVAS_WIDTH // 2 + STARTING_OFFSET, FLOOR_HEIGHT + 10),
FLOOR_HEIGHT)
self.game.interface.hud.SetEnemyText("CPU")
else:
self.game.enemy = Player(
2,
(CANVAS_WIDTH // 2 + STARTING_OFFSET, FLOOR_HEIGHT + 10),
FLOOR_HEIGHT)
self.game.interface.hud.SetEnemyText("Player 2")
self.game_not_started = False
self.game_started = True
self.game.time_remaining = 30
self.game.timer.start()
self.game.environment = Environment(
"assets/background" + str(random.choice(range(3)) + 1) +
".png", (1600, CANVAS_HEIGHT), 1.0)
def enemies_load(self): for p in self.map: if p['code'] == 'e': e = Enemy() e.rect.x = p['x'] e.rect.y = p['y'] self.enemies.add(e)
def gleft(self, player):
self.root.destroy()
self.does(player, Enemy(player.level))
self.pos[0] -= 1
self.x = self.pos[0] * 100 + 100
self.y = 400 - self.pos[1] * 100
self.move(player, 1)
def nextLevel(self): self.wave_length += 5 for i in range(self.wave_length): enemy = Enemy(random.randrange(0, self.WIDTH - 50), random.randrange(-1500, -100), random.choice(["red", "blue", "green"])) self.enemies.append(enemy)
def spawn_enemy():
global all_entities
#print(variables.time - variables.start_time)
diff = variables.time - variables.start_time
if diff > 20:
if diff < 60:
a = random.randint(1, 6)
else:
a = random.randint(1, 4)
if a == 1:
enemy = EnemyT2()
else:
enemy = Enemy()
else:
enemy = Enemy()
enemy.spawn()
def generate(self, lvl, enemy_type):
enemy = Enemy()
if enemy_type == self.LIGHT:
enemy.hp = 25 + (lvl * 5)
enemy.lvl = lvl
enemy.damage = 10 * lvl
enemy.exp_reward = 10 * lvl
enemy.gold_reward = 3 * lvl
enemy.battle_difficulty = 1
elif enemy_type == self.MEDIUM:
enemy.hp = 45 + (lvl * 5)
enemy.lvl = lvl
enemy.damage = 5 * lvl
enemy.exp_reward = 15 * lvl
enemy.gold_reward = 5 * lvl
enemy.battle_difficulty = 2
elif enemy_type == self.HARD:
enemy.hp = 65 + (lvl * 5)
enemy.lvl = lvl
enemy.damage = 7 * lvl
enemy.exp_reward = 30 * lvl
enemy.gold_reward = 7 * lvl
enemy.battle_difficulty = 3
elif enemy_type == self.BOSS:
enemy.hp = 95 + (lvl * 5)
enemy.lvl = lvl
enemy.damage = 10 * lvl
enemy.exp_reward = 50 * lvl
enemy.gold_reward = 10 * lvl
enemy.battle_difficulty = 4
return enemy
def main():
fighter = Fighter()
info = Info()
enemy = Enemy()
bullet = Bullet()
game = Game(fighter, info, enemy, bullet)
game.run()
def loop(e): global characterLayer, loopIndex, loopSpeed, start, enemyNum, max_num_enemy if not start: return # control the speed of adding enemy loopIndex += 1 if loopIndex < loopSpeed: return loopIndex = 0 # control the number of enemy if enemyNum >= max_num_enemy: start = False max_num_enemy += 5 return # add a enmey enemy = Enemy(dataList["soldier2_mov"], 1, 15) characterLayer.addChild(enemy) Enemy.enemyList.append(enemy) enemyNum += 1 # add customized events enemy.addEventListener(Enemy.EVENT_DIE, enemyDie) enemy.addEventListener(Enemy.EVENT_ARRIVE, enemyArrive)
def __init__(self, debug_mode=False):
self.debug_mode = debug_mode
# to calcurate frame per second
self._time = time.time()
self.fps = 30
pyxel.init(width=250, height=200, caption="STG", scale=3, fps=30)
pyxel.load("../asset.pyxres")
self.player = Player(sx=100,
sy=150,
width=10,
height=10,
speed=2,
debug_mode=self.debug_mode)
self.player.activate()
self.enemies = []
for i in range(20):
e = Enemy(sx=100,
sy=0,
height=10,
width=10,
speed=0.5,
max_hp=10,
idx=i,
debug_mode=self.debug_mode)
e.activate()
self.enemies.append(e)
self.particles = []
self.back_ground = BackGround()
pyxel.run(self.update, self.draw)
def new(self):
try:
self.mapPath = os.path.join("../assets/", "stage1.tmx")
self.map = mapLoader(self.mapPath)
except:
self.mapPath = os.path.join("assets/", "stage1.tmx")
self.map = mapLoader(self.mapPath)
self.map.makeMap()
self.mapRect = self.map.terrainLayer.get_rect()
self.grounds = pygame.sprite.Group()
self.enemies = pygame.sprite.Group()
self.bullets = pygame.sprite.Group()
self.cameraCenter = (0, (-self.mapRect.height + SCREEN_SIZE[1]) *
TILESCALE)
self.camera = Camera(self.mapRect.width, self.mapRect.height,
self.cameraCenter)
for obj in self.map.tmdata.objects:
if obj.name == 'ground':
self.grounds.add(
Ground(obj.x * TILESCALE, obj.y * TILESCALE,
obj.width * TILESCALE, obj.height * TILESCALE))
elif obj.name == 'goal':
self.goal = (obj.x * TILESCALE, obj.y * TILESCALE)
elif obj.name == 'player':
self.player = Player(obj.x * TILESCALE, obj.y * TILESCALE,
self.screen)
self.player.moveAhead = True
elif obj.name == 'enemy1':
self.enemies.add(
Enemy(obj.x * TILESCALE, obj.y * TILESCALE, self.screen))
def spawn_one_enemy(self):
"""
Spawn one enemy with random type and random position
"""
import random
from common import Util
if self.last_group_end_time is not None and \
time.time() - self.last_group_end_time < self.scene_conf['time_between_enemy_group']:
return
if self.already_spawn_count >= self.scene_conf['enemy_group_num'][self.spawn_group_id]:
return
self.already_spawn_count += 1
# random prefab
enemy_prefabs = self.enemy_conf['enemy_prefab']
enemy_prefab_idx = Util.get_random_index_with_distribution(self.scene_conf['enemy_spawn_distribution'])
# random spawn transform
spawn_transforms = self.scene_conf['enemy_spawn_transforms']
spawn_transform_idx = random.randint(0, len(spawn_transforms) - 1)
spawn_transform = deepcopy(spawn_transforms[spawn_transform_idx])
# create enemy
ep = enemy_prefabs[enemy_prefab_idx]
eid = self.generate_enemy_id()
enemy = Enemy(eid, spawn_transform[0:3], spawn_transform[3:6], deepcopy(self.scene_conf['target_position']), ep)
self.enemies[eid] = enemy
# send spawn message
spawn_msg = enemy.generate_spawn_msg()
self.broadcast(spawn_msg)
