def __init__(self, map, scoreboardKey=None):
self.map = map
self.winner = None
self.winCondition = None
self.startTime = time()
self.length = None
self.blueBerriesIn = 0
self.goldBerriesIn = 0
self.blueBerries = []
self.snailLoc = 964
for hole in self.map.blueHoles:
self.blueBerries.append(Berry(hole[0], hole[1], "blue"))
self.goldBerries = []
for hole in self.map.goldHoles:
self.goldBerries.append(Berry(hole[0], hole[1], "gold"))
self.blueEggs = []
for eggLoc in self.map.blueEggLocs:
self.blueEggs.append(
Egg(eggLoc[0], eggLoc[1], color="blue", map=self.map.name))
self.goldEggs = []
for eggLoc in self.map.goldEggLocs:
self.goldEggs.append(
Egg(eggLoc[0], eggLoc[1], color="gold", map=self.map.name))
self.blueQueenLives = 3
self.goldQueenLives = 3
self.complete = False
self.scoreboardKey = scoreboardKey
self.eventLog = "Game Start. Map: " + self.map.name + " Local time: " + str(
round(time(), 2)) + "\n"
def register(self, event, mouse):
if event.type == pygame.KEYDOWN:
key = event.key
if key == pygame.K_a:
self.__left = True
elif key == pygame.K_d:
self.__right = True
if key == pygame.K_w:
self.__up = True
elif key == pygame.K_s:
self.__down = True
if not mouse:
if key == pygame.K_LEFT:
self.__ccwise = True
if key == pygame.K_RIGHT:
self.__cwise = True
if key == pygame.K_SPACE and self.ammo > 0:
self.__eggs.append(
Egg(self.cx - 7,
self.cy - 7,
self.__rotate,
self,
vamp=self.items["vampeggs"]))
self.ammo -= 1
if self.items["doubegg"]:
self.__eggs.append(
Egg(self.cx - 7,
self.cy - 7,
self.__rotate + 180,
self,
vamp=self.items["vampeggs"]))
if mouse and event.type == pygame.MOUSEBUTTONDOWN and self.ammo > 0:
self.__eggs.append(
Egg(self.cx - 7,
self.cy - 7,
self.__rotate,
self,
vamp=self.items["vampeggs"]))
self.ammo -= 1
if self.items["doubegg"]:
self.__eggs.append(
Egg(self.cx - 7,
self.cy - 7,
self.__rotate + 180,
self,
vamp=self.items["vampeggs"]))
if event.type == pygame.KEYUP:
key = event.key
if key == pygame.K_a:
self.__left = False
elif key == pygame.K_d:
self.__right = False
if key == pygame.K_w:
self.__up = False
elif key == pygame.K_s:
self.__down = False
if key == pygame.K_LEFT:
self.__ccwise = False
if key == pygame.K_RIGHT:
self.__cwise = False
def add_egg(self, x, y, xspeed, yspeed):
self.eggs.add(Egg(x, y, xspeed, yspeed))
def doIt(self):
for chick in self.getSamePositionChickens():
self.yard.addEgg(Egg(chick, self.x, self.y, self.yard.day))
def change_level(self, currentLevel, stage):
self.reset_level()
self.level = currentLevel
self.stage = stage
ldata = Lvl_Data(self.level, stage)
self.objective = ldata.objective
self.updated_obj = False ######CHANGED
PM.music.load(ldata.music_file)
PM.music.play(-1)
PM.music.set_volume(0.5)
####turn back on only for presentations?
if self.stage == 1:
Cutscene(Globals.SCREEN, self.level)
#interpretting mapfile.txt
if (self.level > 1):
del self.map
Map.GRASS_ARRAY = []
Map.PAD_ARRAY = []
self.pad_list.empty()
##new map is different than level 1's map, of course.
self.map = Map.Map(ldata.map_file, self.level)
self.camera = cam.Camera(self.map.get_surface())
self.camera_background = None
self.background = self.map.create_background()
self.allsprites.clear(Globals.SCREEN, self.background)
Globals.SCREEN.blit(self.background, (0, 0))
PD.update()
self.num_enemies += self.map.get_num_enemies(1) # icecream
self.num_enemies += self.map.get_num_enemies(2) # burger
self.num_enemies += self.map.get_num_enemies(3) # lettuce
self.num_enemies += self.map.get_num_enemies(4) # cupcake
self.num_enemies += self.map.get_num_enemies(5) # egg
#icecream
for e in range(self.map.get_num_enemies(1)):
icecream = IceCream(self.map.get_enemy_coordx(e, 1),
self.map.get_enemy_coordy(e, 1))
self.icecream_list.add(icecream)
#burger
for e in range(self.map.get_num_enemies(2)):
burger = Burger(self.map.get_enemy_coordx(e, 2),
self.map.get_enemy_coordy(e, 2), self.level)
self.burger_list.add(burger)
#lettuce
for e in range(self.map.get_num_enemies(3)):
lettuce = Lettuce(self.map.get_enemy_coordx(e, 3),
self.map.get_enemy_coordy(e, 3))
self.lettuce_list.add(lettuce)
#cupcake
for e in range(self.map.get_num_enemies(4)):
cupcake = Cupcake(self.map.get_enemy_coordx(e, 4),
self.map.get_enemy_coordy(e, 4))
self.cupcake_list.add(cupcake)
#egg
for e in range(self.map.get_num_enemies(5)):
egg = Egg(self.map.get_enemy_coordx(e, 5),
self.map.get_enemy_coordy(e, 5), self.level)
self.egg_list.add(egg)
self.enemy_list.add(self.icecream_list)
self.enemy_list.add(self.burger_list)
self.enemy_list.add(self.lettuce_list)
self.enemy_list.add(self.cupcake_list)
self.enemy_list.add(self.egg_list)
player_health = 0
#get enemy health
if self.stage > 1:
player_health = self.character.get_health()
self.character = Player(Globals.DELTA)
self.player_group = PS.GroupSingle(self.character)
if self.stage > 1:
self.character.set_health(player_health, True)
#pads
for e in range(len(self.map.padtiles)):
if self.map.pad_type[e] == 0: # hot
newPad = Pad.create_Pad(self.map.get_pad_x(e),
self.map.get_pad_y(e), 0)
self.pad_list.add(newPad)
elif self.map.pad_type[e] == 1:
newPad = Pad.create_Pad(self.map.get_pad_x(e),
self.map.get_pad_y(e), 1)
self.pad_list.add(newPad)
#get block sprite group from the map file
self.block_group = self.map.get_object_group()
#list that holds traps
self.trap_list = []
# self.trap_group = PS.Group()
# self.item_group = PS.Group()
#allsprites has all dirty sprites (player, enemies, traps)
self.allsprites = PS.LayeredDirty(self.trap_group, self.pad_list,
self.item_group, self.player_group,
self.icecream_list, self.burger_list,
self.egg_list, self.lettuce_list,
self.projectile_group)
self.allsprites.clear(Globals.SCREEN, self.background)
####(Level variables)####
Globals.INVINCIBILITY_COUNT = 0 # player's invinicibility frame time
#what kind of enemy by ID (-1 means no enemy) used for collisions
self.enemy_ID = -1
#if true, tells map to update w/o key & door
self.map_modified = False
##temp obj conditions
self.cheesed = True
self.killed = True
self.camera_background = self.camera.update(
self.character.get_coordinates(), self.map.get_surface())
class EggGame(object):
def __init__(self):
pygame.display.set_caption("Egg Collector")
self.obstacleSpeed = 2.0
self.score = 0
self.backgroundColor = (255, 0, 0)
self.dimensions = (900, 600)
self.lastObstacle = None
self.movementSpeed = 5
self.running = True
self.lives = 3
self.fontName = pygame.font.match_font('arial')
self.loadedImages = [pygame.image.load("GameImages/background.jpg")]
self.clock = pygame.time.Clock()
def drawBackground(self, screen):
screen.blit(self.loadedImages[0], (0, 0))
def generateObstacles(self):
self.lastObstacle = Egg(random.randint(25, 875), 25)
def destroyObstacle(self):
self.lastObstacle = None
def drawText(self, surf, text, size, x, y):
font = pygame.font.Font(self.fontName, size)
textSurface = font.render(text, True, (0, 0, 0))
textRect = textSurface.get_rect()
textRect.midtop = (x, y)
surf.blit(textSurface, textRect)
def main(self):
pygame.init()
screen = pygame.display.set_mode(self.dimensions)
pygame.display.flip()
player = Player(430, 550)
while self.running:
# Frame Rate
self.clock.tick(100)
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
keys = pygame.key.get_pressed()
# Move player right
if keys[pygame.K_RIGHT]:
player.controlPlayer(self.movementSpeed, 850)
# Move player left
if keys[pygame.K_LEFT]:
player.controlPlayer(self.movementSpeed * -1, 850)
# Draw game background
self.drawBackground(screen)
# Generate obstacles if no obstacles are present on screen
if self.lastObstacle == None:
self.generateObstacles()
else:
self.lastObstacle.propagate(self.obstacleSpeed)
# If player collides with egg increment score
if player.checkCollision(self.lastObstacle):
self.score += 1
self.destroyObstacle()
# If obstacle hits ground, decrement life
elif self.lastObstacle.checkOutOfBoundary(self.dimensions[1]):
self.lives -= 1
self.destroyObstacle()
else:
self.lastObstacle.drawCharacter(screen)
# Exit Game if lives = 0
if self.lives == 0:
self.running = False;
# Draw character on screen
player.drawCharacter(screen)
self.drawText(screen, "Score: " + str(self.score), 20, 700, 100)
self.drawText(screen, "Lives: " + str(self.lives), 20, 100, 100)
pygame.display.update()
def generateObstacles(self): self.lastObstacle = Egg(random.randint(25, 875), 25)
class EggGame(object):
def __init__(self):
pygame.display.set_caption("Egg Collector")
self.obstacleSpeed = 2.0
self.score = 0
self.backgroundColor = (255, 0, 0)
self.dimensions = (900, 600)
self.lastObstacle = None
self.movementSpeed = 5
self.running = True
self.lives = 3
self.generationCount = 1
self.fontName = pygame.font.match_font('arial')
self.loadedImages = [pygame.image.load("GameImages/background.jpg")]
self.players = [Player(430, 550) for i in range(0, 500)]
self.clock = pygame.time.Clock()
self.stopgen = False
def drawBackground(self, screen):
screen.blit(self.loadedImages[0], (0, 0))
def generateObstacles(self):
self.lastObstacle = Egg(random.randint(25, 875), 25)
def destroyObstacle(self):
self.lastObstacle = None
def drawText(self, surf, text, size, x, y):
font = pygame.font.Font(self.fontName, size)
textSurface = font.render(text, True, (0, 0, 0))
textRect = textSurface.get_rect()
textRect.midtop = (x, y)
surf.blit(textSurface, textRect)
def moveAllPlayersBasedOnPredictions(self):
if self.lastObstacle != None:
for player in self.players:
prediction = player.predict(np.array([self.lastObstacle.x, self.lastObstacle.x - player.x]))
maxIndex = prediction.index(max(prediction))
if maxIndex == 0:
player.controlPlayer(self.movementSpeed * -1, 850)
elif maxIndex == 1:
player.controlPlayer(self.movementSpeed, 850)
def drawAllPlayers(self, canvas):
for player in self.players:
player.drawCharacter(canvas)
def checkCollision(self):
if self.lastObstacle != None:
for player in self.players:
if player.checkCollision(self.lastObstacle):
player.score += 1
def BuildNextGeneration(self):
self.generationCount += 1
newPlayers = []
self.players.sort(key=lambda x: x.score, reverse = True)
if len(self.players) < 5:
with open('inputWeights', 'wb') as fp:
pickle.dump(self.players[0].inputWeights.tolist(), fp)
with open('outputWeights', 'wb') as fp:
pickle.dump(self.players[0].outputWeights.tolist(), fp)
self.stopgen = True
# Keep 1 top scorer as it is
self.players[0].x = 430
#self.players[1].x = 430
self.players[0].score = 0
#self.players[1].score = 0
newPlayers.append(self.players[0])
#newPlayers.append(self.players[1])
if not self.stopgen:
bestTwo = Player(430, 550)
bestTwo.crossOver(self.players[0], self.players[1])
newPlayers.append(bestTwo)
bestAndWorst = Player(430, 550)
bestAndWorst.crossOver(self.players[0], self.players[len(self.players) - 1])
newPlayers.append(bestAndWorst)
for i in range(0, len(self.players) - 53):
par1 = self.players[random.randint(0, len(self.players)-1)]
par2 = self.players[random.randint(0, len(self.players)-1)]
child = Player(430, 550)
child.crossOver(par1, par2)
newPlayers.append(child)
self.players = newPlayers
self.restart()
def getMaxScoreForGeneration(self):
max_score = 0
for player in self.players:
if player.score > max_score:
max_score = player.score
return max_score
def restart(self):
self.lastObstacle = None
self.lives = 3
def main(self):
pygame.init()
screen = pygame.display.set_mode(self.dimensions)
pygame.display.flip()
while self.running:
# Frame Rate
self.clock.tick(1000)
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
self.moveAllPlayersBasedOnPredictions()
# Draw game background
self.drawBackground(screen)
# Generate obstacles if no obstacles are present on screen
if self.lastObstacle == None:
self.generateObstacles()
else:
self.lastObstacle.propagate(self.obstacleSpeed)
# If obstacle hits ground, decrement life
if self.lastObstacle.checkOutOfBoundary(self.dimensions[1]):
self.lives -= 1
self.destroyObstacle()
else:
self.lastObstacle.drawCharacter(screen)
self.checkCollision()
# Exit Game if lives = 0
#if self.lives == 0:
# self.running = False;
if self.lives < 0 and self.stopgen == False:
self.BuildNextGeneration()
# Draw character on screen
self.drawAllPlayers(screen)
self.drawText(screen, "Generation: " + str(self.generationCount), 20, 700, 100)
self.drawText(screen, "Lives: " + str(self.lives), 20, 100, 100)
pygame.display.update()
def tick(self):
if self.__x != self.__player.getX():
self.__x += (self.__player.getX() - self.__x) / abs(
self.__player.getX() - self.__x) * min(
self.__speed, abs(self.__player.getX() - self.__x))
if self.__y != self.__player.getY():
self.__y += (self.__player.getY() - self.__y) / abs(
self.__player.getY() - self.__y) * min(
self.__speed, abs(self.__player.getY() - self.__y))
self.coll = pygame.Rect(self.__x, self.__y, self.__size, self.__size)
self.__cx = self.__x + self.__size / 2
self.__cy = self.__y + self.__size / 2
if self.coll.colliderect(self.__player.coll):
self.__player.takeDamage(1)
self.die()
return
hit = False
for i in self.__player.getEggs()[:]:
if self.coll.colliderect(i.coll):
self.__img = self.hurtimg
hit = True
if i not in self.hitEggs[:]:
self.__hp -= self.__player.atk
if self.__player.items['vampeggs']:
self.__player.hp = min(
self.__player.maxhp,
self.__player.hp + self.__player.atk / 4)
if self.__player.items["eggsplit"] and not i.split:
e1 = Egg(self.__cx - 7,
self.__cy - 7,
i.angle + 45,
self.__player,
vamp=self.__player.items["vampeggs"],
split=True)
e2 = Egg(self.__cx - 7,
self.__cy - 7,
i.angle + 135,
self.__player,
vamp=self.__player.items["vampeggs"],
split=True)
e3 = Egg(self.__cx - 7,
self.__cy - 7,
i.angle - 45,
self.__player,
vamp=self.__player.items["vampeggs"],
split=True)
e4 = Egg(self.__cx - 7,
self.__cy - 7,
i.angle - 135,
self.__player,
vamp=self.__player.items["vampeggs"],
split=True)
self.__player.addEggs(e1)
self.hitEggs.append(e1)
self.__player.addEggs(e2)
self.hitEggs.append(e2)
self.__player.addEggs(e3)
self.hitEggs.append(e3)
self.__player.addEggs(e4)
self.hitEggs.append(e4)
if not self.__player.items['eggpen'] and (
not i.split or i not in self.hitEggs[:]):
self.__player.getEggs().remove(i)
self.hitEggs.append(i)
if self.__hp <= 0:
self.die()
return
for i in self.hitEggs[:]:
if i not in self.__player.getEggs():
self.hitEggs.remove(i)
yes = False
for i in self.__player.shieldEggs:
if self.coll.colliderect(i.coll):
self.__img = self.hurtimg
if not self.hitShields:
self.__hp -= self.__player.atk * 3
self.hitShields = True
yes = True
if not yes:
self.hitShields = False
else:
hit = True
if self.__hp <= 0:
self.die()
return
if not hit:
self.__img = self.normimg