def tarkista_lapaisy(peli_lapi):
ruutujen_maara = len(tila["kentta"]) * len(tila["kentta"][0])
miinojen_maara = 0
tuntemattomien_maara = 0
for rivi in tila["kentta"]:
for ruutu in rivi:
if ruutu == "x":
miinojen_maara += 1
for rivi in tila["kayttajan_nakyma"]:
for ruutu in rivi:
if ruutu == "f" or ruutu == " ":
tuntemattomien_maara += 1
pisteet = round((10 * (miinojen_maara / ruutujen_maara) * miinojen_maara),
1)
aika = str(int(tila["ajastin"] / 60)) + ":" + str(
tila["ajastin"] % 60).zfill(2)
if peli_lapi == 0:
haravasto.lopeta()
print(
"\nOuch, hävisit pelin {} klikkauksen jälkeen ajassa {} ja sait {} pistettä :("
.format(tulos["klikkaukset"] + 1, aika, 0))
tulos["lapaisy"] = False
tulos["aika"] = aika
tulos["pisteet"] = 0
elif tuntemattomien_maara == miinojen_maara:
haravasto.lopeta()
print(
"\nHienoa, läpäisit pelin {} klikkauksella ajassa {} ja sait {} pistettä :)"
.format(tulos["klikkaukset"] + 1, aika, pisteet))
tulos["lapaisy"] = True
tulos["aika"] = aika
tulos["pisteet"] = pisteet
def paivita_peli(kulunut_aika):
"""
Päivitää pelin tilannetta. Tarkastelee voito ja häviö ehtoja ja toteuttaa
tarvittavat toimet niiden täyttyessä. Päivittää kelloa.
"""
if tila["jaljella"] == 0:
tarkista_voitto()
if tila["havio"] or tila["voitto"]:
if tila["ajasta"]:
tila["ajasta"] = False
if piirto["toistot"] > 0:
animaatio = [tila["kentta"], tila["naytto"]]
piirto["ruudukko"] = animaatio[int(piirto["kuva"] % 2)]
piirto["kuva"] += piirto["nopeus"]
piirto["toistot"] -= 1
else:
tila["loppu"] = True
if tila["loppu"]:
haravasto.lopeta()
if tila["ajasta"]:
tila["nyt"] = datetime.datetime.now()
try:
aika, millit = str(tila["nyt"] - tila["aloitus"]).split(".")
except ValueError:
aika = str(tila["nyt"] - tila["aloitus"])
tila["aika"] = aika
def peli_paattyi():
"""
Näyttää pelin tiedot, kysyy nimimerkkiä ja tallentaa ne tiedostoon.
Palaa päävalikkoon kun nappia on painettu.
"""
haravasto.lopeta()
if tila["voitto"]:
viesti = "Voitit"
else:
viesti = "Hävisit"
pvm = datetime.datetime.now()
aloitusaika = tila["aloitusaika"]
aika_s = (pvm - aloitusaika).total_seconds()
aika = ("{}min {:.1f}s".format(int(aika_s / 60), aika_s % 60))
aikaleima = aloitusaika.strftime("%d.%m.%Y klo:%H.%M")
tila["aloitusaika"] = aikaleima
tila["peliaika"] = aika
tallennus_ikkuna = ikkunasto.luo_ikkuna("{} pelin!".format(viesti))
ylakehys = ikkunasto.luo_kehys(tallennus_ikkuna, ikkunasto.YLA)
alakehys = ikkunasto.luo_kehys(tallennus_ikkuna, ikkunasto.YLA)
nimiohje = ikkunasto.luo_tekstirivi(ylakehys, "Nimimerkki:")
global nimikentta
nimikentta = ikkunasto.luo_tekstikentta(ylakehys)
tallenna_nappi = ikkunasto.luo_nappi(ylakehys, "Tallenna peli",
tallenna_tilastot)
ohita_nappi = ikkunasto.luo_nappi(ylakehys, "Ohita",
takaisin_nappi_kasittelija)
global tallennus_ikkuna_laatikko
tallennus_ikkuna_laatikko = ikkunasto.luo_tekstilaatikko(alakehys, 40, 30)
ikkunasto.kirjoita_tekstilaatikkoon(
tallennus_ikkuna_laatikko,
"{} pelin.\nAika: {}\nVuorot: {}\nKentän koko: {}x{}\nMiinoja: {}\nPäivämäärä: {}."
.format(viesti, aika, tila["vuorot"], len(tila["kentta"][0]),
len(tila["kentta"]), tila["miinat"], aikaleima))
ikkunasto.kaynnista()
def tarkista_lopetus(nakyva_miinakentta, miinaosuma=False):
"""
Tarkistaa täyttyykö pelin lopetusehdot. Jos täyttyy, sulkee peli-ikkunan,
tallentaa pelin tiedot ja lopuksi tyhjentää vanhan pelin tiedot.
"""
avatut_ruudut = 0
for rivi in nakyva_miinakentta:
avatut_ruudut += rivi.count("0")
avatut_ruudut += rivi.count("1")
avatut_ruudut += rivi.count("2")
avatut_ruudut += rivi.count("3")
avatut_ruudut += rivi.count("4")
avatut_ruudut += rivi.count("5")
avatut_ruudut += rivi.count("6")
avatut_ruudut += rivi.count("7")
avatut_ruudut += rivi.count("8")
if miinaosuma:
tilastokirja["lopputulos"] = "Häviö"
tilastokirja["lopetusaika"] = time.time()
lisaa_tilasto()
tallenna_tilastot("miinaharavatilastot.txt")
nayta_lopputulos()
nollaa_tiedot()
haravasto.lopeta()
elif avatut_ruudut == int(len(tila["jaljella"])):
nakyva_tila["nakyva_kentta"] = tila["kentta"]
piirra_kentta()
tilastokirja["lopputulos"] = "Voitto"
tilastokirja["lopetusaika"] = time.time()
lisaa_tilasto()
tallenna_tilastot("miinaharavatilastot.txt")
nayta_lopputulos(True)
nollaa_tiedot()
haravasto.lopeta()
def kasittele_hiiri(x, y, painike, muokkaus):
"""Tätä funktiota kutsutaan kun käyttäjä klikkaa sovellusikkunaa hiirellä.
Tulostaa hiiren sijainnin sekä painetun napin terminaaliin."""
loppu = False
if painike == harava.HIIRI_VASEN:
tila["valinnat"] += 1
if tila["kentta"][int(y / 40)][int(x / 40)] == "x":
tila["naytto"][int(y / 40)][int(x / 40)] = "x"
loppu = True
else:
tulvataytto(tila["kentta"], int(x / 40), int(y / 40))
elif painike == harava.HIIRI_OIKEA:
if tila["naytto"][int(y / 40)][int(x / 40)] == "f":
tila["naytto"][int(y / 40)][int(x / 40)] = " "
elif tila["naytto"][int(y / 40)][int(x / 40)] == " ":
tila["naytto"][int(y / 40)][int(x / 40)] = "f"
elif painike == harava.HIIRI_KESKI:
pass
piirra_kentta()
if pelin_voitto(tila["naytto"]):
harava.lopeta()
tila["aika"] = (time.time() - tila["aika"]) / 60
tila["tulos"] = "Voitto"
tallenna()
print("\nVoitit Pelin! Valinnat: {}, Pisteet: {}, Aika: {:.2f}min\n".
format(tila["valinnat"], tila["pisteet"], tila["aika"]))
if loppu:
harava.lopeta()
tila["aika"] = (time.time() - tila["aika"]) / 60
tila["tulos"] = "Häviö"
tallenna()
print("\nHävisit Pelin! Valinnat: {}, Pisteet: {}, Aika: {:.2f}min\n".
format(tila["valinnat"], tila["pisteet"], tila["aika"]))
def kasittele_hiiri(hiiriX, hiiriY, hiirenpainike, painetut_muokkausnappaimet):
"""Tunnistaa klikatun hiirenpainikkeen ja koordinaatin. Jos tietokentän kyseisessä ruudussa on x niin pelaaja häviää pelin
ja tilastot tallennetaan A sanakirjaan. Jos 0, niin kutsutaan tulvatäyttöä. Muissa tapauksissa tietokenta ruutu
päivitetään samaan kohtaa pelikenttään. Jokaisella hiiren vasemmalla painalluksella tarkistetaan myös, onko lopputulos valmis.
Jos on niin ikkuna suljetaan ja peli palaa valikkoon"""
x = int(hiiriX // 40)
y = int(hiiriY // 40)
painallus = int(hiirenpainike)
if painallus == haravasto.HIIRI_VASEN:
if tila["lopputulos"] == "valmis":
tila["lopputulos"] = " "
haravasto.lopeta()
valikko()
elif tila["tietokentta"][y][x] == 0:
A["siirrot"] = A["siirrot"] + 1
tulvataytto(tila["tietokentta"], x, y)
elif tila["tietokentta"][y][x] == 'x':
A["siirrot"] = A["siirrot"] + 1
A["lopputulos"] = "tappio"
A["aika_B"] = time.time()
A["minuutit"] = int(round((A["aika_B"] - A["aika_A"] - 30) / 60, 0))
A["sekuntit"] = int(round(A["aika_B"] - A["aika_A"] - (A["minuutit"] * 60), 0))
tilastotallennus("miinaharavatilastot.txt")
print("Hävisit")
tila["pelikentta"] = tila["tietokentta"]
tila["lopputulos"] = "valmis"
else:
A["siirrot"] = A["siirrot"] + 1
tila["pelikentta"][y][x] = tila["tietokentta"][y][x]
elif painallus == haravasto.HIIRI_OIKEA:
tila["pelikentta"][y][x] = 'f'
tarkastavoitto()
def kasittele_hiiri_lopetus(x, y, painike, muokkausnapit):
"Tämä funktio sulkee ikkunan pelin jälkeen vasemmalla hiiren näppäimellä"
aika_loppu = time.time()
statistiikka["kesto"] = time.strftime("%M min %S s", time.gmtime(aika_loppu - aika_alku))
if haravasto.HIIRI_VASEN:
tallenna_statistiikka(statistiikka)
haravasto.lopeta()
def kasittele_hiiri_lopussa(x, y, nappi, muokkausnappain):
"""
Tätä funktiota kutsutaan kun käyttäjä klikkaa sovellusikkunaa hiirellä pelin lopussa.
Sulkee peli_ikkunan klikkauksesta. Peli-ikkuna suljetaan vasta kun tulos_ikkuna on suljettu ensin.
"""
if tila["tulos_ikkuna"] == None:
haravasto.lopeta()
else:
print("Sulje ensin tulosikkuna.")
def timeCounter(t):
"""
Counter function to keep on track of time for the game, and timeout in case game ends.
"""
tila["time"] = tila["time"] + t
if tila["end"] == 1:
tila["timeOut"] = tila["timeOut"] + t
if tila["timeOut"] > 2:
haravasto.lopeta()
def voitto():
h.lopeta()
tulokset["lopetus"] = t.time()
tulokset["min"], tulokset["sec"] = divmod(
(tulokset["lopetus"] - tulokset["aloitus"]), 60)
print("Voitit pelin!")
print("")
tulokset["nimi"] = input("Annahan nimi nii laitetaan tulokset talteen:")
tallenna_kokoelma("tulokset.txt")
print("")
def voitto():
#tarkistaa onko peli voitettu
#https://www.stechies.com/compare-lists-python-using-set-cmp-function/
if set(kentta["miinojen_koordinaatit"]) == set(kentta["liput"]):
h.lopeta()
print("Voitit pelin! :)")
aika_lopetus()
print("Pelisi kesti {} minuuttia".format(statistiikka["kesto"]))
statistiikka["tulos"] = "voitto"
tallenna_tulokset("tulokset.txt")
def havio():
h.lopeta()
tulokset["lopetus"] = t.time()
tulokset["min"], tulokset["sec"] = divmod(
(tulokset["lopetus"] - tulokset["aloitus"]), 60)
print("Siinä oli miina, hävisit pelin")
print("")
tulokset["tulos"] = "Hävio"
tulokset["nimi"] = input("Annahan nimi nii laitetaan tulokset talteen:")
tallenna_kokoelma("tulokset.txt")
print("")
def handleClick(x, y, button, modKey):
"""
Helper function to handle the clicks. If player clicks with mousebutton 1 on the board
game responds accordingly.
"""
x_coord = int(x / SQSIZE)
y_coord = int(y / SQSIZE)
if button == 1:
checkSquare(x_coord, y_coord)
draw_board()
if button == 4:
haravasto.lopeta()
def havio():
"""
Jos miinoitettu ruutu avataan, kutsutaan havio-funktiota,
joka lopettaa pelin, merkitsee lopputulokseksi häviön,
kutsuu tilastot-funktiota ja ilmoittaa käyttäjälle häviöstä.
"""
arvot["lopputulos"] = "HÄVIÖ"
tilastot()
print("HÄVISIT PELIN!!")
haravasto.lopeta()
arvot["aika"] = 0
arvot["Siirrot"] = 0
def voitto():
"""
Vertaa miinojen lukumäärää ja avaamattomat-funktion
palauttamaa lukumäärää avaamattomista ja liputetuista ruuduista. Jos lukumäärä on sama, peli on voitettu,
koska silloin kaikissa avaamattomissa/liputetuissa ruuduissa on miina. Päivittää tilastoja.
"""
if avaamattomat() == arvot["miinat"]:
arvot["lopputulos"] = "VOITTO"
tilastot()
print("VOITIT PELIN!!")
haravasto.lopeta()
arvot["aika"] = 0
arvot["Siirrot"] = 0
def check_win(self):
if self.mapcheck() == 0:
self.statistics["result"] = "Win"
self.statistics["gamelength"] = time.time() - self.starttime
add_statistics()
print(
"Date: {date} | Game length: {length:.0g} seconds | Moves: {moves} | Result: {result} | Game dimensions: {width}x{height} | Mines: {mines}\n"
.format(date=time.strftime("%d-%m-%Y %H:%M", time.localtime()),
length=self.statistics["gamelength"],
moves=self.statistics["moves"],
result=self.statistics["result"],
width=self.width,
height=self.height,
mines=self.mines))
ha.lopeta()
def loss(self):
self.drawMap = self.gameMap
self.statistics["gamelength"] = time.time() - self.starttime
self.statistics['result'] = "Loss"
add_statistics()
print(
"Date: {date} | Game length: {length:.0g} seconds | Moves: {moves} | Result: {result} | Game dimensions: {width}x{height} | Mines: {mines}\n"
.format(date=time.strftime("%d-%m-%Y %H:%M", time.localtime()),
length=self.statistics["gamelength"],
moves=self.statistics["moves"],
result=self.statistics["result"],
width=self.width,
height=self.height,
mines=self.mines))
ha.lopeta()
def game_over():
"""
Jos pelaaja on hävinnyt suljetaan peli-ikkuna ja palataan valikkoon, jos taas voitetaan
tulos tallennetaan, peli-ikkuna suljetaan ja palataan valikkoon
"""
if GAME["gameover"]:
har.lopeta()
if GAME["win"]:
grid = "{}x{}".format(len(GAME["board"][0]), len(GAME["board"]))
highscore = "Päivämäärä: {} \nAika: {} \nSiirrot: {} \nRuudukko: {} \nmiinat: {}\n".format(
asctime(), GAME["time"], GAME["moves"], grid, GAME["mines"])
with open("highscores.txt", 'a') as tied:
tied.write(highscore)
tied.write('****************\n')
har.lopeta()
def valikko():
"""Valikko käynnistää main() funktion kun pelaaja valitsee uuden pelin."""
try:
operaatio = input("Valitse toiminto (1 = Uusi peli, 2 = Tilastot, 3 = Lopeta):")
except ValueError:
print("Anna luku 1-3")
else:
if operaatio == "1":
main()
elif operaatio == "2":
tilastolukija("miinaharavatilastot.txt")
valikko()
elif operaatio == "3":
haravasto.lopeta()
else:
valikko()
def kasittele_hiiri(x, y, nappi, muokkausnapit):
"""
Tätä funktiota kutsutaan kun käyttäjä klikkaa sovellusikkunaa hiirellä.
Antaa hiiren sijainnin(x, y koordinaateilla) sekä painetun napin(hiiren vasen-, oikea tai keskinäppäin).
"""
x, s = divmod(x, 40)
y, t = divmod(y, 40)
#Pelin kulku:
if tila["nakyva"][y][x] != tila["piilossa"][y][
x] and nappi == hv.HIIRI_VASEN and tila["nakyva"][y][
x] != "0": #Ruudun aukaisu(ilman tulvatäyttöä)
tila["nakyva"][y][x] = tila["piilossa"][y][x]
ti.aika["vuorot"] += 1
if nappi == hv.HIIRI_OIKEA: #Merkkaus
if tila["nakyva"][y][x] == " ":
tila["nakyva"][y][x] = "f"
elif tila["nakyva"][y][x] == "f":
tila["nakyva"][y][x] = " "
if tila["piilossa"][y][
x] == "x" and nappi == hv.HIIRI_VASEN: #Miinaan osuminen(Häviö)
tila["piilossa"] == tila["nakyva"]
hv.lopeta()
print("____________________" + "\n" + "\n" + Fore.RED +
"ASTUIT MIINAAN! PELI OHI!" + "\n")
print(Style.RESET_ALL + "____________________")
ti.aika["lopetus"] = time.time()
ti.tallenna("Häviö", av.alkutiedot["miinat"], av.alkutiedot["leveys"],
av.alkutiedot["korkeus"], ti.aika["vuorot"])
if tila["piilossa"][y][x] == "0" and nappi == hv.HIIRI_VASEN: #Tulvatäyttö
tulvataytto(tila["nakyva"], x, y, tila["piilossa"])
tila["vapaat"] = 0 #Voitto tarkistus
for j, ruudut in enumerate(tila["nakyva"]):
for i, ruudut in enumerate(ruudut):
if tila["nakyva"][j][i] == tila["piilossa"][j][i]:
pass
else:
tila["vapaat"] += 1
if tila["vapaat"] <= av.alkutiedot[
"miinat"]: #Voitto(Avaamattomien ruutujen määrä = miinojen määrä
hv.lopeta()
print("____________________" + "\n" + "\n" + Fore.GREEN +
"KAIKKI MIINAT HARAVOITU! ONNEKSI OLKOON!" + "\n")
print(Style.RESET_ALL + "____________________")
ti.aika["lopetus"] = time.time()
ti.tallenna("Voitto", av.alkutiedot["miinat"], av.alkutiedot["leveys"],
av.alkutiedot["korkeus"], ti.aika["vuorot"])
def kasittele_hiiri(x, y, nappi, muokkausnapit):
"""
Tätä funktiota kutsutaan kun käyttäjä klikkaa sovellusikkunaa hiirellä.
Tulostaa hiiren sijainnin sekä painetun napin terminaaliin. kutsuu käyttäjän painalluksesta riippuen joko
hiiri_vasen tai hiiri_oikea funktiota ja laskee pelin lopetus-ehdon.
"""
# Tarkastetaan onko tilasanakirjan tulos arvo muuttunut, jos on, kysytään haluaako käyttäjä aloittaa uuden pelin.
if tila['tulos'] != None:
tila['tulos'] = None
tila['vuorot'] = 0
haravasto.lopeta()
while True:
valinta = input('Uusi peli? K/E.').lower()
if valinta == 'k':
aloita_peli()
elif valinta == 'e':
exit()
else:
print('laiton valinta')
# Muuntaa hiiren sijainnin kentälle sopiviksi koordinaateiksi
x = int(x / 40)
y = int(y / 40)
if Hiiri[nappi] == 'vasen':
hiiri_vasen(x, y)
elif Hiiri[nappi] == 'oikea':
hiiri_oikea(x, y)
# Käydään läpi for loopilla tyhjat_ruudut lista, joka sisältää piiloitetun kentän tyhjät ruudut.
# silmukkamuuttuja tyhja sisältää koordinaattiparin joka sijoitetaan näkyvään kenttään ja tarkastellaan
# onko näkyvässä kentässä sillä kohtaa jotain muuta kuin avaamaton ruutu. Jos on, tarkastellaan vielä onko samassa
# kohtaa jotain muuta kuin lippu, jos on, lisätään count muuttujan arvoa yhdellä. Näin saadaan tietoon ovatko
# näkyvän kentän avaamattomat tai liputetut ruudut samoissa koordinaateissa kuin piiloitetun kentän miinat
count = 0
for tyhja in aseta_numerot():
if tila['nakyvakentta'][tyhja[0]][tyhja[1]] != ' ':
if tila['nakyvakentta'][tyhja[0]][tyhja[1]] != 'f':
count += 1
# Jos count muuttuja on yhtäsuuri kuin kentän dimensiot vähennettynä miinojen määrä (eli pelaaja voittaa pelin jos
# näkyvällä kentällä on jäljellä avaamattomia tai liputettuja ruutuja yhtä monta kuin piiloitetulla kentällä on
# miinoja ja ne sijaitsevat samoilla koordinaateilla) pelaaja voittaa pelin.
if count == (len(tila['nakyvakentta']) * len(tila['nakyvakentta'][0]) -
tila['miina']):
print('Voitit!')
print('Klikkaa peli-ikkunaa jatkaaksesi')
tila['tulos'] = 'Voitto'
tallenna_tilastot('tilastot.csv')
def havio():
rajahdys = """
_.-^^---....,,--
_-- --_
< >)
| |
\._ _./
```--. . , ; .--'''
| | |
.-=|| | |=-.
`-=#$%&%$#=-'
| ; :|
_____.,-#%&$@%#&#~,._____\nOsuit miinaan. Hävisit pelin."""
print(rajahdys)
time.sleep(3)
haravasto.lopeta()
tallenna("miinaharava_tallennukset.txt", "L")
os.system("cls")
def pelin_lopetus():
tila["AIKA_LOPETUS"] = timeit.default_timer()
haravasto.lopeta()
if tila["VOITTO"] == True:
print(" ")
print("Voitto kotiin!")
print(" ")
elif tila["HAVIO"] == True:
print(" ")
print("Hävisit pelin!")
print("Parempi onni ensikerralla.")
print(" ")
print("Tehtyjä siirtoja:", tila["SIIRROT"])
laskettu_aika = round(tila["AIKA_LOPETUS"] - tila["AIKA_ALKU"], 1)
print("Aika: {} sekuntia".format(laskettu_aika))
def tappio():
tila["pelin_paattyminen"] = True
pelin_kesto = ((time.time() - tila["aloitus_aika"]) / 60)
paivays = time.strftime("%d %b %Y %H:%M:%S")
haravasto.lopeta()
print("Onneksi olkoon! Löysit miinan... Hävisit pelin :/")
print("Teit {} siirtoa ja peli kesti {:.2f} minuuttia".format(
tila["siirrot"], pelin_kesto))
#print("Päiväys: {}".format(paivays))
#print("Kentän koko: {} x {}".format(tila["leveys"], tila["korkeus"]))
#print("Miinojen lukumäärä: {}".format(tila["miinat"]))
#webbrowser.open("https://youtu.be/mb-XCaA2HZs?t=37")
tulokset = "\nHävitty peli:\n"
tulokset += "Päiväys: {}\nPeliaika: {:.2f} minuuttia\nMiinojen lukumäärä: {}\nKentän koko: {} x {} ruutua\nSiirrot: {}\n".format(
paivays, pelin_kesto, tila["miinat"], tila["leveys"], tila["korkeus"],
tila["siirrot"])
vie_tiedostoon(tulokset)
print("Haluatko kokeilla uudestaan?")
def voittaminen():
tila["pelin_paattyminen"] = True
pelin_kesto = ((time.time() - tila["aloitus_aika"]) / 60)
paivays = time.strftime("%d %b %Y %H:%M:%S")
haravasto.lopeta()
print("Hurraa! Onnistuit välttämään kaikki miinat! Voitit pelin! :3")
print("Teit {} siirtoa ja peli kesti {:.2f} minuuttia".format(
tila["siirrot"], pelin_kesto))
#print("Päiväys: {}".format(paivays))
#print("Kentän koko: {} x {}".format(tila["leveys"], tila["korkeus"]))
#print("Miinojen lukumäärä: {}".format(tila["miinat"]))
#webbrowser.open("https://www.youtube.com/watch?v=DhlPAj38rHc")
tulokset = "\nVoitettu peli:\n"
tulokset += "Päiväys: {}\nPeliaika: {:.2f} minuuttia\nMiinojen lukumäärä: {}\nKentän koko: {} x {} ruutua\nSiirrot: {}\n".format(
paivays, pelin_kesto, tila["miinat"], tila["leveys"], tila["korkeus"],
tila["siirrot"])
vie_tiedostoon(tulokset)
print("Haluatko kokeilla uudestaan?")
def tappio():
aika = datetime.datetime.now()
leveys = str(ASETUKSET["leveys"])
korkeus = str(ASETUKSET["korkeus"])
miinat = str(ASETUKSET["miinoja"])
lippuja = str(ASETUKSET["lippuja"])
klikkaukset = str(ASETUKSET["klikkaukset"])
ruudut = str(ASETUKSET["leveys"] * ASETUKSET["korkeus"])
tyhjia = str(lasketyhjat(tila["tulostettu_kentta"]))
paivamaara = aika.strftime("%Y-%m-%d %H:%M")
kesto_s = str(int(time.time() - ASETUKSET["aloitus_aika"]))
kesto_m = str(round(((time.time() - ASETUKSET["aloitus_aika"]) / 60), 2))
#Tulostetaan pelin tiedot
print('_______________________________\n',
'Osuit miinaan ja hävisit pelin!!',
'_______________________________',
'Pelin tiedot',
'Päivämäärä: ' + paivamaara,
'Kentän koko: leveys ' + leveys + ', korkeus ' + korkeus,
'Miinojen määrä: ' + miinat,
'Pelin kesto oli ' + kesto_s + ' sekuntia tai ' + kesto_m +
' minuuttia',
'Lippuja käytetty: ' + lippuja,
'Pelatut vuorot: ' + klikkaukset,
'Ruutuja jäljellä: ' + tyhjia + '/' + ruudut,
sep="\n")
#Tallennetaan pelin tiedot
tiedosto = open("miinaharavan_tulokset.txt", "a")
tiedosto.write('Tappio! ' + paivamaara + '\n'
'Kentän leveys ' + leveys + ', korkeus ' + korkeus + '\n'
'Miinojen määrä: ' + miinat + '\n'
'Pelin kesto oli ' + kesto_s + ' sekuntia tai ' + kesto_m +
' minuuttia\n'
'Lippuja käytetty: ' + lippuja + '\n'
'Ruutuja jäljellä: ' + tyhjia + '/' + ruudut + '\n'
'Pelatut vuorot: ' + klikkaukset + '\n\n')
#soittaa räjähdyksen
winsound.PlaySound("pommi.wav", winsound.SND_ASYNC)
haravasto.lopeta()
#palaa päävalikkoon
valikko()
def voitto():
aika = datetime.datetime.now()
leveys = str(ASETUKSET["leveys"])
korkeus = str(ASETUKSET["korkeus"])
miinat = str(ASETUKSET["miinoja"])
ruudut = str(ASETUKSET["leveys"] * ASETUKSET["korkeus"])
lippuja = str(ASETUKSET["lippuja"])
klikkaukset = str(ASETUKSET["klikkaukset"])
paivamaara = aika.strftime("%Y-%m-%d %H:%M")
kesto_s = str(int(time.time() - ASETUKSET["aloitus_aika"]))
kesto_m = str(round(((time.time() - ASETUKSET["aloitus_aika"]) / 60), 2))
#Tulostetaan pelin tiedot
print("_____________________________________________________\n",
'Selvitit miinakentän ja voitit pelin, onneksi olkoon!',
'_____________________________________________________',
'Pelin tiedot',
'Päivämäärä: ' + paivamaara,
'Kentän koko: leveys ' + leveys + ', korkeus ' + korkeus,
'Miinojen määrä: ' + miinat,
'Ruutuja: ' + ruudut,
'Pelin kesto oli ' + kesto_s + ' sekuntia tai ' + kesto_m +
' minuuttia',
'Lippuja käytetty: ' + lippuja,
'Pelatut vuorot: ' + klikkaukset,
sep="\n")
#Tallennetaan pelin tiedot
tiedosto = open("miinaharavan_tulokset.txt", "a")
tiedosto.write('Voitto! ' + paivamaara + '\n'
'Kentän leveys ' + leveys + ', korkeus ' + korkeus + '\n'
'Miinojen määrä: ' + miinat + '\n'
'Pelin kesto oli ' + kesto_s + ' sekuntia tai ' + kesto_m +
' minuuttia\n'
'Lippuja käytetty: ' + lippuja + '\n'
'Pelatut vuorot: ' + klikkaukset + '\n\n')
#soittaa voitonfanfaarin
winsound.PlaySound("voitto.wav", winsound.SND_ASYNC)
paljastamiinat()
tila["pelattu"] = True
haravasto.lopeta()
#palaa päävalikkoon
valikko()
def kasittele_hiiri(x, y, nappi, muokkausnapit):
"""Tätä funktiota kutsutaan kun käyttäjä klikkaa sovellusikkunaa hiirellä."""
x = int(x / 40)
y = int(y / 40)
if tiedot["lopputulos"] != "Keskeytetty":
tallenna()
if nappi == ha.HIIRI_VASEN or ha.HIIRI_OIKEA:
ha.lopeta()
uusipeli()
elif nappi == ha.HIIRI_VASEN:
tiedot["vuorot"] += 1
if tiedot["ekaklikkaus"] == True:
tila["jaljella"].remove((x, y))
miinoita()
tayta_ruudut()
tulvataytto(x, y)
piirra_kentta()
tiedot["ekaklikkaus"] = False
voitto()
elif tiedot["pelaaja"] == "miinamestari1337":
if tila["pohjakentta"][y][x] == "x":
tila["kentta"][y][x] = "f"
else:
tulvataytto(x, y)
piirra_kentta()
voitto()
else:
if tila["pohjakentta"][y][x] == "x":
tila["kentta"][y][x] = "r"
tila["pohjakentta"][y][x] = "r"
havio()
else:
tulvataytto(x, y)
piirra_kentta()
voitto()
elif nappi == ha.HIIRI_OIKEA:
tiedot["vuorot"] += 1
if tila["kentta"][y][x] == " ":
tila["kentta"][y][x] = "f"
elif tila["kentta"][y][x] == "f":
tila["kentta"][y][x] = " "
else:
pass
def kasittele_hiiri(x, y, painike, pmn):
"""
Tätä funktiota kutsutaan kun käyttäjä klikkaa sovellusikkunaa hiirellä.
"""
if painike == haravasto.HIIRI_VASEN and pelinTiedot["loppu"] == False:
xk = int(x / 40)
yk = int(y / 40)
if koordinaatin_sijainti_kentalla(xk, yk, len(kentta[1]), len(kentta)):
pelinTiedot["klikkaukset"] = pelinTiedot["klikkaukset"] + 1
klikkausVASEN(xk, yk)
if painike == haravasto.HIIRI_OIKEA and pelinTiedot["loppu"] == False:
xk = int(x / 40)
yk = int(y / 40)
if koordinaatin_sijainti_kentalla(xk, yk, len(kentta[1]), len(kentta)):
klikkausOIKEA(xk, yk)
if painike == haravasto.HIIRI_KESKI:
if pelinTiedot["loppu"] == True:
tallenna_tulos()
haravasto.lopeta()
def voitto():
victory_flag = """
__
<__>
||______________________________
||###### #####################|
||###### #####################|
||###### #####################|
||###### #####################|
|| |
||###### #####################|
||###### #####################|
||###### #####################|
||###### #####################|
||~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
||
|| Vältit kaikki miinat. Voitit pelin.
||
||
"""
voitit = True
for x in range(len(sotakentta[0])):
for y in range(len(sotakentta)):
if miinakentta[y][x] == "x":
pass
else:
if miinakentta[y][x] == sotakentta[y][x]:
pass
else:
voitit = False
break
if voitit == False:
break
if voitit == True:
print(victory_flag)
time.sleep(3)
haravasto.lopeta()
tallenna("miinaharava_tallennukset.txt", "W")
os.system("cls")
