def __init__(self):
self.shootSound = ResourcesManager.LoadSound("shotgun.ogg")
self.shootSound.set_volume(0.5)
self.impactSound = ResourcesManager.LoadSound("hitdefault.ogg")
self.failHit = ResourcesManager.LoadSound("failhit.ogg")
Weapon.__init__(self, 'Shotgun', 'shotgun.png', DMG_SG, RELOAD_SG,
MAGAZINE_SG, SPEED_SG)
def __init__(self):
self.shootSound = ResourcesManager.LoadSound("rocketlauncher.ogg")
self.shootSound.set_volume(0.5)
self.impactSound = ResourcesManager.LoadSound("explosion.ogg")
self.failHit = self.impactSound
Weapon.__init__(self, 'Rocket Launcher', 'rocket_launcher.png', DMG_RL,
RELOAD_RL, MAGAZINE_RL, SPEED_RL)
def __init__(self, player, speed, scrollx, damage_level, hitSound,
failHit):
MySprite.__init__(self)
# Daño que provoca cada disparo
self.damage_level = damage_level
# Carga de la imagen del disparo
self.image = ResourcesManager.LoadImageCharacter('disparo.png', -1)
self.rect = self.image.get_rect()
#Añadir sonido al impacto del disparo
self.hitSound = hitSound
#añadir sonido fallar bala
self.failHit = failHit
# Dependiendo de hacia donde mire el jugador se crea el disparo en el
# lado derecho o en el izquierdo de este
(posx, posy) = player.position
if player.looking == RIGHT:
self.setposition(
(posx + self.rect.width - 20, player.rect.centery - 3))
else:
self.setposition(
(posx - self.rect.width + 5, player.rect.centery - 3))
self.setpositionscreen((scrollx, 0))
# Se comprueba si hay que darle la vuelta al disparo
self.looking = player.looking
if self.looking == LEFT:
self.image = pygame.transform.flip(self.image, 1, 0)
speed = -speed
self.speed = (speed, 0)
def __init__(self, image, heal_level=1):
MySprite.__init__(self)
self.healing = heal_level
self.image = image
self.image = ResourcesManager.LoadImageObjects(image, -1)
self.rect = self.image.get_rect()
def __init__(self, name, image, dmg, reloadSpeed, magazine, speed):
myfont = pygame.font.SysFont('Arial', 30)
self.name = myfont.render(name, False, (255, 255, 255))
self.pickUp = ResourcesManager.LoadSound("pickup.ogg")
MySprite.__init__(self)
self.dmg = dmg
self.bulletSpeed = speed
self.reloadSpeed = reloadSpeed
self.image = image
self.magazine = magazine
self.maxAmmo = magazine
self.lastBullet = pygame.time.get_ticks()
self.image = ResourcesManager.LoadImageObjects(image, -1)
self.rect = self.image.get_rect()
def __init__(self, image_name):
self.imagen = ResourcesManager.LoadImageScene(image_name, -1)
# TAMAÑO DEL FONDO AQUI (TAMBIEN TAMAÑO NIVEL)
# self.imagen = pygame.transform.scale(self.imagen, (6016, 608))
self.rect = self.imagen.get_rect()
self.rect.bottom = HEIGHT_SCREEN
# La subimagen que estamos viendo
self.rectSubimagen = pygame.Rect(0, 0, WIDTH_SCREEN, HEIGHT_SCREEN)
self.rectSubimagen.left = 0 # El scroll horizontal empieza en la position 0 por defecto
def __init__(self):
self.sprites = ResourcesManager.LoadImageHud(
'corazons_con_calavera.png', -1)
self.magazine = ResourcesManager.LoadImageHud('balas_con_recarga.png',
-1)
# self.sprites = self.sprites.convert_alpha()
# Cargamos las coordenadas de cada sprite
data = ResourcesManager.LoadCoordFileHud('coord_corazons.txt')
data = data.split()
self.coordsCor = []
cont = 0
for animation in range(7):
self.coordsCor.append(
pygame.Rect((int(data[cont]), int(data[cont + 1])),
(int(data[cont + 2]), int(data[cont + 3]))))
cont += 4
data = ResourcesManager.LoadCoordFileHud('coord_balas_pistola.txt')
data = data.split()
self.coordMagazine = []
cont = 0
for animation in range(5):
self.coordMagazine.append(
pygame.Rect((int(data[cont]), int(data[cont + 1])),
(int(data[cont + 2]), int(data[cont + 3]))))
cont += 4
self.currentImageMagazine = 4
self.rectMagazine = self.coordMagazine[self.currentImageMagazine]
self.pos_xMagazine = 750
self.pos_yMagazine = 50
# Establecemos como imagen inicial los 3 corazones
self.currentImageCor = 6
self.rectCor = self.coordsCor[self.currentImageCor]
self.pos_xCor = 50
self.pos_yCor = 50
def __init__(self, image, rectangle, subimage_rect=None):
# Primero invocamos al constructor de la clase padre
MySprite.__init__(self)
# Rectangulo con las coordenadas en screen que ocupara
self.rect = rectangle
# Y lo situamos de forma global en esas coordenadas
self.setposition((self.rect.left, self.rect.top))
# Cargamos la images correspondiente (si la plataforma está visible)
if image is not None:
self.image = ResourcesManager.LoadImageScene(image, -1)
if subimage_rect is not None:
# Si la imagen contiene distintos bloques y solo se quiere dibujar uno
self.image = self.image.subsurface(subimage_rect)
else:
self.image = pygame.Surface((0, 0))
def __init__(self):
self.healSound = ResourcesManager.LoadSound("eat.ogg")
HealthPack.__init__(self, 'chorizo.png', 1)
def __init__(self):
self.healSound = ResourcesManager.LoadSound("drink.ogg")
HealthPack.__init__(self, 'bottle.png', 0.5)
def __init__(self, director, num_level):
# Recibe como parámetro el número de fase, a partir del cual se carga
# un fichero donde está la configuración de esa fase en concreto,
# con cosas como:
# - Nombre del archivo con el decorado
# - Posiciones de las plataformas
# - Posiciones de los enemigos
# - Posición de inicio del jugador
# etc.
# Primero invocamos al constructor de la clase padre
Scene.__init__(self, director)
# Cargamos el archivo de configuración del nivel
filename = 'level_' + str(num_level) + '.tmx'
conf = ResourcesManager.LoadConfigurationFile(filename)
# Imagen de fondo
try:
back_layer = conf.get_layer_by_name('Background')
except ValueError:
raise ReferenceError("Background layer not found. Include it in "
"the maps editor")
back_image_name = os.path.basename(back_layer.source)
# Creamos el fondo del nivel
self.scenary = Scenary(back_image_name)
# Capa de plataformas
try:
layer = conf.get_layer_by_name('Platforms')
except ValueError:
raise ReferenceError("Platform layer not found. Include it in "
"the maps editor")
self.platformGroup = pygame.sprite.Group()
for tile in layer.tiles():
coord_x = tile[
0] # Multiplicar por TILE_SIZE para obtener el pixel donde se dibujará
coord_y = tile[1]
tile_image = os.path.basename(tile[2][0])
tile_coords = tile[2][1]
# tile_coords es una tupla de 4 elementos:
# - coord_x en la imagen de bloques
# - coord y en la imagen de bloques
# - size_x del bloque
# - size y del bloque
rect = pygame.Rect(coord_x * TILE_SIZE, coord_y * TILE_SIZE,
tile_coords[2], tile_coords[3])
# Especificamos que trozo de la imagen se va a dibujar
subimage_rectangle = pygame.Rect(tile_coords[0], tile_coords[1],
tile_coords[2], tile_coords[3])
platform = Platform(tile_image, rect, subimage_rectangle)
self.platformGroup.add(platform)
# Que parte del decorado estamos visualizando
self.scrollx = 0
# En ese caso solo hay scroll horizontal
# Si ademas lo hubiese vertical, seria self.scroll = (0, 0)
# Creamos el sprite del jugador
self.player = Player(Handgun())
# Ponemos al jugador en su posición inicial
try:
layer = conf.get_layer_by_name('Character')
# Para ejecutar el juego es necesario que haya un Jugador situado
# en algún punto del mapa donde comienza el juego, sinó lo hay se
# para la ejecución del juego
tile = next(layer.tiles())
except StopIteration:
raise ReferenceError("Player's sprite not found. Include it in the"
" maps editor")
except ValueError:
raise ReferenceError("Character layer not found. Include it in "
"the maps editor")
coord_x = tile[0]
coord_y = tile[1]
self.player.setposition((coord_x * TILE_SIZE, coord_y * TILE_SIZE))
# Creamos un grupo donde se guardarán los disparos
self.grupoShots = pygame.sprite.Group()
# Y los enemigos que tendrá en este nivel
self.enemyGroup = pygame.sprite.Group()
try:
layer = conf.get_layer_by_name('Enemies')
except ValueError:
raise ReferenceError("Enemies layer not found. Include it in "
"the maps editor")
for tile in layer.tiles():
coord_x = tile[0]
coord_y = tile[1]
enemy_name = os.path.basename(tile[2][0])
enemy = self.__get_enemy(enemy_name)
enemy.setposition((coord_x * TILE_SIZE, coord_y * TILE_SIZE))
self.enemyGroup.add(enemy)
try:
# El jefe final del nivel está en una capa diferente y guardamos una
# referencia a el en la fase para comprobar cuando se termina el nivel
layer = conf.get_layer_by_name('Boss')
# Para ejecutar el juego es necesario que haya un Jefe al final del
# nivel, sinó lo hay se para la ejecución del juego
tile = next(layer.tiles())
except StopIteration:
raise ReferenceError("Boss's sprite not found. Include it in the"
" maps editor")
except ValueError:
raise ReferenceError("Boss layer not found. Include it in "
"the maps editor")
coord_x = tile[0]
coord_y = tile[1]
enemy_name = os.path.basename(tile[2][0])
self.boss = self.__get_enemy(enemy_name)
self.boss.setposition((coord_x * TILE_SIZE, coord_y * TILE_SIZE))
self.enemyGroup.add(self.boss)
# Añadimos los objetos que recuperan la vida del jugador
self.healthGroup = pygame.sprite.Group()
try:
layer = conf.get_layer_by_name('Health_Objects')
except ValueError:
raise ReferenceError(
"Health_Objects layer not found. Include it in "
"the maps editor")
for tile in layer.tiles():
coord_x = tile[0]
coord_y = tile[1]
object_name = os.path.basename(tile[2][0])
health_object = self.__get_health_object(object_name)
health_object.setposition(
(coord_x * TILE_SIZE, coord_y * TILE_SIZE))
self.healthGroup.add(health_object)
# Añadimos las armas que se pueden recoger durante el juego
self.weaponGroup = pygame.sprite.Group()
try:
layer = conf.get_layer_by_name('Weapons')
except ValueError:
raise ReferenceError("Weapons layer not found. Include it in "
"the maps editor")
for tile in layer.tiles():
coord_x = tile[0]
coord_y = tile[1]
weapon_name = os.path.basename(tile[2][0])
weapon = self.__get_weapon(weapon_name)
weapon.setposition((coord_x * TILE_SIZE, coord_y * TILE_SIZE))
self.weaponGroup.add(weapon)
# Creamos un grupo con los Sprites que se mueven (personaje, enemigos, proyectiles,etc.
self.grupoSpritesDinamicos = pygame.sprite.Group(
self.player, self.enemyGroup.sprites())
# Creamos otro grupo con todos los Sprites
self.grupoSprites = pygame.sprite.Group(self.player,
self.enemyGroup.sprites(),
self.platformGroup.sprites(),
self.healthGroup.sprites(),
self.weaponGroup.sprites())
# Creamos los controles del jugador
self.control = ControlKeyboard()
# Creamos el Heads-Up Display con el nivel de vida
self.hud = HUD()
# sin necesidad de acceder a través del menú
DEBUG = False
DEBUG_FASE_NUM = 4
MUSIC_ON = True
if __name__ == '__main__':
# Inicializamos la libreria de pygame
pygame.init()
# Inicializamos el módulo para los sonidos y cargamos la música de fondo
pygame.mixer.pre_init(44100, 16, 2, 512)
pygame.mixer.init()
if MUSIC_ON:
ResourcesManager.LoadMusic('background_music.ogg')
# Reproducimos la música de forma que se repite continuamente
pygame.mixer.music.play(-1)
# Creamos el director
director = Director()
if DEBUG:
# Creamos la escena con el nivel a depurar
scene = Fase(director, DEBUG_FASE_NUM)
director.game_level = DEBUG_FASE_NUM
else:
# Creamos la escena con el menú principal
scene = MenuPrincipal(director)
# Le decimos al director que apile esta escena