def oppdatering(self):
ded2lev = [] # Tomme lister
lev2ded = []
self.generasjon += 1 # Øker gen.#
for i in range(len(self.rutenett)):
for j in range(len(self.rutenett[i])): # Går inn på hvert objekt
naboer = self.finnNabo(i,j) # Kaller på finnNabo som gir en liste
teller = 0 # Setter teller lik 0
for cell in naboer:
if cell.erLevende():
teller += 1 # Øker teller proporsjonalt med antall levende naboer
if self.rutenett[i][j].erLevende():
if teller < 2 or teller > 3: # Dersom det er færre enn 2 eller flere enn 3 naboer
lev2ded.append(self.rutenett[i][j]) # Legg til disse i lista der cellene skal dø
else:
if teller == 3: # Dersom en død celle har akkurat 3 celler
ded2lev.append(self.rutenett[i][j]) # Gjenoppliv den cella
# Oppdaterer hvilke celler som er døde og levenende for neste gen.
for cell in ded2lev:
Celle.settLevende(cell)
for cell in lev2ded:
Celle.settDoed(cell)
def generer(self,ruter): # Metode generer
for i in range(len(ruter)):
for j in range(len(ruter[i])):
x = Celle() # Lager et objekt av klassen Celle
if randint(0,2) == 1: # En viss sannsynlighet for at cellen er levende
x.settLevende()
ruter[i][j] = x # Objektet blir lagt til på sin plass
else:
ruter[i][j] = x
def _generer(self):
self.rutenett = []
for i in range(self._rader):
self.rutenett.append([])
for i in self.rutenett:
for k in range(self._kolonner):
tmp = Celle()
if random.randint(0, 3) == 0:
tmp.settLevende()
i.append(tmp)
def main():
liv1 = Celle()
liv1.settLevende()
print(liv1.erLevende())
liv2 = Celle()
print(liv2.erLevende())
print(liv1.hentStatusTegn())
print(liv2.hentStatusTegn())
def _generer(self):
for y in range(
self._rader
): # fyller rutenettet med lister som skal representere rader, y-retning
self._rutenett.append([])
for _ in range(
self._kolonner
): # skal fylle hver rad med celler i x-retning. _ brukes isteden for x for vi har ikke nytte av variabelen her
seed = randint(0, 2) # tilfeldig taLL 0-2
if seed == 0: # 1/3 sjangse for at cellen spawner levende
self._rutenett[y].append(Celle(True))
else: # 2/3 sjangse for at cellen spawner død
self._rutenett[y].append(Celle(False))
def _generer(self):
rutenett = []
for j in range(self._rader):
rutenett.append([])
for i in range(self._kolonner):
#rutenett[j].append(Celle())
giStatus = randint(0, 2)
nycelle = Celle()
if giStatus == 0:
#objekt = Celle().settLevende()
#rutenett[j].append(Celle().settLevende())
nycelle.settLevende()
rutenett[j].append(nycelle)
return rutenett
def preGenerer(self):
for i in range(self._rader):
liste = []
self._rutenett.append(liste)
for j in range(self._kolonner):
enCelle = Celle()
liste.append(enCelle)
def tegnBrett(self):
for radene in self._rader:
rader = []
for kolonnene in self._rader:
kolonnene = Celle()
rader.append(kolonnene)
self._rutenett.append(rader)
def __init__(self, rader, kolonner):
self._rader = rader
self._kolonner = kolonner
self._rutenett = [[Celle() for i in range(self._kolonner)]
for i in range(self._rader)]
self.gen = 0
def lagBrett(self):
for r in range(self._rader):
#Oppretter en liste for hver rad.
liste = []
for k in range(self._kolonner):
#Legger til celler i hver rute i rutenettet.
celler = Celle()
liste.append(celler)
self._rutenett.append(liste)
def makeBoard(self):
for i in range(self._row):
for j in range(self._column):
self._cellsList.append(Celle())
rand = randint(0,4)
if rand == 2:
self._cellsList[j].settLevende()
self._cellsGrid.append(self._cellsList)
self._cellsList = []
def lagListe(self):
self._rutenett = []
for i in range(self._rader):
b = []
for j in range(self._kolonner):
nyCelle = Celle()
b.append(nyCelle)
self._rutenett.append(b)
return self._rutenett
def __init__(self, rad, kol):
self._rader = rad
self._kolonner = kol
self._rutenett = []
for j in range(rad):
self._rutenett.append([])
for i in range(kol):
self._rutenett[j].append(Celle())
self._generer()
self.tegnBrett()
def __init__(self, rader, kolonner): #oppretter konstruktoeren
self._rader = rader
self._kolonner = kolonner
self._rutenett = [] #oppretter rutenett
for i in range(self._rader):
self._rutenett.append([]) #oppretter en tom liste per rad
for j in range(self._kolonner):
self._rutenett[i].append(Celle()) #legger en celle inn i hver rute som opprettes basert paa antall kolonner
self._generasjonsnummer = 0
self._generer() #kaller paa generer for aa tilordne hver celle ny status
def _konstruerRutenett(self, rader, kolonner):
rutenett = []
# Legg til hver rad som en egen liste:
for rad_idx in range(rader):
rutenett.append([])
# Legg til celler likt antall kolonner, for hver rad:
for elem in range(kolonner):
nyCelle = Celle()
rutenett[rad_idx].append(nyCelle)
return rutenett
def __init__(self, rader, kolonner): # konstruktur med tre parameter
self._rader = rader
self._kolonner = kolonner
self._rutenett = [
] # oppretter et rutenett som tar antall rader gange antall kolooner.
for i in range(self._rader):
self._rutenett.append([])
for j in range(self._kolonner):
self._rutenett[i].append(Celle())
self._generasjonsnummer = 0 # opprette en generasjonsteller.
self.generer() # kaller på metoden generer
def __init__(self, rader, kolonner):
self._rader = rader
self._kolonner = kolonner
self._rutenett = []
for x in range(self._rader):
self._rutenett.append([])
for i in range(self._kolonner):
self._rutenett[x].append(Celle())
#setter _generasjonsnummer til 0 og kaller paa generer, som randomizes rutenettet
self._generasjonsnummer = 0
self._generer()
def __init__(self, rader, kolonner):
self._rader = rader
self._kolonner = kolonner
self._rutenett = []
for e in range(rader):
rad = []
self._rutenett.append(rad)
for i in range(kolonner):
rad.append(Celle())
self._generasjon = 0
self.generer()
def __init__(self, rader, kolonner):
"""Init metoden"""
self._rader = rader
self._kolonner = kolonner
self._rutenett = [
] #ikke nodvendig, men den er der i eksempelfilen, derfor lar den vare der
#genererer et objekter i en nøstet 2d liste med dimensjoner radar x kolonner
self._rutenett = [[Celle() for j in range(self._kolonner)]
for i in range(self._rader)]
self.generer()
self._generasjon = 0
def __init__(self, rader, kolonner):
self._rader = rader
self._kolonner = kolonner
self._generasjon = 0
# Oppretter et rutenett som en tom liste
self._rutenett = []
for i in range(self._rader):
self._rutenett.append([])
for j in range(self._kolonner):
self._rutenett[i].append(Celle())
# Genererer nullte versjon av spillebrettet
self._generer()
def __init__(self , rader, kolonner):
self._rader = rader
self._kolonner = kolonner
self._gnNr = 0
self._rutenett = []
nyCelle = Celle()
for i in range(self._rader):
liste = []
for e in range(self._kolonner):
liste.append(nyCelle)
self._rutenett.append(liste)
self.generer()
def __init__(self, rad, kolonne): #to parametre: antall rader og kolonner
self._rader = rad
self._kolonner = kolonne
self._rutenett = [] #opprettelsen av rutenettet
for x in range(self._rader):
self._rutenett.append([]) #radene opprettes
for y in range(self._kolonner):
#antall celler i hver rad = kolonner
self._rutenett[x].append(Celle()) #celler blir fylt inn
self._generasjon = 0 #generasjonsvariabel
self._generer() #cellene endres til levende, 1/3 sjanse
def __init__(self, bredde, hoyde):
self._rader = bredde
self._kolonner = hoyde
self._rutenett = []
# Fyll ting - maaagic
for x in range(self._rader): # 10
self._rutenett.append([])
for y in range(self._kolonner): # 20
self._rutenett[x].append(Celle())
self._generasjonsnummer = 0
self.generer()
def __init__(self, rader, kolonner):
self.rader = rader
self.kolonner = kolonner
self.generasjonsnummer = 0
self.brett = []
for i in range(self.rader):
rad = []
for j in range(self.kolonner):
rad.append(Celle())
self.brett.append(rad)
self.generer()
def generer(self):
tall = randint(0, 2)
celle = Celle()
if tall == 0:
celle.settLevende()
else:
celle.settDoed()
return celle
def __init__(self, rader, kolonner):
self._rader = rader
self._kolonner = kolonner
self.versjonsnummer = 0
self.antallCeller = self._rader*self._kolonner
self.nabo = []
celleHolder = []
for t in range(0, self.antallCeller):
celleHolder.append(Celle())
n = self._kolonner
self.brett = [celleHolder[i:i+n] for i in range(0, len(celleHolder), n)]
self._generer()
def hovedprogram():
'''celle1 = Celle()
print(celle1.hentStatusTegn())
celle1.settLevende()
print(celle1.hentStatusTegn())'''
celle1 = Celle()
etBrett = Spillebrett(20, 20)
etBrett.tegnBrett()
etBrett.finnAntallLevende()
etBrett.oppdatering()
etBrett.finnAntallLevende()
def __init__(self, rader, kolonner):
self._rader = rader
self._kolonner = kolonner
self._generasjon = 0
self._rutenett = []
# opprett spillebrett
for y in range(rader):
self._rutenett.append([])
for x in range(kolonner):
self._rutenett[y].append( Celle() )
# generer spillebrett
self._generer()
def __init__(self, rader, kolonner):
self._rader = rader
self._kolonner = kolonner
self._rutenett = []
# Her lager jeg en nøstet for-løkke for å fylle self._rutenett med
# Celle-objekter.
for i in range(self._rader):
rad = []
for j in range(self._kolonner):
rad.append(Celle())
self._rutenett.append(rad)
self._generasjonsnummer = 0
self.generer()
def __init__(self, rader, kolonner):
self._rader = rader
self._kolonner = kolonner
#Noestede lister som inneholder elementer generert fra klassen Celle().
self._rutenett = [[Celle() for x in range(self._kolonner)]
for y in range(self._rader)]
#variabel som holder styr paa generasjonsnummer.
#Starter generasjon paa -1 for at foerste generasjon skal bli nr. 0.
self._generasjon = -1
#Kaller paa metoden generer() som setter et tilfeldig antall av cellene
#til levende.
self.generer()