def __init__(self, theApp):
''' theApp: refernecja do obiektu aplikacji. Potrzebne przy dodawaniu obiektu nasłuchującego wejścia. '''
self.__theApp = theApp # obiekt zarządzający aplikacją
self.__objects = [] # lista obiektów w świecie
self.__spriteManager = SpriteManager() # menadżer sprite'ów
self.__collisionManager = CollisionManager(self.__spriteManager) # menadżer kolizji
self.__objectFactory = self.__create_object_factory(self.__spriteManager) # fabryka obiektów
self.__levelManager = LevelManager(self.__objectFactory,self.__spriteManager) # menadżer poziomów
self.__backgroundManager = BackgroundManager( levelManager = self.__levelManager )
self.__backgroundManager.set_window_coords( self.__theApp.get_window_coords() )
self.__backgroundManager.set_window_draw_dim( self.__theApp.get_window_draw_dim() )
self.__levelManager.set_window_coords( self.__theApp.get_window_coords() )
self.__levelManager.set_window_draw_dim( self.__theApp.get_window_draw_dim() )
if not self.__levelManager.load_level("demo_level"):
assert True, "Tworzenie świata nie powiodło się. Nie można wczytać poziomu."
const.renderTextureSize = (512,256) # rozmiary tekstury, do której będziemy renderować
self.__renderTexture = image.create( *const.renderTextureSize ).get_texture()
# Dodaj obiekt helikoptera i jeepa do gry
#
# FIXME: jeep?
#
self.add_object( self.__create_heli() )
class Artifact(pygame.sprite.Sprite):
def __init__(self, file, level, flag=False):
""" Artifact represent a constant block on the map """
super().__init__()
self.flag = flag
self.level = level
self.collisionManager = CollisionManager(self)
# Grab the image for this platform
self.image = pygame.image.load(file).convert_alpha()
self.rect = self.image.get_rect()
def update(self):
coll = False
if self.flag:
if not coll:
coll = self.collisionManager.block_vs_object(
self.level.walls_list)
if not coll:
coll = self.collisionManager.block_vs_object(
self.level.door_list)
if not coll:
coll = self.collisionManager.block_vs_object(
self.level.artifact_list)
if not coll:
coll = self.collisionManager.block_vs_object(
self.level.water_list)
#coll = self.collisionManager.block_vs_object(self.level.block_list)
if not coll:
coll = self.collisionManager.block_vs_object(
self.level.chest_list)
return coll
class Enemy(pygame.sprite.Sprite):
def __init__(self, player, level):
super().__init__()
self.player = player
self.level = level
self.direction = None
self.status = constants.ENEMY_INIT
self.change_status_time = 0
self.collisionManager = CollisionManager(self)
# Grab the images for the snake
self.sprite_sheet0 = None
self.sprite_sheet1 = None
# Egg images
self.sprite_sheet1 = SpriteSheet("Assets/Egg.png")
self.egg_images = [
self.sprite_sheet1.get_image(0, 0, 58, 58),
self.sprite_sheet1.get_image(58, 0, 116, 58)
]
self.image = None
self.rect = None
self.change_x = 0
self.change_y = 0
def update(self):
self.collisionManager.fixed_objects(self.level.walls_list)
self.collisionManager.fixed_objects(self.level.door_list)
self.collisionManager.fixed_objects(self.level.artifact_list)
self.collisionManager.fixed_objects(self.level.water_list)
self.collisionManager.fixed_objects(self.level.block_list)
self.collisionManager.fixed_objects(self.level.chest_list)
def set_egg(self):
""" Called when the player shots the enemy. """
self.image = self.egg_images[0]
self.status = constants.ENEMY_EGG
self.change_status_time = pygame.time.get_ticks()
pygame.time.set_timer(constants.BROKE_EGG, constants.EGG_TIME)
def broke_egg(self):
""" Called when broke egg event is throwed. """
self.image = self.egg_images[1]
self.status = constants.ENEMY_BREAKING_EGG
self.change_status_time = pygame.time.get_ticks()
pygame.time.set_timer(constants.BROKE_EGG, 0)
pygame.time.set_timer(constants.REMOVE_EGG, constants.EGG_TIME)
def remove_egg(self):
""" Called when remove egg event is throwed. """
self.image = self.egg_images[1]
self.status = constants.ENEMY_INIT
self.change_status_time = 0
pygame.time.set_timer(constants.REMOVE_EGG, 0)
def get_status(self):
return self.status
def __init__(self, player, level):
super().__init__()
self.player = player
self.level = level
self.direction = None
self.status = constants.ENEMY_INIT
self.change_status_time = 0
self.collisionManager = CollisionManager(self)
# Grab the images for the snake
self.sprite_sheet0 = None
self.sprite_sheet1 = None
# Egg images
self.sprite_sheet1 = SpriteSheet("Assets/Egg.png")
self.egg_images = [
self.sprite_sheet1.get_image(0, 0, 58, 58),
self.sprite_sheet1.get_image(58, 0, 116, 58)
]
self.image = None
self.rect = None
self.change_x = 0
self.change_y = 0
def __init__(self):
'# Initialize game window and settings etc.'
self.screen = pygame.display.set_mode((1000, 1000))
pygame.display.set_caption("Asteroids")
pygame.font.init()
self.myfont = pygame.font.SysFont('Comic Sans MS', 30)
self.debug_text_surface = self.myfont.render('Hello', False,
(255, 255, 255))
self.render_pace: float = 1 / 60
self.game_active = True
asteroid_list = []
bullet_list = []
ship = Ship(self.screen, Point(400, 500), Point(0, 0), -math.pi / 2, 1)
enemy_ship = Ship(self.screen, Point(600, 500), Point(0, 0),
-math.pi / 2, 1)
self.game_state = GameState(ship, enemy_ship, bullet_list,
asteroid_list)
for count in range(0, 8):
asteroids = Asteroid(self.screen,
Point(randint(0, 900), randint(0, 900)),
Point(randint(-20, 20), randint(-20, 20)),
randint(120, 170))
list.append(asteroid_list, asteroids)
self.movement_manager = MovementManager(self.render_pace, 1000, 1000)
self.collision_manager = CollisionManager()
def __init__(self, file, level, flag=False):
""" Artifact represent a constant block on the map """
super().__init__()
self.flag = flag
self.level = level
self.collisionManager = CollisionManager(self)
# Grab the image for this platform
self.image = pygame.image.load(file).convert_alpha()
self.rect = self.image.get_rect()
def __init__(self, player, level):
super().__init__()
self.collisionManager = CollisionManager(self)
# Set bullet speed vector
self.change_x = 0
self.change_y = 0
self.direction = None
# Grab the images for the bullet
sprite_sheet = SpriteSheet("Assets/Bullet.png")
self.images = [
sprite_sheet.get_image(0, 0, 58, 58), # Closed door
sprite_sheet.get_image(58, 0, 116, 58)
] # Opened door
self.player = player
if self.player.direction == "D":
self.image = self.images[0]
self.direction = "D"
elif self.player.direction == "U":
self.image = self.images[0]
self.direction = "U"
elif self.player.direction == "L":
self.image = self.images[1]
self.direction = "L"
else:
self.image = self.images[1]
self.direction = "R"
self.rect = self.image.get_rect()
self.level = level
block = self
block.rect.x = self.player.rect.x
block.rect.y = self.player.rect.y
block.player = self.player
self.level.shot_list.add(block)
def __init__(self, conffile):
pygame.init()
self.config = GameConfig(conffile)
self.clock = pygame.time.Clock()
self.layer_manager = LayerManager(self.config, self.clock)
self.story_manager = StoryManager(self, self.layer_manager)
self.collision_manager = CollisionManager(self.layer_manager)
#list pour le joueur et monstre
self.perso = None
self.monstres = []
self.layer_manager.set_map(self, self.config.get_start_map())
self.layer_manager.new_layer('player', tmx.SpriteLayer)
self.layer_manager.new_layer('npcs', tmx.SpriteLayer)
self.layer_manager.new_layer('monster', tmx.SpriteLayer)
self.FPS = 30
self.clocks = {"playerHud": 0}
self.userInput = None
class GameWorld(object):
def __init__(self, theApp):
''' theApp: refernecja do obiektu aplikacji. Potrzebne przy dodawaniu obiektu nasłuchującego wejścia. '''
self.__theApp = theApp # obiekt zarządzający aplikacją
self.__objects = [] # lista obiektów w świecie
self.__spriteManager = SpriteManager() # menadżer sprite'ów
self.__collisionManager = CollisionManager(self.__spriteManager) # menadżer kolizji
self.__objectFactory = self.__create_object_factory(self.__spriteManager) # fabryka obiektów
self.__levelManager = LevelManager(self.__objectFactory,self.__spriteManager) # menadżer poziomów
self.__backgroundManager = BackgroundManager( levelManager = self.__levelManager )
self.__backgroundManager.set_window_coords( self.__theApp.get_window_coords() )
self.__backgroundManager.set_window_draw_dim( self.__theApp.get_window_draw_dim() )
self.__levelManager.set_window_coords( self.__theApp.get_window_coords() )
self.__levelManager.set_window_draw_dim( self.__theApp.get_window_draw_dim() )
if not self.__levelManager.load_level("demo_level"):
assert True, "Tworzenie świata nie powiodło się. Nie można wczytać poziomu."
const.renderTextureSize = (512,256) # rozmiary tekstury, do której będziemy renderować
self.__renderTexture = image.create( *const.renderTextureSize ).get_texture()
# Dodaj obiekt helikoptera i jeepa do gry
#
# FIXME: jeep?
#
self.add_object( self.__create_heli() )
def add_object(self, gameObject):
''' Dodaje obiekt do świata. Sprawdza typ dodawanego obiektu. '''
try: isinstance(gameObject, GameObject),
except TypeError, msg: print msg, "Dodawany obiekt nie jest typu GameObject."
self.__objects.append( gameObject )
self.__collisionManager.add_object( gameObject )
def remove_object(self, gameObject):
''' Usuwa wszystkie wystąpienia obiektu w świecie. '''
for i in range(self.__objects.count(gameObject)):
self.__objects.remove( gameObject )
self.collisionManager.remove_object( gameObject )
def create_object(self, objName):
''' Tworzy obiekt o zadanej nazwie korzystając z fabryki obiektów. '''
return self.__objectFactory.create_object( objName )
def get_background_manager(self):
assert self.__backgroundManager, "Obiekt menedżera tła nie istnieje."
return self.__backgroundManager
def update(self, dt):
''' Aktualizuje obiekty ze świata. '''
# aktualizacja menedżera poziomu (np. stworzenie nowych jednostek)
self.__levelManager.update( dt, self )
# usuń obiekty, które są za lewą krawędzią planszy
for obj in self.__objects:
animName = obj.get_current_animation_name()
frame = self.__spriteManager.get_frame( obj.spriteName, animName, 0 )
(ww,wh) = self.__theApp.get_window_draw_dim()
objectWidth = frame.width / float(ww)
if obj.position[0]+objectWidth < -0.5:
print "DELETED:",obj.spriteName
obj.destroy()
# odfiltruj obiekty, które są zniszczone
for o in self.__objects:
if o.isDestroyed():
self.__collisionManager.remove_object(o)
self.__objects = filter(lambda o: not o.isDestroyed() , self.__objects)
# sprawdź kolizje
self.check_collisions()
# aktualizuj stan obiektów
for obj in self.__objects:
obj.update( dt )
# aktualizuj tło
self.get_background_manager().update( dt )
def __draw_object( self, obj ):
''' Rysuje obiekt przekazany jako argument. '''
glPushMatrix()
# przygotuj mieszanie kolorów
glEnable( GL_BLEND )
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA )
# zbierz informacje o reprezentacji obiektu
spriteName = obj.spriteName
animName = obj.get_current_animation_name()
frameNum = obj.get_current_frame_num()
frame = self.__spriteManager.get_frame( spriteName, animName, frameNum )
(ww,wh) = self.__theApp.get_window_draw_dim()
(tc,vs) = compute_tex_vertex_coords( obj, frame, ww, wh )
textureId = frame.textureId
# narysuj tło pod sprite'em (do celów testowych)
if( obj.display_pad() ):
glDisable( GL_TEXTURE_2D )
glColor3f( .3, .3, .4 ) # ew. kolor może być skądś pobierany
glBegin( GL_QUADS )
for v in vs:
glVertex2f( *v )
glEnd()
# narysuj sprite'a
draw_textured_quad( tc, vs, textureId )
glColor3f( 1, 1, 1 )
glPopMatrix()
def draw(self):
''' Rysuje wszystkie obiekty w świecie. '''
glClearColor( 0.4, 0.4, 0.4, 0.5 )
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT )
glMatrixMode( GL_MODELVIEW )
glLoadIdentity()
# zmień viewport, będziemy renderować do tekstury
if config.IS_RENDER_TO_TEXTURE:
tw,th = const.renderTextureSize
glViewport( 0, 0, tw, th )
glTranslatef( 0, 0, -10 )
# narysuj tło
self.get_background_manager().draw_background()
# narysuj scenerię
glTranslatef( 0, 0, 1 )
for obj in filter(lambda o:isinstance(o,SceneryObject),self.__objects):
self.__draw_object( obj )
# narysuj jednostki, etc.
glTranslatef( 0, 0, 1 )
for obj in self.__objects:
if not (isinstance(obj,SceneryObject) or isinstance(obj,GroundObject)):
self.__draw_object( obj )
# narysuj podłoże
glTranslatef( 0, 0, 1 )
for obj in filter(lambda o:isinstance(o,GroundObject) and o.position[0]<1.1,self.__objects):
self.__draw_object( obj )
# zapisz bufor do tekstury
if config.IS_RENDER_TO_TEXTURE:
assert glIsTexture( self.__renderTexture.id ), "Próba narysowania czegoś, co nie jest teksturą"
glBindTexture( GL_TEXTURE_2D, self.__renderTexture.id )
glCopyTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, 0, 0, tw, th, 0 )
# glCopyTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, 0, 0, tw, th )
# przywróć viewport, wyczyść bufor i narysuj czworokąt z zapisaną teksturą
winSize = map( lambda x:int(x), self.__theApp.get_window_dim() )
glViewport( 0, 0, winSize[0], winSize[1] )
if config.IS_RENDER_TO_TEXTURE:
glClearColor( 0.5, 0.5, 0.5, 0.5 )
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glLoadIdentity()
glEnable( GL_TEXTURE_2D )
glColor3f( 1, 1, 1 )
# renderuj czworokąt na cały ekran
coords = self.__theApp.get_window_coords()
x0,x1,y0,y1 = coords[0], coords[1], coords[2], coords[3]
tc = [ ( 0, 0), ( 1, 0), ( 1, 1), ( 0, 1) ]
vs = [ ( x0, y0), ( x1, y0), ( x1, y1), ( x0, y1) ]
draw_textured_quad( tc, vs, self.__renderTexture.id )
# zrzuć wszystko
glFlush()
def check_collisions(self):
''' Pobiera pary kolidujących obiektów i nakazuje obsługę któremuś z nich. '''
collPairs = self.__collisionManager.get_colliding_objects()
for a,b in collPairs:
if a != b:
a.collide(b)
def __create_object_factory(self, spriteManager):
''' Tworzy instancję fabryki obiektów. '''
objFactory = GameObjectFactory()
add_supported_objects_to_factory(objFactory, spriteManager)
return objFactory
def __create_heli(self):
''' Tworzy helikopter gracza. '''
creator = PlayerHeliCreator( self.__theApp, self, self.__spriteManager, self.__objectFactory )
heli = creator.create( 'heli' )
heli.position = (0.1, 0.5)
return heli
class Engine(object):
def __init__(self, mapSizeX, mapSizeY, collisionHandler=None):
self._objectList = {}
self._objectIdCount = 9999
self._map = Map(mapSizeX, mapSizeY)
self._collisionManager = CollisionManager(collisionHandler)
def engineStep(self):
# ipdb.set_trace()
# self._drawBounds()
self._collisionManager.reinitializeLists()
i = 0
for key in self._objectList:
obj = self._objectList[key]
if type(obj) is dynamicObject:
obj.save()
obj.updatePosition()
collisionList = self._collisionManager.collisionDetection(obj, self._objectList, i)
# for collision in collisionList :
# ipdb.set_trace()
# self._objectList[key] = obj.getBackup()
# ipdb.set_trace(frame=None)
i += 1
def showCollisions(self):
newColList = self._collisionManager.newCollisionList
endedColList = self._collisionManager.getEndOfCollisions()
if newColList:
print "New Collisions : "
print newColList
if endedColList:
print "End Of Collisions : "
print endedColList
def _drawBounds(self):
newBounds = []
for key in self._objectList:
obj = self._objectList[key]
if obj.name.split(":")[0] != "bounds":
name = "bounds:%d" % obj.id
bounds = obj.shape.bounds()
shape = Rectangle(bounds.minX, bounds.minY, bounds.maxX - bounds.minX, bounds.maxY - bounds.minY)
if self.getObjectbyName(name) is not None:
self.getObjectbyName(name).shape = shape
else:
newbound = {}
newbound["name"] = name
newbound["shape"] = shape
newBounds.append(newbound)
for bounds in newBounds:
self._objectIdCount += 1
self.addNewObject(bounds["name"], True, bounds["shape"], "bounds")
def addNewObject(self, objectName, isStatic, shape, objectId=None, objectType=None):
if objectId is None:
self._objectIdCount += 1
objectId = self._objectIdCount
if isStatic:
newObject = staticObject(objectName, objectId, shape, objectType)
else:
newObject = dynamicObject(objectName, objectId, shape, objectType)
self._objectList[objectId] = newObject
return newObject
def deleteObjectById(self, objectId):
for key in self._objectList:
if self._objectList[key]._id == objectId:
toDel = key
break
del self._objectList[toDel]
def deleteObject(self, objectId):
try:
del self._objectList[objectId]
# ipdb.set_trace(frame=None)
boundObjId = self.getObjectbyName(("bounds:%d" % int(float(objectId)))).id
del self._objectList[boundObjId]
except KeyError:
pass
def getObjectbyId(self, objectId):
for key in self._objectList:
if self._objectList[key]._id == objectId:
return self._objectList[key]
return None
def getObjectbyName(self, objectName):
for key in self._objectList:
if self._objectList[key]._name == objectName:
return self._objectList[key]
return None
def objectList():
doc = "The objectList property."
def fget(self):
objList = []
for key in self._objectList:
objList.append(self._objectList[key])
return objList
return locals()
objectList = property(**objectList())
def objectDict():
doc = "The objectDict property."
def fget(self):
return self._objectList
return locals()
objectDict = property(**objectDict())
def map():
doc = "The map property."
def fget(self):
return self._map
return locals()
map = property(**map())
class GameLoop:
def __init__(self):
'# Initialize game window and settings etc.'
self.screen = pygame.display.set_mode((1000, 1000))
pygame.display.set_caption("Asteroids")
pygame.font.init()
self.myfont = pygame.font.SysFont('Comic Sans MS', 30)
self.debug_text_surface = self.myfont.render('Hello', False,
(255, 255, 255))
self.render_pace: float = 1 / 60
self.game_active = True
asteroid_list = []
bullet_list = []
ship = Ship(self.screen, Point(400, 500), Point(0, 0), -math.pi / 2, 1)
enemy_ship = Ship(self.screen, Point(600, 500), Point(0, 0),
-math.pi / 2, 1)
self.game_state = GameState(ship, enemy_ship, bullet_list,
asteroid_list)
for count in range(0, 8):
asteroids = Asteroid(self.screen,
Point(randint(0, 900), randint(0, 900)),
Point(randint(-20, 20), randint(-20, 20)),
randint(120, 170))
list.append(asteroid_list, asteroids)
self.movement_manager = MovementManager(self.render_pace, 1000, 1000)
self.collision_manager = CollisionManager()
def handle_events(self):
for event in pygame.event.get():
'# When x button pushed quit game'
if event.type == pygame.KEYDOWN:
'#process ship one key down presses'
if event.key == pygame.K_w:
self.movement_manager.command_ship1.accel = True
elif event.key == pygame.K_a:
self.movement_manager.command_ship1.right = True
elif event.key == pygame.K_d:
self.movement_manager.command_ship1.left = True
elif event.key == pygame.K_SPACE:
self.movement_manager.command_ship1.shoot = True
elif event.key == pygame.K_8:
'#process ship two key down presses'
self.movement_manager.command_ship2.accel = True
elif event.key == pygame.K_4:
self.movement_manager.command_ship2.left = True
elif event.key == pygame.K_6:
self.movement_manager.command_ship2.right = True
elif event.key == pygame.K_0:
self.movement_manager.command_ship2.shoot = True
elif event.type == pygame.KEYUP:
'#process ship one key up presses'
if event.key == pygame.K_w:
self.movement_manager.command_ship1.accel = False
elif event.key == pygame.K_a:
self.movement_manager.command_ship1.right = False
elif event.key == pygame.K_d:
self.movement_manager.command_ship1.left = False
elif event.key == pygame.K_SPACE:
self.movement_manager.command_ship1.shoot = False
elif event.key == pygame.K_8:
'#process ship two key up presses'
self.movement_manager.command_ship2.accel = False
elif event.key == pygame.K_4:
self.movement_manager.command_ship2.left = False
elif event.key == pygame.K_6:
self.movement_manager.command_ship2.right = False
elif event.key == pygame.K_0:
self.movement_manager.command_ship2.shoot = False
elif event.type == pygame.QUIT:
self.game_active = False
pygame.quit()
def update_game(self):
self.game_state = self.movement_manager.calculate_rotation(
self.game_state)
self.game_state = self.movement_manager.calculate_pos_delta(
self.game_state)
self.game_state = self.movement_manager.calculate_movement(
self.game_state)
self.game_state = self.movement_manager.calculate_shoot(
self.game_state, self.screen)
self.game_state = self.collision_manager.if_intersect(self.game_state)
for i in self.game_state.bullets:
i.ttl -= 1
for i in self.game_state.bullets:
if i.ttl <= 0:
self.game_state.bullets.remove(i)
def render_game(self):
'#render new asteroids at new locations every call'
"#render new ship locations and heading directions"
'#render bullets as they are created and travel until they die'
self.game_state.my_ship.blitme()
self.game_state.enemy_ship.blitme()
for i in self.game_state.asteroids:
i.blitme()
for i in self.game_state.bullets:
i.blitme()
self.debug_text_surface = self.myfont.render(
str(self.game_state.my_ship.pos_delta.x), False, (255, 255, 255))
self.screen.blit(self.debug_text_surface, (0, 0))
pygame.display.flip()
self.screen.fill(000000)
"""Main game loop"""
def run_game(self):
pygame.init()
while self.game_active:
self.handle_events()
self.update_game()
self.render_game()
class Engine(object):
def __init__(self, mapSizeX, mapSizeY, collisionHandler = None):
self._objectList = {}
self._objectIdCount = 9999
self._map = Map(mapSizeX,mapSizeY)
self._collisionManager = CollisionManager(collisionHandler)
def engineStep(self):
# ipdb.set_trace()
# self._drawBounds()
self._collisionManager.reinitializeLists()
i = 0
for key in self._objectList:
obj = self._objectList[key]
if type(obj) is dynamicObject :
obj.save()
obj.updatePosition()
collisionList = self._collisionManager.collisionDetection(obj, self._objectList, i)
# for collision in collisionList :
# ipdb.set_trace()
# self._objectList[key] = obj.getBackup()
# ipdb.set_trace(frame=None)
i += 1
def showCollisions(self):
newColList = self._collisionManager.newCollisionList
endedColList = self._collisionManager.getEndOfCollisions()
if newColList :
print 'New Collisions : '
print newColList
if endedColList :
print 'End Of Collisions : '
print endedColList
def _drawBounds(self):
newBounds = []
for key in self._objectList:
obj = self._objectList[key]
if obj.name.split(':')[0] != 'bounds' :
name = "bounds:%d" % obj.id
bounds = obj.shape.bounds()
shape = Rectangle(bounds.minX, bounds.minY, bounds.maxX - bounds.minX, bounds.maxY - bounds.minY)
if self.getObjectbyName(name) is not None :
self.getObjectbyName(name).shape = shape
else :
newbound = {}
newbound['name'] = name
newbound['shape'] = shape
newBounds.append(newbound)
for bounds in newBounds :
self._objectIdCount += 1
self.addNewObject(bounds['name'], True, bounds['shape'], "bounds")
def addNewObject(self, objectName, isStatic, shape, objectId=None, objectType=None):
if objectId is None :
self._objectIdCount += 1
objectId = self._objectIdCount
if isStatic :
newObject = staticObject(objectName, objectId, shape, objectType)
else :
newObject = dynamicObject(objectName, objectId, shape, objectType)
self._objectList[objectId] = (newObject)
return newObject
def deleteObjectById(self, objectId):
for key in self._objectList:
if self._objectList[key]._id == objectId :
toDel = key
break
del self._objectList[toDel]
def deleteObject(self, objectId):
try:
del self._objectList[objectId]
# ipdb.set_trace(frame=None)
boundObjId = self.getObjectbyName(('bounds:%d' % int(float(objectId)))).id
del self._objectList[boundObjId]
except KeyError:
pass
def getObjectbyId(self, objectId):
for key in self._objectList:
if self._objectList[key]._id == objectId :
return self._objectList[key]
return None
def getObjectbyName(self, objectName):
for key in self._objectList:
if self._objectList[key]._name == objectName :
return self._objectList[key]
return None
def objectList():
doc = "The objectList property."
def fget(self):
objList = []
for key in self._objectList:
objList.append(self._objectList[key])
return objList
return locals()
objectList = property(**objectList())
def objectDict():
doc = "The objectDict property."
def fget(self):
return self._objectList
return locals()
objectDict = property(**objectDict())
def map():
doc = "The map property."
def fget(self):
return self._map
return locals()
map = property(**map())
def __init__(self, mapSizeX, mapSizeY, collisionHandler=None):
self._objectList = {}
self._objectIdCount = 9999
self._map = Map(mapSizeX, mapSizeY)
self._collisionManager = CollisionManager(collisionHandler)
class Bullet(pygame.sprite.Sprite):
def __init__(self, player, level):
super().__init__()
self.collisionManager = CollisionManager(self)
# Set bullet speed vector
self.change_x = 0
self.change_y = 0
self.direction = None
# Grab the images for the bullet
sprite_sheet = SpriteSheet("Assets/Bullet.png")
self.images = [
sprite_sheet.get_image(0, 0, 58, 58), # Closed door
sprite_sheet.get_image(58, 0, 116, 58)
] # Opened door
self.player = player
if self.player.direction == "D":
self.image = self.images[0]
self.direction = "D"
elif self.player.direction == "U":
self.image = self.images[0]
self.direction = "U"
elif self.player.direction == "L":
self.image = self.images[1]
self.direction = "L"
else:
self.image = self.images[1]
self.direction = "R"
self.rect = self.image.get_rect()
self.level = level
block = self
block.rect.x = self.player.rect.x
block.rect.y = self.player.rect.y
block.player = self.player
self.level.shot_list.add(block)
def update(self):
# Move the bullet
if self.direction == "R":
self.go_right()
elif self.direction == "L":
self.go_left()
if self.direction == "U":
self.go_up()
elif self.direction == "D":
self.go_down()
self.rect.x += self.change_x
self.rect.y += self.change_y
# Walls, artifacts & door collisions
if self.collisionManager.fixed_objects(
self.level.walls_list) or self.collisionManager.fixed_objects(
self.level.door_list
) or self.collisionManager.fixed_objects(
self.level.artifact_list):
self.level.shot_list.empty()
self.change_x = 0
self.change_y = 0
# Enemies collisions
block_hit_list = pygame.sprite.spritecollide(self,
self.level.enemy_list,
False)
b = None
flag = False
for block in block_hit_list:
self.level.shot_list.remove(self)
flag = True
b = block
if flag:
if b.get_status() == 0 or b.get_status() == 4:
b.set_egg()
elif b.get_status() == 1 or b.get_status() == 2:
self.level.enemy_list.remove(b)
b.status = 3
def go_left(self):
""" Called when the user hits the left arrow. """
self.image = self.images[1]
self.change_x = -29
self.change_y = 0
def go_right(self):
""" Called when the user hits the right arrow. """
self.image = self.images[1]
self.change_x = 29
self.change_y = 0
def go_up(self):
""" Called when the user hits the up arrow. """
self.image = self.images[0]
self.change_y = -29
self.change_x = 0
def go_down(self):
""" Called when the user hits the down arrow. """
self.image = self.images[0]
self.change_y = 29
self.change_x = 0
def __init__(self):
# Call the parent's constructor
super().__init__()
# -- Attributes
# Set speed vector of player
self.change_x = 0
self.change_y = 0
self.lives = 5
self.shots = 0
self.collisionManager = CollisionManager(self)
# This holds all the images for the animated walk of manolito
self.walking_frames_l = []
self.walking_frames_r = []
self.walking_frames_u = []
self.walking_frames_d = []
# What direction is manolito facing?
self.direction = "D"
self.level = None
self.level_end = False
self.hearts_collected = 0
self.gem = False
sprite_sheet = SpriteSheet("Assets/manolito.png")
# Load all the down facing images into a list
image = sprite_sheet.get_image(0, 0, 58, 58)
self.walking_frames_d.append(image)
image = sprite_sheet.get_image(58, 0, 58, 58)
self.walking_frames_d.append(image)
image = sprite_sheet.get_image(116, 0, 58, 58)
self.walking_frames_d.append(image)
image = sprite_sheet.get_image(174, 0, 58, 58)
self.walking_frames_d.append(image)
image = sprite_sheet.get_image(232, 0, 58, 58)
self.walking_frames_d.append(image)
# Load all the left facing images into a list
image = sprite_sheet.get_image(0, 58, 58, 58)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(58, 58, 58, 58)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(116, 58, 58, 58)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(174, 58, 58, 58)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(232, 58, 58, 58)
self.walking_frames_l.append(image)
# Load all the right facing images into a list
image = sprite_sheet.get_image(0, 116, 58, 58)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(58, 116, 58, 58)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(116, 116, 58, 58)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(174, 116, 58, 58)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(232, 116, 58, 58)
self.walking_frames_r.append(image)
# Load all the up facing images into a list
image = sprite_sheet.get_image(0, 174, 58, 58)
self.walking_frames_u.append(image)
image = sprite_sheet.get_image(58, 174, 58, 58)
self.walking_frames_u.append(image)
image = sprite_sheet.get_image(116, 174, 58, 58)
self.walking_frames_u.append(image)
image = sprite_sheet.get_image(174, 174, 58, 58)
self.walking_frames_u.append(image)
image = sprite_sheet.get_image(232, 174, 58, 58)
self.walking_frames_u.append(image)
# Set the image the player starts with
self.image = self.walking_frames_d[0]
# Set a reference to the image rect.
self.rect = self.image.get_rect()
self.rect.x = 58
self.rect.y = 58
class Manolito(pygame.sprite.Sprite):
def __init__(self):
# Call the parent's constructor
super().__init__()
# -- Attributes
# Set speed vector of player
self.change_x = 0
self.change_y = 0
self.lives = 5
self.shots = 0
self.collisionManager = CollisionManager(self)
# This holds all the images for the animated walk of manolito
self.walking_frames_l = []
self.walking_frames_r = []
self.walking_frames_u = []
self.walking_frames_d = []
# What direction is manolito facing?
self.direction = "D"
self.level = None
self.level_end = False
self.hearts_collected = 0
self.gem = False
sprite_sheet = SpriteSheet("Assets/manolito.png")
# Load all the down facing images into a list
image = sprite_sheet.get_image(0, 0, 58, 58)
self.walking_frames_d.append(image)
image = sprite_sheet.get_image(58, 0, 58, 58)
self.walking_frames_d.append(image)
image = sprite_sheet.get_image(116, 0, 58, 58)
self.walking_frames_d.append(image)
image = sprite_sheet.get_image(174, 0, 58, 58)
self.walking_frames_d.append(image)
image = sprite_sheet.get_image(232, 0, 58, 58)
self.walking_frames_d.append(image)
# Load all the left facing images into a list
image = sprite_sheet.get_image(0, 58, 58, 58)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(58, 58, 58, 58)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(116, 58, 58, 58)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(174, 58, 58, 58)
self.walking_frames_l.append(image)
image = sprite_sheet.get_image(232, 58, 58, 58)
self.walking_frames_l.append(image)
# Load all the right facing images into a list
image = sprite_sheet.get_image(0, 116, 58, 58)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(58, 116, 58, 58)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(116, 116, 58, 58)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(174, 116, 58, 58)
self.walking_frames_r.append(image)
image = sprite_sheet.get_image(232, 116, 58, 58)
self.walking_frames_r.append(image)
# Load all the up facing images into a list
image = sprite_sheet.get_image(0, 174, 58, 58)
self.walking_frames_u.append(image)
image = sprite_sheet.get_image(58, 174, 58, 58)
self.walking_frames_u.append(image)
image = sprite_sheet.get_image(116, 174, 58, 58)
self.walking_frames_u.append(image)
image = sprite_sheet.get_image(174, 174, 58, 58)
self.walking_frames_u.append(image)
image = sprite_sheet.get_image(232, 174, 58, 58)
self.walking_frames_u.append(image)
# Set the image the player starts with
self.image = self.walking_frames_d[0]
# Set a reference to the image rect.
self.rect = self.image.get_rect()
self.rect.x = 58
self.rect.y = 58
def update(self):
# Move the player
self.rect.x += self.change_x
pos = self.rect.x
if self.direction == "R":
frame = (pos // 29) % len(self.walking_frames_r)
self.image = self.walking_frames_r[frame]
elif self.direction == "L":
frame = (pos // 29) % len(self.walking_frames_l)
self.image = self.walking_frames_l[frame]
self.rect.y += self.change_y
pos = self.rect.y
if self.direction == "U":
frame = (pos // 29) % len(self.walking_frames_u)
self.image = self.walking_frames_u[frame]
elif self.direction == "D":
frame = (pos // 29) % len(self.walking_frames_d)
self.image = self.walking_frames_d[frame]
# Wall & door collisions
if not self.gem:
self.collisionManager.fixed_objects(self.level.walls_list)
self.collisionManager.fixed_objects(self.level.door_list)
else:
block_hit_list = pygame.sprite.spritecollide(
self, self.level.door_list, False,
pygame.sprite.collide_rect_ratio(0.1))
if block_hit_list != []:
self.level_end = True
# Artifact collisions
self.collisionManager.fixed_objects(self.level.artifact_list)
# Water
self.collisionManager.fixed_objects(self.level.water_list)
# Green blocks
self.collisionManager.green_blocks(self.level.block_list)
# Collect hearts
block_hit_list = pygame.sprite.spritecollide(
self, self.level.hearts_list, True,
pygame.sprite.collide_rect_ratio(0.1))
for block in block_hit_list:
self.hearts_collected += 1
if block.bonus > 0:
self.shots = block.bonus
# When all hearts are collected, change the status of the enemies
if self.hearts_collected == self.level.hearts_needed:
for enemy in self.level.enemy_list:
if enemy.status == 0:
enemy.status = constants.ENEMY_ATTACK
# Chest collisions
if self.hearts_collected < self.level.hearts_needed:
self.collisionManager.fixed_objects(self.level.chest_list)
elif self.gem == False:
block_hit_list = pygame.sprite.spritecollide(
self, self.level.chest_list, False,
pygame.sprite.collide_rect_ratio(0.1))
for block in block_hit_list:
self.gem = True
self.level.enemy_list.empty() # Remove enemies
# Snake collisions
self.collisionManager.snakes(self.level.enemy_list)
self.change_x = 0
self.change_y = 0
def go_left(self):
""" Called when the user hits the left arrow. """
self.change_x = -29
self.change_y = 0
self.direction = "L"
def go_right(self):
""" Called when the user hits the right arrow. """
self.change_x = 29
self.change_y = 0
self.direction = "R"
def go_up(self):
""" Called when the user hits the up arrow. """
self.change_y = -29
self.change_x = 0
self.direction = "U"
def go_down(self):
""" Called when the user hits the down arrow. """
self.change_y = 29
self.change_x = 0
self.direction = "D"
def shot(self, sound):
""" Called when the user hits space. """
if self.shots > 0 and self.level.shot_list.sprites() == []:
self.shots -= 1
sound.play()
bullet.Bullet(self, self.level)
def end_level(self):
self.shots = 0
self.gem = False
self.hearts_collected = 0
self.level_end = False
def __init__(self, mapSizeX, mapSizeY, collisionHandler = None):
self._objectList = {}
self._objectIdCount = 9999
self._map = Map(mapSizeX,mapSizeY)
self._collisionManager = CollisionManager(collisionHandler)
class Game(object):
def __init__(self, conffile):
pygame.init()
self.config = GameConfig(conffile)
self.clock = pygame.time.Clock()
self.layer_manager = LayerManager(self.config, self.clock)
self.story_manager = StoryManager(self, self.layer_manager)
self.collision_manager = CollisionManager(self.layer_manager)
#list pour le joueur et monstre
self.perso = None
self.monstres = []
self.layer_manager.set_map(self, self.config.get_start_map())
self.layer_manager.new_layer('player', tmx.SpriteLayer)
self.layer_manager.new_layer('npcs', tmx.SpriteLayer)
self.layer_manager.new_layer('monster', tmx.SpriteLayer)
self.FPS = 30
self.clocks = {"playerHud": 0}
self.userInput = None
def start(self):
#Trouve l'emplacement du héro
source = self.layer_manager['boundaries'].find_source("start")
self.layer_manager.set_focus(source.px, source.py, True)
self.perso = self.charge_player()
self.collision_manager.set_player(self.perso)
self.perso.definir_position(source.px, source.py)
self.monstres = self.charge_monstres()
self.userInput = userInput.Keyboard(self)
epe = weapon.Weapon(self.layer_manager, self.perso, 'clavier', 20, 50, 10)
self.perso.ajoute_outils(epe, self.layer_manager)
#hub
self.createHuds()
self.story_manager.read_stories(self.config.get_start_map())
self.mainloop()
def mainloop(self):
while True:
dt = self.clock.tick(self.FPS)
quitter = EventManager.update(self)
if quitter:
return
if not self.story_manager.blocking:
self.userInput.updateKey(dt)
for key, value in self.clocks.iteritems():
if value >= 0:
if value == 0:
if key == "playerHud":
self.hideHud(key)
pass
else:
self.clocks[key] = value - 1
#Récupère les collisions
self.collision_manager.tmx_stackCollisionEvents()
#stack les collision de monstre
self.collision_manager.player_stackEvents()
self.collision_manager.monster_stackEvents()
#gère les évenement crée par le joureur
self.collision_manager.player_manageCollisionEvents()
#Gère les colisions selon leur nature
self.collision_manager.tmx_manageCollisionEvents()
self.collision_manager.monster_manageCollisionEvents()
if self.perso.alive():
self.layer_manager.update(self.story_manager.blocking)
else:
self.story_manager.display_speech(["GAME OVER"], "bottom")
self.story_manager.set_unblockable(False)
self.layer_manager.draw()
pygame.display.update()
#pygame.display.flip()
#factory pour monstre
def charge_monstres(self):
monstres = []
try:
for cell in self.layer_manager['pnjs'].find('monstre'):
monster_layer = []
if "visible" not in cell.properties or cell.properties['visible']:
monster_layer = self.layer_manager['monster']
m = monster.Monster(cell.name,
os.path.join(self.config.get_sprite_dir(),
"sprite-Ennemi.png"),
(cell.px, cell.py), monster_layer)
m.definir_position(cell.px, cell.py)
monstres.append(m)
except KeyError:
pass
return monstres
def charge_player(self):
return player.Player("player",
os.path.join(self.config.get_sprite_dir(),
"sprite-Hero.png"),
(0, 0), self.layer_manager['player'])
def do_trigger(self, trigger):
self.story_manager.read_story(trigger)
def effectuer_transition(self, limite):
if not isinstance(limite, tmx.Object):
pass
try:
if limite.properties['barree']:
clef_requise = limite.properties['clef']
if not clef_requise in self.perso.tools:
self.story_manager.display_speech([u"La porte est barrée... Il serait certainement possible de", u"l'ouvrir si tu avais une clé."], "top")
return
except KeyError:
# la porte n'est probablement pas barrée...
pass
self.deleteHuds()
source_name = self.layer_manager.get_current_filename()
if 'destination' in limite.properties:
self.layer_manager.set_map(self, limite.properties['destination'])
if 'dest_transition' in limite.properties:
source = \
self.layer_manager['boundaries'].find_source(limite.properties['dest_transition'])
else:
source = \
self.layer_manager['boundaries'].find_source(source_name)
self.createHuds()
self.perso.definir_position(source.px, source.py)
self.charge_monstres()
self.layer_manager.set_focus(source.px, source.py, True)
self.story_manager.read_stories(limite.properties['destination'])
def createHuds(self):
hud = playerHud.PlayerHud("playerHud",
self.perso,
self.layer_manager)
self.layer_manager.add_layer(hud.name, hud)
def showHud(self, name):
layer = self.layer_manager[name]
layer.setVisible(True)
def hideHud(self, name):
layer = self.layer_manager[name]
layer.setVisible(False)
def deleteHuds(self):
if "playerHud" in self.layer_manager.layers:
layer = self.layer_manager["playerHud"]
self.layer_manager.remove(layer)
def addClockSec(self, name, second):
self.clocks[name] += second * self.FPS
