Con el fin de respetar el original, este es el enlace original: la implementación del código Python Zombies (1): carga de imágenes y el interruptor de pantalla
Descripción del juego
la imagen del cambio de visualización
de imagen de carga
código completo
de código para
cargar la imagen
de visualización de imagen para cambiar
el compilador entorno de
juego se presentó
ante el fuego Zombies juego, que quería encontrar en la versión en línea del juego bajo el pitón de aprender, pero por desgracia no he encontrado relativamente completa, a sí mismos para escribir un put. de recursos de imagen se descarga desde github debido a la imagen recursos limitados, sólo se puede lograr de varias plantas y zombies.
Función para lograr lo siguiente:
Apoyado tipo de planta: girasoles, cerbatana, tirador de hielo, nueces, bombas de cereza. La nueva planta de aumento: guisante juego de disparos dobles, triples tirador de guisante.
Apoyado tipo de zombie: zombis, peón, bloqueos de carreteras zombi, zombi tambor.
Uso de archivos JSON información guardada puesto de control, ajuste la hora y la ubicación de los zombis aparecen.
El nuevo aumento weeder.
A continuación se muestra una captura de pantalla del juego:
1
Figura 2
Cambio de visualización de imagen
2 puede verse en la figura 1 y figura, la imagen zombi caminando y atacar pantalla será diferente, este artículo sobre cómo cambiar de imagen próximos espectáculos.
Para los bloqueos anteriores zombi, por ejemplo, un total de los siguientes tipos de tipos de imagen.
Caminar con barrera
con el ataque de barrera
sin viajar barricada (es decir, se convierte en zombies normales pie)
sin atacar las barreras (es decir, se convierte en ataque normal zombi)
sin tener que caminar cabeza
de ataque sin cabeza
muertes
Fig. 3, que es un zombi barrera ejemplo 7 clases de tipos de imágenes
de la Fig. 3
Cargando imagen
Zombis recursos de imagen particular que comparan un tipo de imagen de cada imagen es una sola acción, la figura 4 es una barrera con una barrera de ataque zombi fotos de acción, un total de 11 imágenes, la imagen de código cargado hacer modificación correspondiente.
El código completo de
un código de juego que implementa el enlace github Zombies
Aquí está el enlace de descarga CSDN Zombies
Código de lograr
aquí hablar de la siguiente imagen se carga y las imágenes muestran el cambio de código, estructura de directorios de archivos y todo el juego antes de Super Mario es el mismo.
Imágenes cargadas
en la fuente \ tool.py en load_all_gfx itera función de recursos \ directorio de gráficos y subdirectorios.
Código hace una distinción sencilla:
Si los recursos \ graphics \ subcarpeta \ directorio es una imagen, una imagen que está separado, como los recursos gráficos \ \ imagen interfaz de directorio de la pantalla
si los recursos \ graphics \ subcarpeta \ directorio es un subdirectorio, entonces este subdirectorio o todas las imágenes pertenecen a los sub-subdirectorios un tipo de imagen, tales como \ graphics \ zombis \ ConeheadZombie \ recursos del directorio está bajo barrera ConeheadZombieAttack con barrera de ataque zombi fotos de acción, como se muestra en la figura.
def load_all_gfx(directory, colorkey=c.WHITE, accept=('.png', '.jpg', '.bmp', '.gif')):
graphics = {}
for name1 in os.listdir(directory):
# subfolders under the folder resources\graphics
dir1 = os.path.join(directory, name1)
if os.path.isdir(dir1):
for name2 in os.listdir(dir1):
dir2 = os.path.join(dir1, name2)
if os.path.isdir(dir2):
# e.g. subfolders under the folder resources\graphics\Zombies
for name3 in os.listdir(dir2):
dir3 = os.path.join(dir2, name3)
# e.g. subfolders or pics under the folder resources\graphics\Zombies\ConeheadZombie
if os.path.isdir(dir3):
# e.g. it's the folder resources\graphics\Zombies\ConeheadZombie\ConeheadZombieAttack
image_name, _ = os.path.splitext(name3)
graphics[image_name] = load_image_frames(dir3, image_name, colorkey, accept)
else:
# e.g. pics under the folder resources\graphics\Plants\Peashooter
image_name, _ = os.path.splitext(name2)
graphics[image_name] = load_image_frames(dir2, image_name, colorkey, accept)
break
else:
# e.g. pics under the folder resources\graphics\Screen
name, ext = os.path.splitext(name2)
if ext.lower() in accept:
img = pg.image.load(dir2)
if img.get_alpha():
img = img.convert_alpha()
else:
img = img.convert()
img.set_colorkey(colorkey)
graphics[name] = img
return graphics
GFX = load_all_gfx(os.path.join("resources","graphics"))
load_image_frames funcionan de acuerdo con todas las imágenes en el nombre del directorio de imagen en el índice es clave, almacenada en el diccionario tmp. Por ejemplo, el nombre de la imagen es "ConeheadZombieAttack_2", el valor del índice será de 2.
Foto Por entonces añadieron secuencialmente al valor del índice en frame_list.
def load_image_frames(directory, image_name, colorkey, accept):
frame_list = []
tmp = {}
# image_name is "Peashooter", pic name is 'Peashooter_1', get the index 1
index_start = len(image_name) + 1
frame_num = 0;
for pic in os.listdir(directory):
name, ext = os.path.splitext(pic)
if ext.lower() in accept:
index = int(name[index_start:])
img = pg.image.load(os.path.join(directory, pic))
if img.get_alpha():
img = img.convert_alpha()
else:
img = img.convert()
img.set_colorkey(colorkey)
tmp[index]= img
frame_num += 1
for i in range(frame_num):
frame_list.append(tmp[i])
return frame_list
Las funciones básicas son implementados en la clase padre zombi, subclase que tiene necesidades especiales, se puede redefinir la función del mismo nombre.
función de actualización: Cada entrada se denomina función de garrapata, que se utiliza para actualizar el zombi posición, y una actualización de la imagen de visualización del estado de conmutación.
función handleState: para realizar diferentes funciones de acuerdo con el estado actual de los zombies.
funciones de animación: una imagen en movimiento se muestra debajo del tipo especificado animate_interval cada vez.
def update(self, game_info):
self.current_time = game_info[c.CURRENT_TIME]
self.handleState()
self.animation()
def handleState(self):
if self.state == c.WALK:
self.walking()
elif self.state == c.ATTACK:
self.attacking()
elif self.state == c.DIE:
self.dying()
def animation(self):
if (self.current_time - self.animate_timer) > self.animate_interval:
self.frame_index += 1
if self.frame_index >= self.frame_num:
if self.state == c.DIE:
self.kill()
return
self.frame_index = 0
self.animate_timer = self.current_time
self.image = self.frames[self.frame_index]
Los siguientes cuatro funciones se modifican zombies y fotografías muestran el estado actual.
setWalk funciones: modificar el estado de caminar, la imagen de la pantalla serán diferentes en función de los valores de ajuste del tipo de imagen.
setAttack funciones: modificar el estado de ataque, la imagen de la pantalla será diferente en función de los valores de ajuste del tipo de imagen.
setDie función: para modificar el estado de muerte.
changeFrames Función: Después de modificar el tipo de imagen, es necesario restablecer el valor de la variable miembro FRAME_NUM, frame_index, imagen y rect de.
def setWalk(self):
self.state = c.WALK
self.animate_interval = 150
if self.helmet:
self.changeFrames(self.helmet_walk_frames)
elif self.losHead:
self.changeFrames(self.losthead_walk_frames)
else:
self.changeFrames(self.walk_frames)
def setAttack(self, plant):
self.plant = plant
self.state = c.ATTACK
self.animate_interval = 100
if self.helmet:
self.changeFrames(self.helmet_attack_frames)
elif self.losHead:
self.changeFrames(self.losthead_attack_frames)
else:
self.changeFrames(self.attack_frames)
def setDie(self):
self.state = c.DIE
self.animate_interval = 200
self.changeFrames(self.die_frames)
def changeFrames(self, frames):
'''change image frames and modify rect position'''
self.frames = frames
self.frame_num = len(self.frames)
self.frame_index = 0
bottom = self.rect.bottom
centerx = self.rect.centerx
self.image = self.frames[self.frame_index]
self.rect = self.image.get_rect()
self.rect.bottom = bottom
self.rect.centerx = centerx
Obstáculos zombi es relativamente simple, sólo es necesario poner en práctica funcionan LoadImages, loadFrames llamada de función para cargar el tipo de zombi apoyado tipos de imágenes, aquí la principal diferencia es que los nombres de los diferentes tipos de zombis serán diferentes tipos de imágenes.
class ConeHeadZombie(Zombie):
def __init__(self, x, y, head_group):
Zombie.__init__(self, x, y, c.CONEHEAD_ZOMBIE, c.CONEHEAD_HEALTH, head_group)
self.helmet = True
def loadImages(self):
self.helmet_walk_frames = []
self.helmet_attack_frames = []
self.walk_frames = []
self.attack_frames = []
self.losthead_walk_frames = []
self.losthead_attack_frames = []
self.die_frames = []
helmet_walk_name = self.name
helmet_attack_name = self.name + 'Attack'
walk_name = c.NORMAL_ZOMBIE
attack_name = c.NORMAL_ZOMBIE + 'Attack'
losthead_walk_name = c.NORMAL_ZOMBIE + 'LostHead'
losthead_attack_name = c.NORMAL_ZOMBIE + 'LostHeadAttack'
die_name = c.NORMAL_ZOMBIE + 'Die'
frame_list = [self.helmet_walk_frames, self.helmet_attack_frames,
self.walk_frames, self.attack_frames, self.losthead_walk_frames,
self.losthead_attack_frames, self.die_frames]
name_list = [helmet_walk_name, helmet_attack_name,
walk_name, attack_name, losthead_walk_name,
losthead_attack_name, die_name]
for i, name in enumerate(name_list):
self.loadFrames(frame_list[i], name, tool.ZOMBIE_RECT[name]['x'])
self.frames = self.helmet_walk_frames
Compilador entorno
+ pygame1.9 python3.7
