def Main():
bredde = int(input(
"hvor bred skal rutenettet være?")) # lar bruker velge bredde på brett
lengde = int(input(
"hvor lang skal rutenettet være?")) # lar bruker velge lengde på brett
spillebrett1 = Spillebrett(
bredde,
lengde) # oppretter objektet spillebrett med de to angitte parametere
spillebrett1.tegnBrett() # tegner gen 0
print("Generasjon:" + " " + str(spillebrett1.gennummer) + " - " +
"Antall levende celler:" + str(spillebrett1.finnAntallLevende())
) # printer antall levende celler og gen nummer
kommando = "" # oppretter kommandovariabel for den kontinuerlig kjørende løkka ( programmet)
while kommando != "q": # man skriver 1 i kommando for å avslutte
kommando = input(
"trykk enter for aa generere og skriv q for aa avslutte"
) # tar input som kommando
if kommando != "q": # om kommando ikke er q utføres opdateringen ellers avsluttes program for man looper til topp
spillebrett1.oppdatering() # oppdaterer spillebrett objekt
spillebrett1.tegnBrett() # tegner opp det nye brettet
print("Generasjon:" + " " + str(spillebrett1.gennummer) + " - " +
"Antall levende celler:" +
str(spillebrett1.finnAntallLevende())
) # printer antall levende celler og gen nummer
def main():
generation = 0
#Ber om antalll kolonner og rader
boardHight = int(input("Skriv inn hvor mange kolonner du vil ha: "))
boardWidth = int(input("Skriv inn hvor mange rader du vil ha: "))
#Konstruerer brett-objektet
board = Spillebrett(boardWidth, boardHight)
#Kaller metoden til brettobjektet som lager et nytt brett
board.makeBoard()
#Printer altall levende celler og generasjon
print("Antall levende celler: ", board.findAlive())
print("Dette er %s generasjon" % (generation))
#Kaller metoen som tegner brettet
board.drawBoard()
#Har en løkke som kjører så lenge input ikke er q
while input(
"tast q for å avslutte, eller bare tast enter for å fortsette: "
) != "q":
#Denne løkka er kun får å tømme sida.
for i in range(20):
print("\n")
#Oppdaterer generasjonen
generation += 1
#Oppdaterer alt
board.update()
print("Antall levende celler: ", board.findAlive())
print("Dette er %s generasjon" % (generation))
def main():
spillebrett = Spillebrett(50, 200)
spillebrett._generer()
spillebrett.tegnBrett()
drive = 1000
while drive > 1:
spillebrett.oppdatering()
spillebrett.tegnBrett()
drive -= 1
def main(): #prosedyren main
print("VELKOMMEN TIL GAME OF LIFE:")
print()
rad = int(
input("Vennligst skriv inn rader: ")) #brukeren skriver inn rader
kolonne = int(input(
"Vennligst skriv inn kolonner: ")) #brukeren skriver inn kolonner
spillebrett1 = Spillebrett(
rad,
kolonne) #lager objektet spillebrett1 med brukerens rader og kolonner
print()
spillebrett1.tegnBrett(
) #lager tegnebrettet som generer tilfeldige antall levende celler
sporsmal = input(
"Press ENTER for aa fortsette. q + ENTER for aa avslutte: "
) #spørsmål som spør brukeren om å fortsette
while sporsmal != "q": #så lenge svaret på spørsmålet ikke er q:
spillebrett1.oppdatering() #oppdateres spillebrett
spillebrett1.tegnBrett() #det oppdaterte spillbrettet tegnes
if spillebrett1.finnAntallLevende() == 0: #hvis alle cellene er døde
print("GAME OVER") #printes game over
exit() #og programmet stoppes
sporsmal = input(
"Press enter for aa fortsette. Skriv inn q og trykk enter for aa avslutte: "
) #looper hvis det fortsatt er levende celler
def main():
rader = int(input("Antall rader: "))
kolonner = int(input("Antall kolonner: "))
arg = Spillebrett(rader, kolonner)
arg.tegnBrett()
todo = True
while todo:
print("Generasjon: " + str(arg.generasjon))
print("Antall levende celler: " + str(arg.finnAntallLevende()))
action = input(
"Press enter for aa fortsette. Skriv inn q og trykk enter for aa avslutte: "
)
if action == "q":
break
elif action == "":
arg.oppdatering()
arg.tegnBrett()
else:
print("hei")
def main():
rader = int(input("Skriv inn antall rader:"))
kolonner = int(input("Skriv inn antall kolonner:"))
nyttSpillebrett = Spillebrett(rader, kolonner)
nyttSpillebrett.tegnBrett()
print()
print()
fortsette = True
while fortsette:
nyttSpillebrett.oppdatering()
nyttSpillebrett.generasjonsnummer()
nyttSpillebrett.finnAntallLevende()
fortsette = input("Press enter for aa fortsette. Skriv inn q og trykk enter for aa avslutte:")
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 main():
x, y = generateRandomNumber()
brett = Spillebrett(int(x), int(y))
print(
"trykk enter for aa fortsette, skriv q og trykk enter for aa avslutte: "
)
userInput = input()
while userInput == "":
brett.tegnBrett()
print(
"trykk enter for aa fortsette, skriv q og trykk enter for aa avslutte: "
)
userInput = input()
if "q" in userInput or "Q" in userInput:
pass
def main():
antallRader = int(input("Oppgi rader på rutenettet: "))
antallKolonner = int(input("Oppgi kolonner på rutenettet: "))
brett = Spillebrett(antallRader, antallKolonner)
#Denne def funksjonen er for at jeg trenger ikke å skrive de samme kodene om igjen senere i filen
def tegning():
#Her bør rutenettet skrives ut og oppgir antall generasjoner og levende celler
brett.tegnBrett()
def hentGenerasjonsnummer():
gen = brett._generasjonsnummer
return gen
hentGenerasjonsnummer()
print()
print("Generasjon: " + str(hentGenerasjonsnummer()) + " — " +
"Antall levende celler: " + str(brett.finnAntallLevende()))
tegning()
#brukeren velger hvilken de vil velge selv, om de vil programmet skal forsette eller ikke
trykk = input(
"Press enter for aa forsette. Skriv inn q og trykk enter for aa avslutte: "
)
while trykk != "q":
# if trykk == "\n":
tegning()
trykk = input(
"Press enter for aa forsette. Skriv inn q og trykk enter for aa avslutte: "
)
def main():
print("")
#2 inputs som spør bruker hvor stør de ønsker rutenettet
inp1 = int(input("Hvor mange rader? (bortover): "))
inp2 = int(input("Hvor mange kolonner? (nedover): "))
#kaller opp klassen Spillebrett med de 2 inputtene som argument
spill1 = Spillebrett(inp2, inp1)
#tom input, for å ikke spørre brukeren om noe før while-løkken har kjørt
inp = ""
#mens inp ^ (og inne i løkken) ikke er Q, kjøres koden
while inp != "q":
#stor linjeskift
print("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n")
#lager en border rundt rutenettet på lengden til radene
border = ""
for x in range(inp1):
border += "---"
print(border)
#kaller opp objektet med 2 metoder som tegner rutenettet, og deretter oppdateren den
spill1.tegnBrett()
spill1.oppdatering()
#Antall levende celler blir printet ut vha metoden "finnAntallLevende()"
print("Antall levende celler: ", spill1.finnAntallLevende())
print(border)
#input som spør brukeren om de vil avslutte eller fortsette - henger sammen med while-løkken
inp = input("Press enter for å fortsette. Skriv in q og trykk enter for å avslutte: ")
def main():
dimensjon1 = input("oppgi dimensjoner på spillebrettet.\n rader : ")
dimensjon2 = input(
"kolonner : ") # per brukeren om å teste antall rader og kolonner
klasse = Spillebrett(int(dimensjon1),
int(dimensjon2)) #definere en objke (kasse)
klasse._tegnBrett() # kaller på _tegnBrett
a = input(
'\nprss enter for å gå videre til neste steg og q for å avslutte programmet '
)
while a != "q": # lager en while løkke og skrive ut programet.
klasse.oppdatering()
klasse._tegnBrett()
print('\ngenerasjonsnummer er : ', klasse.hentGnerasjonsnummer())
print('\nantal levende er : ', klasse.finnAntallLevende())
a = input(
'\nprss enter for å gå videre til neste steg og q for å avslutte programmet '
)
def kjoerAutomatisk(rader, kolonner, antallGenerasjoner=10, delta=1, p=1 / 3):
# Utvidelse, for aa kjoere genereringen automatisk uten taste-input fra bruker under simuleringen.
spillebrett = Spillebrett(rader, kolonner, p)
spillebrett.tegnBrett()
ctr = 0
while ctr < antallGenerasjoner:
spillebrett.oppdatering()
spillebrett.tegnBrett()
sleep(delta)
ctr += 1
def main():
# Bruker oppgir dimensjonene til spillebrettet
rader = int(input("Oppgi antall rader: "))
kolonner = int(input("Oppgi antall kolonner: "))
# Oppretter den nullte versjonen av spillebrettet med dimensjonene
# som bruker oppga
spill = Spillebrett(rader, kolonner)
spill.tegnBrett()
print("Generasjon:", spill._generasjon, " - Antall levende celler:",
spill.finnAntallLevende())
# Oppretter en menylokke for brukeren
while True:
valg = input("Trykk enter for aa fortsette. Trykk q for aa avslutte: ")
if valg == "":
spill.oppdatering()
spill.tegnBrett()
# Printer ut generasjon og antall levende celler
print("Generasjon:", spill._generasjon, "- Antall levende celler:",
spill.finnAntallLevende())
else:
break
def main():
print("Game of life")
rader = int(input("Antall rader: "))
kolonner = int(input("Antall kolonner: "))
# Generate the board and plot generation 'zero'
Game = Spillebrett(rader, kolonner)
Game.tegnBrett()
print("\n\nGenereasjon: %g. Antall levende celler: %g" %(Game._gen, Game.finnAntallLevende()))
print("--"*41)
Next = input("Press enter to continue to the next generation, or 'q' and enter to quit the game. ")
# Keep opdting the game board until the user ends the game
while Next != "q":
Game.oppdatering()
Game.tegnBrett()
print("\n\nGenereasjon: %g. Antall levende celler: %g" %(Game._gen, Game.finnAntallLevende()))
print("--"*41)
Next = input("\nPress enter to continue to the next generation, or 'q' and enter to quit the game. ")
def kjoerInteraktivt(rader, kolonner):
# Prosedyre for aa kalle paa rette funksjoner/metoder naar den kjoerer "interaktivt".
# Samsvarer med oppgaveformuleringen i obligen.
spillebrett = Spillebrett(rader, kolonner)
spillebrett.tegnBrett()
brukervalg = input(
"Press enter for aa fortsette. Skriv inn q og trykk enter for aa avslutte: "
)
while brukervalg != "q":
spillebrett.oppdatering()
spillebrett.tegnBrett()
brukervalg = input(
"Press enter for aa fortsette. Skriv inn q og trykk enter for aa avslutte: "
)
def main():
print("Oppgi dimensjoner på spillebrettet")
kolonner = int(input("Antall kolonner: "))
rader = int(input("Antall rader: "))
nyttSpill = Spillebrett(rader, kolonner)
nyttSpill.tegnBrett()
#naboer = nyttSpill.finnNabo(1,0)
while (input("Trykk [q] for aa avslutte\nTrykk [enter] for aa fortsette\n"
).lower() != "q"):
nyttSpill.oppdatering()
nyttSpill.tegnBrett()
def main():
m = int(input("Skriv inn antall rader: ")) # Rader
n = int(input("Skriv inn antall kolonner: ")) # Kolonner
spill = Spillebrett(m, n) # Lager et objekt av Spillebret
spill.tegnBrett() # Skriver ut brett til den 0. generasjonen
k = True # Boolsk variabel
while k: # Løkke
g = input(
"Trykk Enter for neste generasjon \nSkriv q for å avslutte: \n")
if g == "q":
k = False
else:
spill.oppdatering(
) # Hvis ikke bruker avslutter, skal brettet oppdatere seg
spill.tegnBrett() # Og skrives ut for neste generasjon
def main():
#Lar brukeren velge antall rader og kolonner
rad = int(input("Skriv inn hvor mange rader du vil ha: "))
kolonne = int(input("Skriv inn hvor mange kolonner du vil ha: "))
#lager spillebrett objekt med rad og kolonne som brukeren velger
test = Spillebrett(rad, kolonne)
#tegner brettet en gang forst
test.tegnBrett()
#lager variabel som skjekker om brukeren vil fortsette eller ikke
fortsett = input("Vil du fortsette? (Skriv q for å avslutte) ")
#so lenge brukeren ikke avlsutter sa skal brettet oppdateres seg
while fortsett.lower() != "q":
test.oppdatering()
test.tegnBrett()
#spor brukeren om han vil fortsette etter hver oppdatering
fortsett = input("Vil du fortsette? (Skriv q for å avslutte) ")
def main():
#Oppretter brett1, som jeg gir klassen Spillebrett med brukerens input som parameterverdier.
brett1 = Spillebrett(int(input("Bredde: ")), int(input("Høyde: ")))
brett1.oppdatering()
print("Dette er den ", brett1._generasjon, "generasjonen.")
print(brett1.finnAntallLevende(), "levende celler.")
brukerinput = int(input("Enter for nesten generasjon, q for å avslutte: "))
#Oppdaterer til neste generasjon frem til brukeren klikker "q".
while brukerinput != 10000:
brett1.oppdatering()
print("Dette er den ", brett1._generasjon, "generasjonen.")
print(brett1.finnAntallLevende(), "levende celler.")
brukerinput += 1
def main():
storrelse = input("Skriv inn dimensjoner du ønsker(eks.30x40):\n>")
a, b = storrelse.split("x")
brett = Spillebrett(int(a), int(b))
brett.generer()
inp = ""
while inp != "q":
for e in range(100):
print()
brett.tegnBrett()
antallLevende = brett.finnAntallLevende()
genNr = brett.oppdatering()
#print("Dette er generasjon:", genNr)
#print("Antall levende celler:", antallLevende)
#print("""Trykk enter for neste generasjon.
#Trykk q for å avslutte.""")
#inp = input(">")
time.sleep(0.1)
def main():
print("\n" * 50)
rader = int(input("Antall rader (bortover): "))
kolonner = int(input("Antall kolonner (nedover): "))
hovedbrett = Spillebrett(kolonner, rader)
valg = ""
while valg != "q":
hovedbrett.tegnBrett()
hovedbrett.oppdatering()
valg = input("Enter for å fortsette, q for å avslutte: ")
def main():
x = int(input("Oppgi x dimensjonen? "))
y = int(input("Oppgi y dimensjonen? "))
c = Spillebrett(y, x)
#c.tegnBrett()
svar = input("Trykk q for avslutte programmet: ")
while svar != "q":
c.tegnBrett()
print()
print("Generasjon: ", c.oppdatering())
print("Antall levende celler: ", c.finnAntallLevende())
#time.sleep(0.5)
svar = input("Trykk q for avslutte programmet: ")
def main():
rader = int(input("Hvor mange rader vil du at spillebrettet skal ha? \n"))
kolonner = int(
input("Hvor mange kolonner vil du at spillebrettet skal ha? \n"))
#Sjekker at bruker har valgt verdier storre enn 0.
if (rader > 0) and (kolonner > 0):
brett1 = Spillebrett(rader, kolonner)
while True:
brett1.tegnBrett()
brett1.oppdatering()
print("Generasjon: {} - Antall levende celler: {}".format(
brett1.generasjon(), brett1.finnAntallLevende()))
svar = input(
"Press enter for aa fortsette eller q og enter for aa avslutte: "
)
if svar == "q":
break
else:
print(
"Programmet kjoerer bare med positive verdier over 0. \nProev programmet igjen med positive verdier fra 1 og oppover."
)
def main():
#her blir bruker bedt om hvor mange rader og kolonner hen ønsker
#dette lagres i hver sin variabel
antallrader = int(input("Hvor mange rader vil du ha?: "))
antallkolonner = int(input("Hvor mange kolonner vil du ha?: "))
#variablene blir brukt til å opprette et objekt av spillebrett-klassen
brett1 = Spillebrett(antallrader, antallkolonner)
#brettes printes ved hjelp av tegnBrett-metoden
brett1.tegnBrett()
svar = 0 #setter svar-variabelen for at while-løkken skal starte
while svar != "q":
svar = input("Tast Enter for å fortsette, q for å avslutte: ")
#brukeren får spørsmål om å fortsette eller avslutte
#for å komme til neste generasjon må brukeren taste enter
while svar == "":
#hvis bruker taster enter blir brettet oppdatert og skrevet ut
brett1.oppdatering()
brett1.tegnBrett()
#bruker blir spurt på nytt om å fortsette
svar = input("Tast Enter for å fortsette, q for å avslutte: ")
def main():
print('Game of Life - et zero player spill')
game_of_life = Spillebrett(int(input('Hoyde: ')), int(
input('Bredde: '
))) # oppretter et objekt for spillbrettet med gitt størrelse
game_of_life.oppdatering() # printer første generasjon av spillet
kommando = input(
'Trykk enter for aa fortsette. Skriv inn q og trykk enter for aa avslutte.'
)
while kommando != 'q': # så lenge man ikke "quitter" kan man skrive inn kommandoer
if kommando == '': # hvs kun enter blir satt inn, oppdateres spillbrettet
game_of_life.oppdatering()
# sett inn noe annet enn blankt eller 'q', og du får en ny mulighet for input
kommando = input(
'Du satt inn en ukjent kommando\nTrykk enter for aa fortsette. Skriv inn q og trykk enter for aa avslutte. '
)
def hovedProgram():
#brukeren oppgir maaler paa spillebrettet og bestemmer om hun vil opprette neste generasjon eller avslutte spillet
rader = int(input("Oppgi antall rader: "))
kolonner = int(input("Oppgi antall kolonner: "))
#oppretter spillebrett-objekt som generer rutenettet automatisk. Deretter skriver ut brettet til terminalen
spilleBrett1 = Spillebrett(rader, kolonner)
spilleBrett1.tegnBrett()
#info om foerste generasjon
print("Generasjon 0. Antall levende celler: " + str(len(spilleBrett1.finnAntallLevende())))
fortsette = input("Trykk ENTER for aa fortsette. Skriv inn 'q' og trykk ENTER for aa avslutte: ")
#denne listen brukes for aa sammenligne naboer fra den forrige og naavaarende generasjonen dersom antall levende celler er samme
#hvis de to listene er samme, betyr det at ingenting har endret seg paa brettet - livet har vunnet
sammenlignLevende = []
while fortsette == "" and len(spilleBrett1.finnAntallLevende()) != 0 and len(sammenlignLevende) == 0:
#loekke fortsetter saa lenge brukeren taster 'enter', antall levende celler er ikke 0 og listen med identiske levende celler er tom
lenvendeCeller0 = spilleBrett1.finnAntallLevende() #levende celler foer oppdateringen
generasjon = spilleBrett1.oppdatering() #spillebrettet oppdateres
antallLevende = len(spilleBrett1.finnAntallLevende()) #antall levende celler etter oppdateringen
spilleBrett1.tegnBrett() #spillebrettet tegnes
lenvendeCeller1 = spilleBrett1.finnAntallLevende() #levende celler etter oppdateringen
if antallLevende != 0 and lenvendeCeller0 == lenvendeCeller1:
#hvis levende celler er samme som i den forrige generasjonen:
sammenlignLevende.append(lenvendeCeller0) #legger levende celler til lista
sammenlignLevende.append(lenvendeCeller1)
elif antallLevende != 0 and lenvendeCeller0 != lenvendeCeller1:
#Det er noen levende celler som skiller seg fra de fra forrige generasjonen, spillet fortsetter
print("Generasjon: " + str(generasjon) + ". Antall levende celler: " + str(antallLevende) + ".")
fortsette = input("Trykk ENTER for aa fortsette. Skriv inn 'q' og trykk ENTER for aa avslutte: ")
#to mulige avslutninger naar spillet er over:
if len(sammenlignLevende) != 0:
#naar noen celler overlevde og ingenting har endret seg paa brettet:
print("VI OVERLEVDE! LIVET HAR VUNNET!")
else:
#naar alle cellene har doed:
print("GAME OVER!")
print()
print("Takk for spillet!")
#skriver ut statistikk:
print("Totalt antall generasjoner: " + str(generasjon) + ".")
def main():
"""Brukes for aa kjoere Conways game of life"""
print("Skriv inn dimensjoner")
rader = int(input("\nRad:"))
kolonner = int(input("\nKolonner:"))
brett = Spillebrett(rader, kolonner)
brett.tegnBrett()
print("Generasjon:", brett.generasjon(), " - Antall Levende:",
brett.finnAntallLevende())
UserInput = str(
input(
"Press enter for aa fortsette. Skriv inn q og trykk enter for aa avslutte:"
))
while UserInput != "q":
brett.oppdatering()
brett.tegnBrett()
print("Generasjon:", brett.generasjon(), " - Antall Levende:",
brett.finnAntallLevende())
UserInput = str(
input(
"Press enter for aa fortsette. Skriv inn q og trykk enter for aa avslutte:"
))
from spillebrett import Spillebrett
print("*** Velkommen til Game Of Life spillet! ***\n")
print("Skriv inn dimensjonene du vil ha på spillebrettet ditt.")
rader = int(input("Rader: "))
kolonner = int(input("Kolonner: "))
#tegner spillebrettet og skriver det ut
spillebrett = Spillebrett(rader, kolonner)
spillebrett.tegnBrett()
spillebrett.printInfo()
kommando = None
#fortsetter spillet helt til brukern ønsker å avslutte
while kommando != "q":
kommando = input(
"\n- Trykk f for å fortsette.\n- Trykk q for å avslutte\n")
#hvis brukeren ønsker å fortsette, oppdateres breddet og printes ut
if kommando == "f":
spillebrett.oppdatering()
spillebrett.tegnBrett()
spillebrett.printInfo()
elif kommando != "q" and kommando != "f":
print("\nDu skrev inn feil bokstav, mann!")
def Main():
a = input("Skriv inn antall rader og kolonner med et mellomrom i mellom. typ 10 10 \n").split()
r = Spillebrett(int(a[0]), int(a[1]))
r.tegnBrett()
inp = input("Trykk enter for å rulle, eller q for å avslutte, eller tall n for å rulle n ganger\n")
while(inp!="q"):
if inp == "":
r._oppdatering()
else:
for i in range(int(inp)):
r._oppdatering()
print("Generasjon: ", r.generasjon)
print("AntLevende: " + str(r.finnAntallLevende()))
r.tegnBrett()
inp = input("Trykk enter for å rulle, eller q for å avslutte, eller tall n for å rulle n ganger\n")
def main():
# Oppretter spillebrett objekt. Spør om antall rader og kolonner fra brukeren.
brett = Spillebrett(int(input("Oppgi rader: ")),
int(input("Oppgi kolonner: ")))
# Tegner brettet
brett.tegnBrett()
# Printer ut generasjonsnummeret og antall levende.
print("Generasjon:", brett._gen)
print("Antall levende", brett.finnAntallLevende())
# Henter input fra brukeren og går i en while løkke som går så lenge brukeren ikke taster "q" eller om brukeren tastet "a"
tast = input("Enter = neste Generasjon, q = avslutt, automatisk = a\n")
while tast != "q" or tast == "a":
if tast == "a":
# Dersom brukeren skriver "a" så spør vi om hvor mange generasjoner den skal gå gjennom
antallGens = int(input("Antall generasjoner: "))
# While løkke som går dersom tallet brukeren har oppgitt er større enn brettets generasjoner
while antallGens > brett._gen:
brett.oppdatering()
print("Generasjon:", brett._gen)
print("Antall levende", brett.finnAntallLevende())
# Når løkken er ferdig så spør vi om input igjen.
tast = input(
"Enter = neste Generasjon, q = avslutt, automatisk = a\n")
else:
# Dersom man skal bare trykke enter for å oppdatere så gjør vi dette.
brett.oppdatering()
print("Generasjon:", brett._gen)
print("Antall levende", brett.finnAntallLevende())
tast = input(
"Enter = neste Generasjon, q = avslutt, automatisk = a\n")
