Conways Game of Life (Simulationen)
ConwaysJohn H. Conway, englischer Mathematiker (* 1937) Game of Life ist eine Populations-Simulation, die in einem Raster (beliebig großes Schachbrett) Zellen überleben, sterben oder neu bilden lässt. Das Überleben oder Neubilden von Zellen hängt allein von ihren umliegenden acht Quadraten ab.
Es gelten die folgenden Regeln:
- Wenn eine Zelle höchstens eine Nachbarzelle hat, stirbt sie an Vereinsamung. Das heißt, sie wird nicht in die nächste Generation übernommen.
- Wenn eine Zelle vier oder mehr Nachbarzellen hat, so stirbt sie an Übervölkerung. Das heißt, auch sie wird nicht in die nächste Generation übernommen.
- Hat eine Zelle zwei oder drei Nachbarzellen, so überlebt sie. Das bedeutet, sie wird in die nächste Generation übernommen.
- Wenn ein leeres Quadrat in den umliegenden acht Quadraten genau drei Nachbarzellen hat, dann entsteht dort durch Vermehrung eine neue Zelle in der nächsten Generation.
Schreiben Sie nun ein Programm, das ein 20x20-Raster Boole'scher Werte mit zufälligen Zellen füllt. (Eine Wahrscheinlichkeit von 25%, dass ein Quadrat eine Zelle enthält, hat sich in Tests als spannend erwiesen.)
Programmieren Sie den "Überlebensschritt" nach obigen Regeln und geben Sie einige Generationen aus.
0 Kommentare
5 Lösung(en)
import java.util.Scanner;
public class GameOfLife {
public static void main(String[] args) {
new GameOfLife().top(); }
int KANTENLAENGE = 30 ;
float FUELLFAKTOR = 0.25f;
boolean feld [][];
void top() {
initialisiereFeld(KANTENLAENGE);
fuelleFeld();
boolean weiter;
weiter = true;
while(weiter) {
zeigeFeld();
naechsteGenerationFeld();
weiter = weiterMachen(); }
}
void fuelleFeld() {
int x = 0;
while(x < kantenLaenge()) {
fuelleZeile(x);
x = x + 1; }
}
void fuelleZeile(int x) {
int y = 0;
while(y < kantenLaenge()) {
if(Math.random() < FUELLFAKTOR) {
feld[x][y] = true; }
y = y + 1; }
}
void naechsteGenerationFeld() {
boolean[][] feldcpy = new boolean[kantenLaenge()][kantenLaenge()]; // quadratisch
int x = 0;
while(x < kantenLaenge()) {
naechsteGenerationZeile(feldcpy, x);
x = x + 1; }
feld = feldcpy; }
void naechsteGenerationZeile(boolean[][] feldcpy, int x) {
int y = 0;
while(y < kantenLaenge()) {
feldcpy[x][y] = regel(x, y);
y = y + 1;}
}
int kantenLaenge() {
return feld.length; }
/**
* Es wird geprüft, ob an Stelle x,y ein (evtl. neues) "Bakterium" entsteht.
* @return
*/
boolean regel(int x, int y) {
int anzahlLebende = totalIn3x3(x, y);
// Vereinsamt oder verhungert:
if(anzahlLebende < 3 || anzahlLebende >4) {
return false; }
// Überlebt
if(feld[x][y] && (3 == anzahlLebende || 4 == anzahlLebende)) {
return true; }
// neu geboren
if(!feld[x][y] && (3 == anzahlLebende)) {
return true; }
// nicht neu geboren, da zu wenig oder zu viele Nachbarzellen.
return false; }
/**
* Wie viele Felder "leben" im 3x3-Feld um (x, y) inklusive (x, y)
*/
int totalIn3x3(int x, int y) {
int xStart = min(x);
int xEnd = max(x);
int yEnd = max(y);
int summe = 0;
while(xStart <= xEnd) {
int yStart = min(y);
while(yStart <= yEnd) {
if(feld[xStart][yStart]) {
summe = summe + 1; }
yStart = yStart + 1; }
xStart = xStart + 1; }
return summe;
}
/**
* Minimalwert im 3x3 Feld = 0 oder >0
* @param xy x or y
*/
int min(int xy) {
return Math.max(0, xy - 1); }
/**
* Maximalwert im 3x3 Feld = kantenLaenge -1 oder kleiner
* @param xy x or y
*/
int max(int xy) {
return Math.min(xy + 1, kantenLaenge() - 1); }
void zeigeFeld() {
for(boolean [] zeile : feld) {
for(boolean feld : zeile) {
if(feld) {
System.out.print('*'); }
else {
System.out.print(' ');
}
}
System.out.println(); }
}
void initialisiereFeld(int groesse) {
feld = new boolean[groesse][groesse]; }
boolean weiterMachen() {
Scanner sc = new Scanner(System.in);
System.out.println("Weiter (ja, nein)? :");
String eingabe;
eingabe = sc.next();
return ! eingabe.startsWith("n"); }
} // end of class GameOfLive
// Processing
// grafische Loesung
// Mausklick loest nächste Generation aus
// by Igo Schaller
int Kantenlaenge = 10;
gameOfLife Spiel = new gameOfLife();
PFont schrift;
// setup() wird beim Start einmal ausgefuehrt
void setup() {
background(200,200,200);
stroke(100,100,100);
size(520,520);
smooth();
schrift = loadFont("AlbaSuper-40.vlw");
Spiel.zufaelligFuellen();
Spiel.zeichnen();
noLoop();
}
void draw() {
background(255);
Spiel.evolution();
Spiel.zeichnen();
}
void mousePressed() {
redraw(); // führt den Code in draw() einmal aus
}
// Klasse gameOfLife
class gameOfLife {
float StartZufall = 0.25;
boolean[][] spielfeld = new boolean[Kantenlaenge][Kantenlaenge]; // 2D-Array mit Diemsion Kantenlaenge
int Generation;
// Konstruktor
gameOfLife() {
// Spielfeld wird mit lauter toten Zellen (=false) gefuellt
for (int j = 0; j < Kantenlaenge; j++) { // j geht die Zeilen des Feldes durch
for (int i = 0; i < Kantenlaenge; i++) { // i geht die Spalten des Feldes durch
spielfeld[i][j] = false;
}
}
}
// Zufaellige Startpopulation
void zufaelligFuellen() {
for (int j = 0; j < Kantenlaenge; j++) {
for (int i = 0; i < Kantenlaenge; i++) {
//wenn die Zufallszahl kleiner dem Startzufall ist, so wird die Zelle lebendig (=true)
if (random(1) < StartZufall) {
spielfeld[i][j] = true;
}
}
}
}
// naechste Generation
void evolution() {
boolean[][] naechsteGeneration = new boolean[Kantenlaenge][Kantenlaenge];
boolean Antwort;
//naechste Generation berechnen
for (int j = 0; j < Kantenlaenge; j++) {
for (int i = 0; i < Kantenlaenge; i++) {
Antwort = LebenOderTod(i,j);
if (Antwort == true) {
naechsteGeneration[i][j] = true;
}
else
{
naechsteGeneration[i][j] = false;
}
}
}
// berechnete Generation auf Spielfeld uebertragen
for (int j = 0; j < Kantenlaenge; j++) {
for (int i = 0; i < Kantenlaenge; i++) {
spielfeld[i][j] = naechsteGeneration[i][j];
}
}
}
// Methode berechnet ob eine Zelle aufgrund der Regeln lebend oder tod ist
boolean LebenOderTod(int xPos, int yPos) {
int anzLeben;
anzLeben = anzahlLeben3x3(xPos, yPos);
// vereinsamt oder verhungert
if (anzLeben < 3 || anzLeben > 4) {
return false;
}
// überlebend
if (spielfeld[xPos][yPos] && (anzLeben == 3 || anzLeben == 4 )) {
return true;
}
// geboren
if (!spielfeld[xPos][yPos] && anzLeben == 3) {
return true;
}
// nicht neu geboren, da zu viele Nachbarn
return false;
}
// Methode zaehlt wieviele Zellen im 3x3 Quadrat um eine Zelle herum inkl. der Zelle selber leben
int anzahlLeben3x3(int x, int y) {
int resultat = 0;
for (int j = y-1; j <= y+1; j++) {
for (int i = x-1; i <= x+1; i++) {
if (i>=0 && i<Kantenlaenge && j>=0 && j<Kantenlaenge) {
if (spielfeld[i][j] == true) {
resultat++;
}
}
}
}
return resultat;
}
// die Population zeichnen
void zeichnen(){
background(0);
color feldFarbe;
float feldLaenge = width/Kantenlaenge;
float pxPosX, pxPosY;
// falls Feld lebend Fuellfarbe gleich Rot setzen, sonst gleich weiss setzen
for (int j = 0; j < Kantenlaenge; j++) {
for (int i = 0; i < Kantenlaenge; i++) {
pxPosX = i * feldLaenge;
pxPosY = j * feldLaenge;
if (spielfeld[i][j] == true) {
feldFarbe = color(255,0,0);
}
else
{
feldFarbe = color(255,255,255);
}
fill(feldFarbe);
rect(pxPosX, pxPosY, pxPosX + feldLaenge, pxPosY + feldLaenge);
}
}
}
}
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
void Erstellen (const, int, int*, int*, int*, int*, int*, int*);
void NaechsteRunde (const, int, int*, int*, int*, int*, int*, int*);
int main (int argc, char** argv){
const n=5;
int i=0;
int Durchgang=0;
int V0[n];
int V1[n];
int V2[n];
int V3[n];
int V4[n];
int V5[n];
for (Durchgang=0; Durchgang <10; Durchgang++){ //10 Durchgaenge
if (Durchgang==0){
printf("Nach dem %i. Durchgang.\n", Durchgang);
Erstellen (n, i, V0, V1, V2, V3, V4, V5);
}
printf("Nach dem %i. Durchgang.\n", Durchgang+1);
NaechsteRunde(n, i, V0, V1, V2, V3, V4, V5);
}
return 0;
}
void Erstellen (const n,int i, int V0[n], int V1[n], int V2[n], int V3[n], int V4[n], int V5[n]){
int Prozent = 25;
srand(time(NULL));
for (i=0; i<=n; i++){ // Erstellen 0. Vertikale
V0[i]= (rand() %(100/Prozent));
if (V0[i]!=1){
V0[i]=0;
}
printf("%i", V0[i]);
}
printf("\n");
for (i=0; i<=n; i++){ // Erstellen 1. Vertikale
V1[i]= (rand() %(100/Prozent));
if (V1[i]!=1){
V1[i]=0;
}
printf("%i", V1[i]);
}
printf("\n");
for (i=0; i<=n; i++){ // Erstellen 2. Vertikale
V2[i]= (rand() %(100/Prozent));
if (V2[i]!=1){
V2[i]=0;
}
printf("%i", V2[i]);
}
printf("\n");
for (i=0; i<=n; i++){ // Erstellen 3. Vertikale
V3[i]= (rand() %(100/Prozent));
if (V3[i]!=1){
V3[i]=0;
}
printf("%i", V3[i]);
}
printf("\n");
for (i=0; i<=n; i++){ // Erstellen 4. Vertikale
V4[i]= (rand() %(100/Prozent));
if (V4[i]!=1){
V4[i]=0;
}
printf("%i", V4[i]);
}
printf("\n");
for (i=0; i<=n; i++){ // Erstellen 5. Vertikale
V5[i]= (rand() %(100/Prozent));
if (V5[i]!=1){
V5[i]=0;
}
printf("%i", V5[i]);
}
printf("\n\n");
}
void NaechsteRunde(const n, int i, int V0[], int V1[], int V2[], int V3[], int V4[], int V5[]){
for (i=0; i<=n; i++){ // Prüfen von 0.Zeile******************************************************
int Zaehler=0;
if (V0[i-1]==1){ //Mitte Links
Zaehler++;
}
if (V0[i-1]==1){ //Mitte rechts
Zaehler++;
}
if (V1[i-1]==1){ //Unten links
Zaehler++;
}
if (V1[i]==1){ //Unten Mitte
Zaehler++;
}
if (V1[i+1]==1){ //Unten Rechts
Zaehler++;
}
if(V0[i]==1){ //Eigentliches Feld mit Zelle
if(Zaehler<2){ //Einsamkeit
V0[i]=0;
printf("%i",V0[i]);
continue;
}
if(Zaehler>3){ //Ueberbefoelkerung
V0[i]=0;
printf("%i",V0[i]);
continue;
}
} else{
if(Zaehler==3){ //Neue Zelle entsteht
V0[i]=1;
printf("%i",V0[i]);
continue;
}
}
printf("%i",V0[i]);
}
printf("\n");
for (i=0; i<=n; i++){ // Prüfen von 1.Zeile******************************************************
int Zaehler=0;
if (V0[i-1]==1){ //Oben links
Zaehler++;
}
if (V0[i]==1){ //Obern Mitte
Zaehler++;
}
if (V0[i+1]==1){ //Oben Rechts
Zaehler++;
}
if (V1[i-1]==1){ //Mitte Links
Zaehler++;
}
if (V1[i-1]==1){ //Mitte rechts
Zaehler++;
}
if (V2[i-1]==1){ //Unten links
Zaehler++;
}
if (V2[i]==1){ //Unten Mitte
Zaehler++;
}
if (V2[i+1]==1){ //Unten Rechts
Zaehler++;
}
if(V1[i]==1){ //Eigentliches Feld mit Zelle
if(Zaehler<2){ //Einsamkeit
V1[i]=0;
printf("%i",V1[i]);
continue;
}
if(Zaehler>3){ //Ueberbefoelkerung
V1[i]=0;
printf("%i",V1[i]);
continue;
}
} else{
if(Zaehler==3){ //Neue Zelle entsteht
V1[i]=1;
printf("%i",V1[i]);
continue;
}
}
printf("%i",V1[i]);
}
printf("\n");
for (i=0; i<=n; i++){ // Prüfen von 2.Zeile******************************************************
int Zaehler=0;
if (V1[i-1]==1){ //Oben links
Zaehler++;
}
if (V1[i]==1){ //Obern Mitte
Zaehler++;
}
if (V1[i+1]==1){ //Oben Rechts
Zaehler++;
}
if (V2[i-1]==1){ //Mitte Links
Zaehler++;
}
if (V2[i-1]==1){ //Mitte rechts
Zaehler++;
}
if (V3[i-1]==1){ //Unten links
Zaehler++;
}
if (V3[i]==1){ //Unten Mitte
Zaehler++;
}
if (V3[i+1]==1){ //Unten Rechts
Zaehler++;
}
if(V2[i]==1){ //Eigentliches Feld mit Zelle
if(Zaehler<2){ //Einsamkeit
V2[i]=0;
printf("%i",V2[i]);
continue;
}
if(Zaehler>3){ //Ueberbefoelkerung
V2[i]=0;
printf("%i",V2[i]);
continue;
}
} else{
if(Zaehler==3){ //Neue Zelle entsteht
V2[i]=1;
printf("%i",V2[i]);
continue;
}
}
printf("%i",V2[i]);
}
printf("\n");
for (i=0; i<=n; i++){ // Prüfen von 3.Zeile******************************************************
int Zaehler=0;
if (V2[i-1]==1){ //Oben links
Zaehler++;
}
if (V2[i]==1){ //Obern Mitte
Zaehler++;
}
if (V2[i+1]==1){ //Oben Rechts
Zaehler++;
}
if (V3[i-1]==1){ //Mitte Links
Zaehler++;
}
if (V3[i-1]==1){ //Mitte rechts
Zaehler++;
}
if (V4[i-1]==1){ //Unten links
Zaehler++;
}
if (V4[i]==1){ //Unten Mitte
Zaehler++;
}
if (V4[i+1]==1){ //Unten Rechts
Zaehler++;
}
if(V3[i]==1){ //Eigentliches Feld mit Zelle
if(Zaehler<2){ //Einsamkeit
V3[i]=0;
printf("%i",V3[i]);
continue;
}
if(Zaehler>3){ //Ueberbefoelkerung
V3[i]=0;
printf("%i",V3[i]);
continue;
}
} else{
if(Zaehler==3){ //Neue Zelle entsteht
V3[i]=1;
printf("%i",V3[i]);
continue;
}
}
printf("%i",V3[i]);
}
printf("\n");
for (i=0; i<=n; i++){ // Prüfen von 4.Zeile******************************************************
int Zaehler=0;
if (V3[i-1]==1){ //Oben links
Zaehler++;
}
if (V3[i]==1){ //Obern Mitte
Zaehler++;
}
if (V3[i+1]==1){ //Oben Rechts
Zaehler++;
}
if (V4[i-1]==1){ //Mitte Links
Zaehler++;
}
if (V4[i-1]==1){ //Mitte rechts
Zaehler++;
}
if (V5[i-1]==1){ //Unten links
Zaehler++;
}
if (V5[i]==1){ //Unten Mitte
Zaehler++;
}
if (V5[i+1]==1){ //Unten Rechts
Zaehler++;
}
if(V4[i]==1){ //Eigentliches Feld mit Zelle
if(Zaehler<2){ //Einsamkeit
V4[i]=0;
printf("%i",V4[i]);
continue;
}
if(Zaehler>3){ //Ueberbefoelkerung
V4[i]=0;
printf("%i",V4[i]);
continue;
}
} else{
if(Zaehler==3){ //Neue Zelle entsteht
V4[i]=1;
printf("%i",V4[i]);
continue;
}
}
printf("%i",V4[i]);
}
printf("\n");
for (i=0; i<=n; i++){ // Prüfen von 5.Zeile******************************************************
int Zaehler=0;
if (V4[i-1]==1){ //Oben links
Zaehler++;
}
if (V4[i]==1){ //Obern Mitte
Zaehler++;
}
if (V4[i+1]==1){ //Oben Rechts
Zaehler++;
}
if (V5[i-1]==1){ //Mitte Links
Zaehler++;
}
if (V5[i-1]==1){ //Mitte rechts
Zaehler++;
}
if(V5[i]==1){ //Eigentliches Feld mit Zelle
if(Zaehler<2){ //Einsamkeit
V5[i]=0;
printf("%i",V5[i]);
continue;
}
if(Zaehler>3){ //Ueberbefoelkerung
V5[i]=0;
printf("%i",V5[i]);
continue;
}
} else{
if(Zaehler==3){ //Neue Zelle entsteht
V5[i]=1;
printf("%i",V5[i]);
continue;
}
}
printf("%i",V5[i]);
}
printf("\n");
}
Lösung von: Felix Girke (DHBW Stuttgart)
# frozen_string_literal: false
# Klasse fuer Conway's Game of Life
class Conway
# Instanzen-Variablen:
@field = nil
@size_x = 0
@size_y = 0
@seed = nil
# Getter + Setter:
attr_accessor :size_x, :size_y, :field, :seed
# Konstruktor:
def initialize(size_x, size_y, probability, seed = Random.new.seed)
@size_x = size_x
@size_y = size_y
@seed = Random.new(seed)
@field = Array.new(size_x) { Array.new(size_y) { @seed.rand(0..100) < probability ? 1 : 0 } }
end
def to_s
return nil if @field.nil?
s = ''
@field.each do |i|
i.each do |j|
s += ' ' if j.zero?
s += 'O ' if j.positive?
end
s += "\n"
end
s
end
def clear
puts "\e[H" # Cursor an 1,1 setzen und vorhandenen Text ueberschreiben
end
def initial_clear
puts "\e[H\e[2J" # gesamte Ausgabe loeschen
end
def live
return if @field.nil?
new_field = Array.new(@size_x) { Array.new(@size_y) { 0 } }
(0..@field.size - 1).each do |i|
(0..@field[i].size - 1).each do |j|
neighbors = 0 - @field[i][j] # Betrachtetes Feld selbst abziehen
i_min = i.zero? ? 0 : -1
i_max = i == @field.size - 1 ? 0 : 1
j_min = j.zero? ? 0 : -1
j_max = j == @field[i].size - 1 ? 0 : 1
(i_min..i_max).each do |a|
(j_min..j_max).each do |b|
neighbors += @field[i + a][j + b]
end
end
new_field[i][j] = case [neighbors, @field[i][j]] # Conway-Regeln
when [2, 1]
1
when [3, 1]
1
when [3, 0]
1
else
0
end
end
end
@field = new_field
end
end
# x-Groesse, y-Groesse, "Bevoelkerungsdichte" in Prozent (0-100), Seed
c = Conway.new(20, 20, 25)
c.initial_clear
begin
loop do
puts c.to_s << "End with Ctrl-C\n"
sleep 0.05
c.live
c.clear
end
rescue Interrupt
puts format('Bye. This game was presented to you by seed %s.', c.seed.seed.to_s)
end
# Anmerkung: Am besten zu geniessen auf einem Vollbild-Terminal. :-)
# Verwendung mit Beispiel-Seed: Conway.new(20, 20, 25, 37277149346478517338418324281306208128)
Lösung von: Ich Bins (tubs)
# -*- coding: utf-8 -*-
# Python 3.8.5
# Importieren der Pygame-Bibliothek
import pygame, random, copy
from pygame.locals import *
# Rastergröße
n = 20
# Größen Multiplikator
MULTIPLIKATOR = 13
# Spielfeld erzeugen über Berechnung
fenster = pygame.display.set_mode((n* MULTIPLIKATOR, n * MULTIPLIKATOR))
# Titel für Fensterkopf
pygame.display.set_caption("Conways Game of Life ist eine Populations-Simulation.")
spielaktiv = True
# Bildschirm Aktualisierungen einstellen
clock = pygame.time.Clock()
# genutzte Farben
ORANGE = ( 255, 140, 0)
BLUE = ( 21, 116, 193)
SCHWARZ = ( 0, 0, 0)
Hintergrund = ( 7, 54, 66)
farbe = [ ORANGE, BLUE, SCHWARZ ]
# Variablen
population = [0,0,0,1] # 25%
raster = []
a = 0
# Funktionen
def ausgabe(liste):
''' print Liste formatiert '''
s = 0
for i in liste:
s = s + sum(i)
print(i)
print('Lebende',s)
def erstelle_raster(n):
''' raster mit Werten füllen. '''
R = []
for i in range(n):
r = []
for j in range(n):
r.append(random.choice(population))
R.append(r)
#ausgabe(R)
raster.append(R)
def position(z,s,liste):
''' Umliegenden acht Quadraten der Position überprüfen. '''
global n, b
try: a = liste[z-1][s-1];
except: a = 0
try: b = liste[z-1][s]
except: b = 0
try: c = liste[z-1][s+1]
except: c = 0
try: d = liste[z][s-1]
except: d = 0
try: e = liste[z][s] # Mittelpunkt
except: e = 0
try: f = liste[z][s+1]
except: f = 0
try: g = liste[z+1][s-1]
except: g = 0
try: h = liste[z+1][s]
except: h = 0
try: i = liste[z+1][s+1]
except: i = 0
if z == 0: a,b,c = 0,0,0
if z == n-1: g,h,i = 0,0,0
if s == 0: a,d,g = 0,0,0
if s == n-1: c,f,i = 0,0,0
U = [a,b,c,d,e,f,g,h,i]
umgebung = sum(U)
# Regeln:
# Wenn eine position höchstens eine Nachbarposition hat, stirbt sie an Vereinsamung.
# Das heißt, sie wird nicht in die nächste Generation übernommen.
if e == 1 and umgebung == 2:
return 0
# Wenn eine position vier oder mehr Nachbarpositionn hat, so stirbt sie an Übervölkerung.
# Das heißt, auch sie wird nicht in die nächste Generation übernommen.
if e == 1 and umgebung >= 5:
return 0
# Hat eine position zwei oder drei Nachbarpositionn, so überlebt sie.
# Das bedeutet, sie wird in die nächste Generation übernommen.
if e == 1 and umgebung == 3 or umgebung == 4:
return 1
# Wenn ein leeres Quadrat in den umliegenden acht Quadraten genau drei Nachbarpositionn hat,
# dann entsteht dort durch Vermehrung eine neue position in der nächsten Generation.
if e == 0 and umgebung == 3:
return 1
return 0
def ueberlebensschritt(liste):
''' Überlebende ermitteln '''
raster_neu = copy.deepcopy(liste)
for z in range(n):
for s in range(n):
e = position(z,s,liste)
raster_neu[z][s] = e
print()
#ausgabe(raster_neu)
raster.append(raster_neu)
return raster_neu
# GUI Funktionen
def kor(zahl):
''' Korrekturfaktor berechnen '''
zahl = zahl * MULTIPLIKATOR
return zahl
def element_zeichnen(spalte,reihe):
''' Spielelement zeichnen '''
pygame.draw.rect(fenster, farbe[b], [kor(spalte)+1, kor(reihe)+1,kor(1)-1,kor(1)-1])
def element(karte):
''' Ausgabe Mauersteine im Spielfenster '''
global b; b = 0
for x in range(n):
for y in range(n):
if karte[y][x] != 0:
element_zeichnen(x,y)
b += 1 # Farbe wechseln
if b > 2:
b = 0
# ------------------ Start --------------------
erstelle_raster(n)
fenster.fill(Hintergrund)
while spielaktiv:
''' Hauptschleife '''
# Überprüfen, ob Nutzer eine Aktion durchgeführt hat
for event in pygame.event.get():
if event.type == pygame.QUIT or event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
spielaktiv = False
print("Spieler hat beendet")
# Elemente zur ausgabe
if a == 0: element(raster[0])
if a > 0: element(ueberlebensschritt(raster[a-1]))
# Fenster aktualisieren
pygame.display.flip()
# Refresh-Zeiten festlegen
clock.tick(10)
# lösche Fenster
fenster.fill(Hintergrund)
a += 1
pygame.quit()
Lösung von: Alex Groeg (Freies Lernen)
Verifikation/Checksumme:
Hier eine mögliche "Life" Population. Nach einigen Generationen stellt man immer wieder die selben Muster fest:
Aktionen
Neue Lösung hinzufügen
Bewertung
Durchschnittliche Bewertung:
Meta
Zeit: | 2-4 |
Schwierigkeit: | k.A. |
Webcode: | ch5c-67pm |
Autor: | Philipp G. Freimann (BBW (Berufsbildungsschule Winterthur) https://www.bbw.ch) |