Implémentation du jeu de vie en Python
en premier
J'ai implémenté le programme en utilisant Pygame pour la première fois depuis longtemps. Cette fois, j'ai implémenté un jeu de vie un peu éloigné du jeu. (Le nom inclut un jeu, mais ce n'est pas un jeu, donc c'est sûr.) La difficulté de mise en œuvre n'est pas si élevée.
Qu'est-ce qu'un jeu de la vie?
Les jeux de la vie sont simplement des simulations de la vie. Vous pouvez observer comment les créatures naissent et meurent au fil du temps. Il n'y a que quelques règles dans les jeux de la vie, et le nombre de blocs appelés cellules est mis à jour en conséquence.
Règles du jeu de la vie
Les règles de mise à jour du jeu de vie sont divisées en naissance, survie et mort.
La naissance, c'est quand une cellule est morte, une cellule qui vit dans une cellule adjacente est née, mais quand il y a trois nouvelles cellules qui vivent dans cette cellule naissent.
D'autre part, une cellule vivante survit lorsque le nombre de cellules vivantes adjacentes est de 3 ou 4, et meurt à d'autres moments. La mort correspond ici au dépeuplement et à la surpopulation du monde réel.
Ici, dans la figure ci-dessous, les règles de naissance, de survie, de mort (dépeuplement) et de mort (surpeuplement) sont appliquées à la cellule centrale à partir de la gauche, respectivement.
Vous êtes libre de décider du nombre de cellules dont vous avez besoin pour que la règle s'applique. Cette fois, j'ai utilisé le nombre expliqué ci-dessus, qui est souvent utilisé.
la mise en oeuvre
En gros, je l'ai implémenté comme expliqué. Il est important de noter que lors de la mise à jour des cellules, si elles sont mises à jour séquentiellement, les cellules peuvent mourir à la fois. Par conséquent, lors de la mise à jour d'une cellule, il est nécessaire de conserver une fois l'état de cellule mis à jour dans un autre emplacement et de le mettre à jour en une seule fois après l'obtention de tous les états mis à jour. (Je suis resté coincé quand j'ai implémenté le jeu de la vie pour la première fois) De plus, nous avons ajouté quelques fonctions cette fois.
Écran couleur
La plupart des jeux de la vie affichent des cellules dans une couleur, mais cette fois j'ai utilisé des cellules multicolores. Plus précisément, nous avons commencé avec quatre types de blanc, vert, rouge et bleu à l'état initial, et lorsque le processus de naissance est effectué, des cellules avec la couleur moyenne des cellules adjacentes naissent.
Entrée clé
Vous pouvez utiliser les touches fléchées pour avancer rapidement et ralentir le passage du temps, et utiliser les touches numériques pour initialiser à tout moment. Si la touche numérique initiale enfoncée est n, elle sera initialisée de sorte que le rapport de cellule soit n0%.
Organisme du programme
import pygame
from pygame.locals import *
import sys
display = [1010, 1010]
world_size = [100, 100]
num_key = [K_1, K_2, K_3, K_4, K_5, K_6, K_7, K_8, K_9]
class World:
def __init__(self):
self.speed = 1 #Vitesse de dessin
self.world = np.zeros(tuple(world_size + [3]))
self.color = np.asarray([[255.0, 255.0, 255.0], [255.0, 0.0, 0.0], [0.0, 255.0, 0.0], [0.0, 0.0, 255.0], [0.0, 0.0, 0.0]])
#Drapeau initialisé au hasard=Si True, la couleur est également aléatoire
def random_init(self, p, color_flag=False):
for i in range(world_size[0]):
for j in range(world_size[1]):
if random.random() > p:
continue
if color_flag:
color = self.color[random.randint(0, 3)]
else:
color = self.color[0]
self.world[i, j] = color
def draw(self, screen):
for i in range(world_size[0]):
for j in range(world_size[1]):
pygame.draw.rect(screen, tuple(self.world[i, j]), Rect(10*j + 10, 10*i + 10, 10, 10))
def update(self):
next_world = np.zeros(tuple(world_size + [3]))
flags = self.world.sum(axis=2) > 0
for i in range(world_size[0]):
for j in range(world_size[1]):
min_x = max(0, j-1)
max_x = min(world_size[1], j+2)
min_y = max(0, i-1)
max_y = min(world_size[0], i+2)
count = np.sum(flags[min_y:max_y, min_x:max_x])
if flags[i, j] == 0: #Cellule morte
if count == 3: #naissance
area = self.world[min_y:max_y, min_x:max_x]
next_world[i, j] = area.reshape(-1, 3).sum(axis=0) / count
else:
if 3 < count < 6: #pas dépeuplé ou surpeuplé
next_world[i, j] = self.world[i, j]
self.world = next_world
def main():
pygame.init()
screen = pygame.display.set_mode(display)
pygame.display.set_caption("Lifegame")
world = World()
world.random_init(0.3, True)
counter = 0
while(1):
screen.fill((0, 0, 0))
world.draw(screen)
pygame.display.update()
pygame.time.wait(5)
counter += 1
if counter > world.speed:
world.update()
counter = 0
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
pygame.quit()
sys.exit()
if event.key == K_DOWN:
world.speed = world.speed+1
if event.key == K_UP:
world.speed = max(0, world.speed-1)
if event.key in num_key:
world.random_init((num_key.index(event.key)+1.0)*0.1, True)
if __name__ == "__main__":
main()
C'est beaucoup plus court que le dernier Tetris.
Écran de sortie
Cela ressemble à une tempête de sable. Le taux de cellules est de 30%.
Un certain temps s'est écoulé. Je sens que le mélange des couleurs (accouplement) progresse bien.
Comme prévu, il existe de nombreuses couleurs sales qui survivent en fin de vie. Il semble que le mélange de couleurs ait beaucoup progressé. Au début, il y en avait tellement.
en conclusion
C'est la fin de la mise en œuvre du jeu de vie. Pour dire la vérité, je voulais ajouter un peu plus de fonctionnalités, mais j'ai abandonné car la vitesse de traitement de Python était suspecte. Peut-être que je le réimplémenterai en utilisant C ++. à la prochaine
Recommended Posts