class Game:
def __init__(self, preference):
self.preference = preference
self.display = pygame.display.set_mode(preference.display)
pygame.display.set_caption("Bricks")
# Game Properties
self.running = True
self.bricks = pygame.sprite.Group()
self.wall = Wall(self)
self.bullet = Bullet(self)
pygame.init()
self.start()
self.main_loop()
def main_loop(self):
def update():
self._update()
self._flip()
while self.running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
if event.type == pygame.KEYUP and event.key == pygame.K_r:
self.start()
update()
def start(self):
brick = self.preference.brick
margin = self.preference.margin
self.bricks = pygame.sprite.Group()
self.wall = Wall(self)
self.bullet = Bullet(self)
for x in range(self.preference.army[0]):
for y in range(self.preference.army[1]):
b = Brick(self,
x * (brick[0] + margin[0]) + margin[0],
y * (brick[1] + margin[1]) + margin[1])
self.bricks.add(b)
def _update(self):
self.wall.update()
self.bricks.update()
self.bullet.update()
def _flip(self):
self.display.fill((255, 255, 255))
self.wall.draw()
self.bullet.draw()
for brick in self.bricks:
brick.draw()
pygame.display.flip()
def main():
terminal.open()
terminal.set('input.filter=[keyboard, close]')
wl = Wall(FIELD_WIDTH, FIELD_HEIGHT, '+')
wl.draw()
snk = Snake(size=4)
snk.draw()
food = food_creator(snk)
food.draw()
terminal.refresh()
while terminal.peek() != terminal.TK_CLOSE:
if terminal.has_input():
snk.change_direction(terminal.read())
if snk.collision(wl) or snk.collision(snk):
break
if snk.collision(food):
snk.eat(food)
food = food_creator(snk)
food.draw()
else:
snk.move()
terminal.refresh()
terminal.delay(100)
if not terminal.has_input():
game_over()
terminal.read()
terminal.close()
#Sets clock (used for fixed FPS) and timer (used to count collision rate)
clock = pygame.time.Clock()
pygame.time.set_timer(pygame.USEREVENT + 1, 1000)
info = Info(settings, screen)
info.prep_collisions()
keepGoing = True
while keepGoing:
clock.tick(30) #30 FPS
events.check_events(screen, settings, particles, info, wall)
particles.clear(screen, background)
for particle in particles:
particle.update(wall) #updates vel and pos
if particle.collision:
info.collision_rate += 1
particle.collision = False
screen.fill(settings.bg_color) #cleans screen
particles.draw(screen)
wall.draw(screen)
info.prep(wall, total_kinetic_energy(particles), len(particles))
info.show()
pygame.display.flip()
__main__()
def main():
width, height = 1000, 500
win_main = pygame.display.set_mode((width, height))
win1 = pygame.Surface((width / 2, height))
win2 = pygame.Surface((width / 2, height))
pygame.display.set_caption("Raytracing")
fps = 30
clock = pygame.time.Clock()
part = Particle((width / 4, height / 2))
walls = []
scene = []
num_walls = 5
# Add boundary walls
walls.append(Wall((0, 0), (width / 2, 0)))
walls.append(Wall((width / 2, 0), (width / 2, height)))
walls.append(Wall((width / 2, height), (0, height)))
walls.append(Wall((0, height), (0, 0)))
# Add Walls randomly to the screen
for i in range(num_walls):
x1 = randint(0, width / 2)
y1 = randint(0, height)
x2 = randint(0, width / 2)
y2 = randint(0, height)
wall = Wall((x1, y1), (x2, y2))
walls.append(wall)
# Game Loop
while True:
clock.tick(fps)
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
# Input
keys = pygame.key.get_pressed()
rot_speed = 2
move_speed = 5
if keys[pygame.K_LEFT]:
part.rotate(-rot_speed)
if keys[pygame.K_RIGHT]:
part.rotate(rot_speed)
if keys[pygame.K_UP]:
x_vel = cos(radians(part.hdg)) * move_speed
y_vel = sin(radians(part.hdg)) * move_speed
part.move(x_vel, y_vel)
if keys[pygame.K_DOWN]:
x_vel = cos(radians(part.hdg)) * -move_speed
y_vel = sin(radians(part.hdg)) * -move_speed
part.move(x_vel, y_vel)
# Logic
part.clean()
scene = part.get_dists()
m_pos = pygame.mouse.get_pos()
# part.pos = m_pos
part.update()
part.look_at(walls)
# Rendering
win1.fill((0, 0, 0))
win2.fill((0, 0, 0))
part.draw(win1)
for wall in walls:
wall.draw(win1)
for i in range(len(scene)):
color = map_val(scene[i]**2, 0, (width / 2)**2, 255, 0)
w = (width / 2) / len(scene)
h = map_val(scene[i], 0, width / 2, height, 0)
x = (i * w) - (w / 2)
y = height / 2 - h / 2
pygame.draw.rect(win2, (color, color, color), (x, y, w + 1, h))
# Render surfaces to main window
win_main.blit(win1, (0, 0))
win_main.blit(win2, (width / 2 + 1, 0))
pygame.display.update()
class Scene:
def __init__(self):
self.lblScore = pyglet.text.Label('Score: 0',
font_name='Arial',
font_size=12,
x=15,
y=5,
anchor_x='left',
anchor_y='bottom')
self.lblLevel = pyglet.text.Label('Level: 1',
font_name='Arial',
font_size=12,
x=game.window.width - 15,
y=5,
anchor_x='right',
anchor_y='bottom')
self.setup()
def setup(self, score=0, level=1):
# SETUP GAME OBEJCTS
self.paddle = Paddle(game.keyboard,
game.window.width / 2 - 50,
40,
width=100,
height=20,
speed=400)
self.ball = Ball(game.window.width / 2 - 8,
200,
width=16,
height=16,
speed=200,
direction=(0, -1))
self.wall_w = Wall(0, 0, width=10, height=game.window.height)
self.wall_e = Wall(game.window.width - 10,
0,
width=10,
height=game.window.height)
self.wall_n = Wall(0,
game.window.height - 10,
width=game.window.width,
height=10)
self.wall_s = Wall(0, 0, width=game.window.width, height=10)
self.walls = [self.wall_w, self.wall_n, self.wall_e, self.wall_s]
self.score = score
self.lblScore.text = "Score: " + str(self.score)
self.level = level
self.lblLevel.text = "Level: " + str(self.level)
# bricks setup
BRICK_WIDTH = 60
BRICK_HEIGHT = 40
MARGIN = 10
self.bricks = []
brickX = MARGIN
brickY = game.window.height - MARGIN - BRICK_HEIGHT
while brickY > game.window.height / 2:
while brickX + BRICK_WIDTH < game.window.width - MARGIN:
self.bricks.append(
Brick(brickX, brickY, BRICK_WIDTH, BRICK_HEIGHT))
brickX += BRICK_WIDTH + MARGIN
brickX = MARGIN
brickY -= MARGIN + BRICK_HEIGHT
# appear
#for brick in self.bricks:
# brick.appear(0.25 + random.random() * 0.5)
def draw(self):
for brick in self.bricks:
brick.draw()
self.paddle.draw()
self.ball.draw()
self.wall_w.draw()
self.wall_e.draw()
self.wall_n.draw()
self.lblScore.draw()
self.lblLevel.draw()
def tick(self, dt):
# update tweens
game.tween.tick(dt)
# update game objects
self.paddle.tick(dt)
self.ball.tick(dt)
# compute collisions and raise collision events
game.physics.collide_prepare()
game.physics.collide([self.ball],
[self.paddle]) # collides ball against the paddle
game.physics.collide([self.ball],
self.walls) # collides ball against walls
game.physics.collide([self.ball],
self.bricks) # collides ball against bricks
game.physics.collide_finish(
) # this raises collision events gathered during "physics.collide(...)"
# remove dead bricks
i = 0
while i < len(self.bricks):
if not self.bricks[i].alive:
self.bricks.pop(i)
self.score += 1
self.lblScore.text = "Score: " + str(self.score)
else:
i += 1
# check ball off-screen
if self.ball.x < -self.ball.width or self.ball.x > game.window.width + self.ball.width or self.ball.y > game.window.height + self.ball.height or self.ball.y < -self.ball.height:
self.restart()
# check all bricks down
new_level = True
for brick in self.bricks:
if brick.destroyable and brick.alive:
new_level = False
break
if new_level:
self.next_level()
def restart(self):
self.setup()
def next_level(self):
self.setup(score=self.score, level=self.level + 1)
def __init__(self, mapSize, display, character_size, theworld):
# Initialize the sprite base class
super(Map, self).__init__()
# Set our image to a new surface, the size of the World Map
self.display = display
self.mapSize = mapSize
logging.debug ("mapSize is {0}".format(self.mapSize))
self.character_size = character_size
self.image = Surface(self.mapSize)
# Fill the image with a green colour (specified as R,G,B)
self.image.fill(colors.BLACK)
self.world = theworld
self.walls = [] # List to hold the walls
self.wallgrid = [[[] for x in range(self.world.cols)] for y in range(self.world.rows)] # [y][x] grid of arrays of walls in that grid square
self.arts = [] # list to hold the arts
self.shapes = [] # list to hold the shapes
#print "DEBUG: Map.__init__(): rendering world:\n{0}".format(theworld.to_s())
self.grid_cellheight = grid_cellheight = int(mapSize[1] / theworld.rows)
self.grid_cellwidth = grid_cellwidth = int(mapSize[0] / theworld.cols)
logging.debug ("cell size is {0} wide x {1} high".format(grid_cellwidth, grid_cellheight))
self.displayGridSize = (int(display.getDisplaySize()[0] / grid_cellwidth), int(display.getDisplaySize()[1] / grid_cellheight))
# NEXT: render the world map from the 'world' class argument
for worldObj in sorted(theworld.objects, key=lambda obj: pacdefs.RENDER_ORDER[obj.type]):
pacglobal.checkAbort()
logging.debug ("rendering the next world object: {0}".format(worldObj))
if worldObj.type == pacdefs.TYPE_PATH:
left = worldObj.left * grid_cellwidth
top = worldObj.top * grid_cellheight
if worldObj.direction_h:
right = (worldObj.left+worldObj.length) * grid_cellwidth
bottom = (worldObj.top+worldObj.width) * grid_cellheight
else:
right = (worldObj.left+worldObj.width) * grid_cellwidth
bottom = (worldObj.top+worldObj.length) * grid_cellheight
width = right - left
height = bottom - top
rect = (left, top, width, height)
pygame.draw.rect(self.image, (111,111,111), rect)
elif worldObj.type == pacdefs.TYPE_ART:
# let the sprite manager draw it
pass
elif worldObj.type == pacdefs.TYPE_INTERSECTION:
# draw a grey rectangle
left = worldObj.left * grid_cellwidth
top = worldObj.top * grid_cellheight
width = worldObj.width * grid_cellwidth
height = worldObj.height * grid_cellheight
#right = (worldObj['left']+worldObj['width']) * grid_cellwidth
#bottom = (worldObj['top']+worldObj['length']) * grid_cellheight
#topLt = (left, top)
#topRt = (right, top)
#bottomLt = (left, bottom)
#bottomRt = (right, bottom)
rect = (left, top, width, height)
logging.debug ("intersection rect at {0}".format(rect))
pygame.draw.rect(self.image, (222,222,222), rect)
elif worldObj.type == pacdefs.TYPE_FIELD:
# draw a brown rectangle
left = worldObj.left * grid_cellwidth
top = worldObj.top * grid_cellheight
width = worldObj.width * grid_cellwidth
height = worldObj.height * grid_cellheight
rect = (left, top, width, height)
#print "DEBUG: field rect at {0}".format(rect)
pygame.draw.rect(self.image, (160,82,45), rect)
elif worldObj.type == pacdefs.TYPE_ROOM:
# calculate corners & dimensions
left = worldObj.left * grid_cellwidth
top = worldObj.top * grid_cellheight
width = worldObj.width * grid_cellwidth
height = worldObj.height * grid_cellheight
right = left + width
bottom = top + height
logging.debug ("rendering ROOM {4} [vert={0}..{1}, horiz={2}..{3}]".format(top,bottom,left,right,worldObj.id))
# define interior & paint it
rect = (left, top, width, height)
#print "DEBUG: room rect at {0}".format(rect)
pygame.draw.rect(self.image, colors.BLUE, rect)
#DEBUG MODE: draw the objectId in the middle
#font = pygame.font.Font(None, 20)
#textBitmap = font.render(str(worldObj.id), True, colors.BLACK)
#self.image.blit(textBitmap, [left+(width/2), top+(height/2)])
# draw 4 walls
roomWalls = {} # dictionary of side to array of wallDefs (each wallDef is a tuple of 2 points, each one an (x,y) tuple)
# draw walls that have doors in them
#NOTE: assumes no more than one door per wall
num_doors = len(worldObj.doors.keys())
if num_doors > 1: logging.debug ("multiple doors! Room has {0} doors.".format(num_doors))
for side,doorpos in worldObj.doors.items():
#need to keep track of which sides have been processed,
#add the defaults later for walls with no doors
doorx = doorpos[0]
doory = doorpos[1]
logging.debug ("rendering ROOM {0} has a door at {1} on side {2}".format(worldObj.id,doorpos,side))
if side == pacdefs.SIDE_N:
doorLeft = doorx * grid_cellwidth
doorRight = (doorx+1) * grid_cellwidth
# add 2 walls, on either side of the door
roomWalls[side] = []
roomWalls[side].append([(left,top), (doorLeft,top)])
roomWalls[side].append([(doorRight,top), (right,top)])
if side == pacdefs.SIDE_E:
doorTop = doory * grid_cellheight
doorBottom = (doory+1) * grid_cellheight
logging.debug ("rendering ROOM door top/bottom is {0}/{1}".format(doorTop,doorBottom))
# add 2 walls, on either side of the door
roomWalls[side] = []
roomWalls[side].append([(right,top), (right,doorTop)])
roomWalls[side].append([(right,doorBottom), (right,bottom)])
if side == pacdefs.SIDE_S:
doorLeft = doorx * grid_cellwidth
doorRight = (doorx+1) * grid_cellwidth
# add 2 walls, on either side of the door
roomWalls[side] = []
roomWalls[side].append([(left,bottom), (doorLeft,bottom)])
roomWalls[side].append([(doorRight,bottom), (right,bottom)])
if side == pacdefs.SIDE_W:
doorTop = doory * grid_cellheight
doorBottom = (doory+1) * grid_cellheight
# add 2 walls, on either side of the door
roomWalls[side] = []
roomWalls[side].append([(left,top), (left,doorTop)])
roomWalls[side].append([(left,doorBottom), (left,bottom)])
# end of for each door (creating walls w/ doors)
# check all directions and add a default wall if none is defined
for side in pacdefs.SIDES:
if side not in roomWalls.keys() or len(roomWalls[side]) == 0:
logging.debug ("drawing default wall for side {0}".format(side))
roomWalls[side] = []
if side == pacdefs.SIDE_N: roomWalls[side].append([(left,top), (right,top)])
if side == pacdefs.SIDE_E: roomWalls[side].append([(right,top), (right, bottom)])
if side == pacdefs.SIDE_S: roomWalls[side].append([(right,bottom), (left,bottom)])
if side == pacdefs.SIDE_W: roomWalls[side].append([(left,bottom), (left,top)])
for walls in roomWalls.values():
for wallPoints in walls:
# create the wall def
newwall = Wall(self.mapSize, wallPoints[0], wallPoints[1])
# add to walls array
self.addWall( newwall )
# draw on image
newwall.draw(self.image)
# draw a border, registering each line as a wall
topLt = (0, 0)
topRt = (self.mapSize[0], 0)
botLt = (0, self.mapSize[1])
botRt = (self.mapSize[0], self.mapSize[1])
wallDefs = [
(topLt, topRt),
(topRt, botRt),
(botRt, botLt),
(botLt, topLt)
]
for wallPoints in wallDefs:
newwall = Wall(self.mapSize, wallPoints[0], wallPoints[1]) # create the wall def
self.addWall( newwall ) # add to walls array and index
newwall.draw(self.image) # draw on image
# Create the sprite rectangle from the image
self.rect = self.image.get_rect()
# holds current effects happening on the map
self.effects = [] # array of Effects
class Engine: #------------------------------------------------------------------------------------------------------- def __init__( self ): self.core = Core( 60, 1024, 768, "Ninja" ) self.intro = Intro() self.menu_background = Texture( "menu/background.png" ) self.menu_title = Menu_title() self.menu_play_button = Menu_play_button() self.menu_git_button = Menu_link_button( "menu/git.png", "https://github.com/Adriqun" ) self.menu_google_button = Menu_link_button( "menu/google.png", "https://en.wikipedia.org/wiki/Ninja" ) self.menu_facebook_button = Menu_link_button( "menu/facebook.png", "nothing", True ) self.menu_twitter_button = Menu_link_button( "menu/twitter.png", "nothing", True ) self.menu_music_button = Menu_music_button( "menu/music.png" ) self.menu_chunk_button = Menu_music_button( "menu/chunk.png", 1 ) self.menu_exit_log = Menu_exit_log() self.menu_author_log = Menu_author_log() self.menu_game_log = Menu_link_button( "menu/game.png", "nothing", True ) self.menu_settings_log = Menu_link_button( "menu/settings.png", "nothing", True ) self.menu_score_log = Menu_score_log() self.menu_music = Menu_music( "menu/Rayman Legends OST - Moving Ground.mp3" ) self.wall = Wall() self.hero = Hero() self.menu_log = Menu_log() self.map = Map() #------------------------------------------------------------------------------------------------------- def load( self ): self.core.setState( -1 ) self.intro.load( self.core.getWidth(), self.core.getHeight() ) self.menu_title.load( self.core.getWidth() ) self.menu_play_button.load( self.core.getWidth(), self.core.getHeight() ) self.menu_git_button.load( self.core.getWidth(), 10 ) self.menu_google_button.load( self.core.getWidth(), self.menu_git_button.getBot() ) self.menu_facebook_button.load( self.core.getWidth(), self.menu_google_button.getBot() ) self.menu_twitter_button.load( self.core.getWidth(), self.menu_facebook_button.getBot() ) self.menu_music_button.load( 10 ) self.menu_chunk_button.load( self.menu_music_button.getBot() ) self.menu_exit_log.load( self.core.getWidth(), self.core.getHeight() ) self.menu_author_log.load( self.menu_play_button.getLeft()+5, self.core.getWidth(), self.menu_title.getBot() +150, self.menu_play_button.getBot() ) self.menu_game_log.load( self.menu_author_log.getRight(), self.menu_play_button.getBot() +10, True ) self.menu_settings_log.load( self.menu_game_log.getRight(), self.menu_play_button.getBot() +10, True ) self.menu_score_log.load( self.menu_settings_log.getRight(), self.core.getWidth(), self.menu_title.getBot() +150, self.menu_play_button.getBot() ) self.wall.load() self.hero.load( self.core.getWidth(), self.core.getHeight() ) self.menu_log.load( self.core.getWidth(), self.core.getHeight() ) self.map.load() #------------------------------------------------------------------------------------------------------- def handle( self ): for event in pygame.event.get(): if event.type == pygame.QUIT: self.core.setQuit() #------------------------------------------------------------------------------------------------------- if self.core.getState() == 0: if self.menu_play_button.getState() == 0: self.menu_exit_log.handle( event ) #HANDLE IF AUTHOR BUTTON == OFF AND SCORE BUTTON == OFF if self.menu_author_log.getState() == 0 and self.menu_score_log.getState() == 0: self.menu_play_button.handle( event ) self.menu_git_button.handle( event ) self.menu_google_button.handle( event ) self.menu_music_button.handle( event ) self.menu_chunk_button.handle( event ) if self.menu_score_log.getState() == 0: self.menu_author_log.handle( event ) if self.menu_author_log.getState() == 0: self.menu_score_log.handle( event ) #------------------------------------------------------------------------------------------------------- if self.core.getState() == 1: self.menu_log.handle( event ) #HANDLE IF MENU_LOG == OFF if self.menu_log.getState() == 0: self.hero.handle( event ) #------------------------------------------------------------------------------------------------------- def states( self ): #-------------------------------------------------------------------------------------------------------STATE -1 if self.core.getState() == -1: self.intro.draw( self.core.getWindow() ) if self.intro.getQuit(): self.intro.free() del self.intro self.menu_music.play()#MENU MUSIC self.core.setState( 0 ) #-------------------------------------------------------------------------------------------------------STATE 0 if self.core.getState() == 0: #FADE IN if self.menu_play_button.getState() != 1 and self.menu_exit_log.getState() == 0: self.menu_background.fadein( 5 ) self.menu_title.fadein( 5 ) self.menu_play_button.fadein( 5 ) self.menu_git_button.fadein( 5 ) self.menu_google_button.fadein( 5 ) self.menu_facebook_button.fadein( 5 ) self.menu_twitter_button.fadein( 5 ) self.menu_music_button.fadein( 5 ) self.menu_chunk_button.fadein( 5 ) self.menu_author_log.fadein( 5 ) self.menu_game_log.fadein( 5 ) self.menu_settings_log.fadein( 5 ) self.menu_score_log.fadein( 5 ) self.menu_music.setVolume( 1.0 ) #DRAW ALWAYS IN MENU STATE self.menu_background.draw( self.core.getWindow() ) self.menu_title.draw( self.core.getWindow() ) self.menu_exit_log.draw( self.core.getWindow() ) #DRAW IF AUTHOR BUTTON == OFF AND SCORE BUTTON == OFF if self.menu_author_log.getState() == 0 and self.menu_score_log.getState() == 0: self.menu_git_button.draw( self.core.getWindow() ) self.menu_google_button.draw( self.core.getWindow() ) self.menu_facebook_button.draw( self.core.getWindow() ) self.menu_twitter_button.draw( self.core.getWindow() ) self.menu_play_button.draw( self.core.getWindow() ) self.menu_music_button.draw( self.core.getWindow() ) self.menu_chunk_button.draw( self.core.getWindow() ) self.menu_game_log.draw( self.core.getWindow() ) self.menu_settings_log.draw( self.core.getWindow() ) if self.menu_score_log.getState() == 0: self.menu_author_log.draw( self.core.getWindow() ) if self.menu_author_log.getState() == 0: self.menu_score_log.draw( self.core.getWindow() ) #IF USER TURN ON/OFF CHUNKS if self.menu_chunk_button.getState(): self.menu_play_button.setState() self.menu_git_button.setState() self.menu_google_button.setState() self.menu_music_button.setState() self.menu_chunk_button.setState() self.menu_author_log.setState() self.menu_score_log.setState() #IF USER TURN ON/OFF MUSIC if self.menu_music_button.getState(): self.menu_music.pause() #IF USER PRESS Q - EXIT if self.menu_exit_log.getState() == 1: self.menu_background.fadeout( 6, 120 ) self.menu_title.fadeout( 6, 120 ) self.menu_play_button.fadeout( 6, 120 ) self.menu_git_button.fadeout( 6, 120 ) self.menu_google_button.fadeout( 6, 120 ) self.menu_facebook_button.fadeout( 6, 120 ) self.menu_twitter_button.fadeout( 6, 120 ) self.menu_music_button.fadeout( 6, 120 ) self.menu_chunk_button.fadeout( 6, 120 ) self.menu_author_log.fadeout( 6, 120 ) self.menu_game_log.fadeout( 6, 120 ) self.menu_settings_log.fadeout( 6, 120 ) self.menu_score_log.fadeout( 6, 120 ) self.menu_music.setVolume( 0.3 ) elif self.menu_exit_log.getState() == 2: self.menu_background.fadeout( 6 ) self.menu_title.fadeout( 6 ) self.menu_play_button.fadeout( 6 ) self.menu_git_button.fadeout( 6 ) self.menu_google_button.fadeout( 6 ) self.menu_facebook_button.fadeout( 6 ) self.menu_twitter_button.fadeout( 6 ) self.menu_music_button.fadeout( 6 ) self.menu_chunk_button.fadeout( 6 ) self.menu_author_log.fadeout( 6 ) self.menu_game_log.fadeout( 6 ) self.menu_settings_log.fadeout( 6 ) self.menu_score_log.fadeout( 6 ) if self.menu_exit_log.getState() == 2 and self.menu_background.getAlpha() == 0: self.core.setQuit() #IF USER CLICK PLAY BUTTON if self.menu_play_button.getState() == 1: self.menu_background.fadeout( 6 ) self.menu_title.fadeout( 6 ) self.menu_play_button.fadeout( 6 ) self.menu_git_button.fadeout( 6 ) self.menu_google_button.fadeout( 6 ) self.menu_facebook_button.fadeout( 6 ) self.menu_twitter_button.fadeout( 6 ) self.menu_music_button.fadeout( 6 ) self.menu_chunk_button.fadeout( 6 ) self.menu_author_log.fadeout( 6 ) self.menu_game_log.fadeout( 6 ) self.menu_settings_log.fadeout( 6 ) self.menu_score_log.fadeout( 6 ) if self.menu_music.isPaused() == False: self.menu_music.fadeOut() if self.menu_play_button.getAlpha() == 0: self.menu_play_button.setNext( 0 ) self.core.setState( 1 ) #-------------------------------------------------------------------------------------------------------STATE 1 if self.core.getState() == 1: #FADE IN IF PAUSE BUTTON == OFF AND MENU_LOG == OFF if self.menu_log.getState() == 0: self.wall.fadein( 5 ) self.hero.fadein( 5 ) self.map.fadein( 5 ) elif self.menu_log.getState() == 1: self.wall.fadeout( 6, 130 ) self.hero.fadeout( 6, 130 ) self.map.fadeout( 6, 130 ) elif self.menu_log.getState() == 2: self.wall.fadeout( 6 ) self.hero.fadeout( 6 ) self.map.fadeout( 6 ) if self.wall.getAlpha() == 0: self.menu_log.setState( 0 ) if self.menu_music.isPaused() == False: self.menu_music.play() self.core.setState( 0 ) #Back to menu #DRAW self.wall.draw( self.core.getWindow() ) self.hero.draw( self.core.getWindow() ) self.menu_log.draw( self.core.getWindow() ) self.map.draw( self.core.getWindow() ) def loop( self ): while not self.core.isQuit(): self.handle() self.core.fillDisplay() self.states() self.core.tickClock() pygame.display.update() def quit( self ): pygame.quit()
class Game():
def __init__(self):
pygame.init()
pygame.font.init()
self.clock = pygame.time.Clock()
self.myfont = pygame.font.SysFont('Comic Sans MS', 20)
self.population_counter = 1
self.average_fitness = 0
self.update_text()
self.population_size = 50
self.inherit_pool = 5
self.death_counter = 0
self.screen = pygame.display.set_mode([SCREEN_WIDTH, SCREEN_HEIGHT])
self.screen.blit(self.textsurface, (int(-100), int(SCREEN_HEIGHT / 2)))
self.running = True
self.wall = Wall(OPEN_SPACE, OPEN_SPACE, SCREEN_WIDTH - 2 * OPEN_SPACE,
SCREEN_HEIGHT - 2 * OPEN_SPACE, BLACK)
self.players = []
def spawn_player(self):
self.players.append(
Player(int(OPEN_SPACE / 2),
int(SCREEN_HEIGHT / 2 - PLAYER_SIZE / 2), PLAYER_SIZE,
BLACK, self.wall))
def manage_hotkeys(self, player):
pressed = pygame.key.get_pressed()
if pressed[pygame.K_LEFT]:
player.turn_left()
if pressed[pygame.K_RIGHT]:
player.turn_right()
if pressed[pygame.K_SPACE]:
player.move()
else:
player.stop()
def random_directions(self, player):
player.move()
if random.random() < 0.5:
player.turn_left()
else:
player.turn_right()
def check_collision(self, player):
if not player.is_dead:
if (player.collision(self.wall)):
player.die()
# self.players.remove(player)
def manage_quit(self):
for i in pygame.event.get():
if i.type == pygame.QUIT:
self.running = False
pygame.quit()
def adjustFPS(self):
pygame.time.wait(int(1000 / FPS))
def player_loop(self):
self.spawn_player()
while self.running:
self.draw_background()
for player in self.players:
player.update()
self.manage_hotkeys(player)
self.check_collision(player)
self.update_pygame()
self.manage_quit()
self.adjustFPS()
def update_pygame(self):
pygame.display.update()
def manage_population(self):
if self.death_counter == self.population_size:
parents = self.get_best_ancestors()
self.show_best_ancestors(parents)
self.create_new_population(parents)
self.update_text()
def create_new_population(self, parents):
nets = [p.net for p in parents]
self.death_counter = 0
self.players = []
self.spawn_players()
for player in self.players:
player.net.set_weights(nets)
player.net.set_biases(nets)
self.population_counter += 1
def show_best_ancestors(self, parents):
for a in range(self.inherit_pool):
parents[a].show()
self.update_pygame()
time.sleep(1)
def get_best_ancestors(self):
best_ancestors = sorted(self.players,
key=lambda x: x.fitness,
reverse=True)[:self.inherit_pool]
self.average_fitness = sum([x.fitness for x in best_ancestors
]) / len(best_ancestors)
return best_ancestors
def update_text(self):
self.textsurface = self.myfont.render(
"Population: {}| Fitness:{}".format(str(self.population_counter),
str(self.average_fitness)),
False, (255, 255, 255))
def spawn_players(self):
for a in range(self.population_size):
self.spawn_player()
def set_death_counter(self):
self.death_counter = sum(p.is_dead == True for p in self.players)
print(self.death_counter)
def update_players(self):
for player in self.players:
if time.time() - player.spawn_time > 10:
if player.fitness < 2 or time.time() - player.spawn_time > 20:
player.die()
player.update()
player.make_decision()
self.check_collision(player)
def draw_background(self):
self.screen.fill(WHITE)
self.wall.draw()
self.screen.blit(self.textsurface,
(int(SCREEN_WIDTH / 2), int(SCREEN_HEIGHT / 2)))
def computer_loop(self):
self.spawn_players()
while self.running:
self.draw_background()
self.update_players()
self.set_death_counter()
self.manage_population()
self.update_pygame()
self.manage_quit()
self.clock.tick()
