Implementierung eines Lebensspiels in Python
zunaechst
Ich habe das Programm zum ersten Mal seit langer Zeit wieder mit Pygame implementiert. Dieses Mal habe ich ein Lebensspiel implementiert, das etwas vom Spiel entfernt ist. (Der Name enthält ein Spiel, aber es ist kein Spiel, daher ist es sicher.) Die Schwierigkeit der Implementierung ist nicht so hoch.
Was ist ein Lebensspiel?
Lebensspiele sind einfach Simulationen des Lebens. Sie können beobachten, wie Kreaturen im Laufe der Zeit geboren werden und sterben. In Lebensspielen gibt es nur wenige Regeln, und die Anzahl der als Zellen bezeichneten Blöcke wird entsprechend aktualisiert.
Lebensspielregeln
Die Regeln für die Aktualisierung des Lebensspiels sind in Geburt, Überleben und Tod unterteilt.
Geburt ist, wenn eine Zelle tot ist, eine Zelle geboren wird, die in einer benachbarten Zelle lebt, aber wenn drei neue Zellen in dieser Zelle leben, werden sie geboren.
Andererseits überlebt eine lebende Zelle, wenn die Anzahl benachbarter lebender Zellen 3 oder 4 beträgt, und stirbt zu anderen Zeiten. Der Tod hier entspricht der Entvölkerung und Überfüllung der realen Welt.
In der folgenden Abbildung werden die Regeln für Geburt, Überleben, Tod (Entvölkerung) und Tod (Überfüllung) jeweils von links auf die mittlere Zelle angewendet.
Sie können frei entscheiden, wie viele Zellen Sie benötigen, damit die Regel angewendet wird. Dieses Mal habe ich die oben erläuterte Nummer verwendet, die häufig verwendet wird.
Implementierung
Grundsätzlich habe ich es wie erklärt implementiert. Es ist wichtig zu beachten, dass beim Aktualisieren von Zellen, wenn sie nacheinander aktualisiert werden, die Zellen sofort sterben können. Daher ist es beim Aktualisieren einer Zelle erforderlich, den aktualisierten Zellenstatus einmal an einem anderen Ort zu halten und alles auf einmal zu aktualisieren, nachdem alle aktualisierten Zustände erhalten wurden. (Ich blieb stecken, als ich das Lebensspiel zum ersten Mal implementierte) Außerdem haben wir diesmal einige Funktionen hinzugefügt.
Farbbildschirm
Die meisten Lebensspiele zeigen Zellen in einer Farbe an, aber diesmal habe ich mehrfarbige Zellen verwendet. Insbesondere haben wir im Ausgangszustand mit vier Arten von Weiß, Grün, Rot und Blau begonnen, und wenn der Geburtsprozess durchgeführt wird, werden Zellen mit der durchschnittlichen Farbe benachbarter Zellen geboren.
Tasteneingabe
Mit den Pfeiltasten können Sie den Zeitablauf schnell vor- und vorspulen und mit den Zifferntasten jederzeit initialisieren. Wenn die gedrückte anfängliche Zifferntaste n ist, wird sie initialisiert, so dass das Zellenverhältnis n0% beträgt.
Programmkörper
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 #Zeichengeschwindigkeit
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]])
#Zufällig initialisiertes Flag=Wenn True, ist die Farbe ebenfalls zufällig
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: #Tote Zelle
if count == 3: #Geburt
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: #nicht entvölkert oder überfüllt
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()
Es ist viel kürzer als das letzte Tetris.
Ausgabebildschirm
Es sieht aus wie ein Sandsturm. Das Zellverhältnis beträgt 30%.
Einige Zeit ist vergangen. Ich habe das Gefühl, dass die Farbmischung (Paarung) gut voranschreitet.
Wie erwartet gibt es viele schmutzige Farben, die am Ende des Lebens überleben. Es scheint, dass die Farbmischung so weit fortgeschritten ist. Anfangs waren es so viele.
abschließend
Dies ist das Ende der Implementierung des Lebensspiels. Um die Wahrheit zu sagen, wollte ich etwas mehr Funktionen hinzufügen, gab aber auf, weil die Verarbeitungsgeschwindigkeit von Python verdächtig war. Vielleicht werde ich es mit C ++ neu implementieren. Wir sehen uns wieder
Recommended Posts