def main():
"""
Luodaan aloitusvalikko, josta voi valita uuden pelin, lopettamisen ja
tilastojen katsomisen. Uuteen peliin voi valita kentän koon
sekä miinojen määrän
"""
alku_ikkuna = ikkunasto.luo_ikkuna("Miinaharava")
ylakehys = ikkunasto.luo_kehys(alku_ikkuna, ikkunasto.YLA)
alakehys = ikkunasto.luo_kehys(alku_ikkuna, ikkunasto.YLA)
syotekehys = ikkunasto.luo_kehys(ylakehys, ikkunasto.VASEN)
nappikehys1 = ikkunasto.luo_kehys(ylakehys, ikkunasto.VASEN)
nappikehys2 = ikkunasto.luo_kehys(ylakehys, ikkunasto.VASEN)
uusipelinappi = ikkunasto.luo_nappi(syotekehys, "Uusi peli", uusipeli)
tilastonappi = ikkunasto.luo_nappi(nappikehys1, "Katso tilastoja",
tilastot)
lopetusnappi = ikkunasto.luo_nappi(nappikehys2, "Lopeta",
lopeta_nappi_kasittelija)
leveysohje = ikkunasto.luo_tekstirivi(syotekehys, "Kentän leveys:")
global leveyskentta
leveyskentta = ikkunasto.luo_tekstikentta(syotekehys)
korkeusohje = ikkunasto.luo_tekstirivi(syotekehys, "Kentän korkeus:")
global korkeuskentta
korkeuskentta = ikkunasto.luo_tekstikentta(syotekehys)
miinalkmohje = ikkunasto.luo_tekstirivi(syotekehys, "Miinojen lukumäärä:")
global miinalkmkentta
miinalkmkentta = ikkunasto.luo_tekstikentta(syotekehys)
global tekstilaatikko
tekstilaatikko = ikkunasto.luo_tekstilaatikko(alakehys, 44, 20)
ikkunasto.kaynnista()
def lisaaKomponenttiKL():
"""
Komponentin lisäys listaan.
"""
ikn.piilota_ali_ikkuna(KLIITTYMÄ["wizAk"])
lisaaKompAkkuna = ikn.luo_ali_ikkuna("Lisää komponentti")
ikn.luo_tekstirivi(
lisaaKompAkkuna,
"Lisää komponentti (v)astus = (r), (k)ela = (l) tai (c)ondensaattori.")
KLIITTYMÄ["syote"[0]] = ikn.luo_tekstikentta(lisaaKompAkkuna)
ikn.luo_vaakaerotin(lisaaKompAkkuna)
ikn.luo_tekstirivi(lisaaKompAkkuna,
"Anna komponentin arvo ilman yksikköä:")
KLIITTYMÄ["syote"[1]] = ikn.luo_tekstikentta(lisaaKompAkkuna)
ikn.luo_vaakaerotin(lisaaKompAkkuna)
ikn.luo_tekstirivi(lisaaKompAkkuna, "Anna lisättävän haaran ID (numero):")
KLIITTYMÄ["syote"[2]] = ikn.luo_tekstikentta(lisaaKompAkkuna)
ikn.luo_nappi(lisaaKompAkkuna, "Lisää komponentti", lisaaKomponentti)
ikn.luo_vaakaerotin(lisaaKompAkkuna)
ikn.luo_tekstirivi(lisaaKompAkkuna, "Komponentit:")
KLIITTYMÄ["komplistaus"] = ikn.luo_tekstilaatikko(lisaaKompAkkuna,
leveys=40)
if KLIITTYMÄ["komponentit"] != [[]]:
komponenttilistaus()
def save():
'''Funktio kysyy pelaajan nimen ja tallentaa tämän ajan
että liputetut miinat'''
elementit['vikaik'] = iku.luo_ali_ikkuna('')
iku.luo_tekstirivi(elementit['vikaik'], 'Kirjoita nimesi')
elementit['vika'] = iku.luo_tekstikentta(elementit['vikaik'])
iku.luo_nappi(elementit['vikaik'], 'Syötä', nimi)
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 luo_valikko():
"""
Luo valikkoikkunan.
"""
ikkuna = ikkunasto.luo_ikkuna("Miinaharava")
nappikehys = ikkunasto.luo_kehys(ikkuna, ikkunasto.YLA)
uusipelinappi = ikkunasto.luo_nappi(nappikehys, "Uusi peli", pyyda_syotteet)
tilastonappi = ikkunasto.luo_nappi(nappikehys, "Tilastot", lue_tilastot)
lopetusnappi = ikkunasto.luo_nappi(nappikehys, "Lopeta", ikkunasto.lopeta)
ikkunasto.kaynnista()
def nayta_lopputulos(voitto=False):
"""
Näyttää pelaajalle pelatun pelin tiedot pelin päätyttyä.
"""
loppuikkuna["ikkuna"] = ikkunasto.luo_ali_ikkuna("Lopputulos")
if voitto:
ikkunasto.luo_tekstirivi(loppuikkuna["ikkuna"], "Voitit pelin!")
else:
ikkunasto.luo_tekstirivi(loppuikkuna["ikkuna"], "Osuit miinaan. Hävisit pelin.")
ikkunasto.luo_tekstirivi(loppuikkuna["ikkuna"], "Kesto: {:.1f} minuuttia, {} vuoroa".format(
tilastokirja["kestoaika"],
tilastokirja["kestovuorot"]
))
ikkunasto.luo_nappi(loppuikkuna["ikkuna"], "Valikkoon", sulje_lopputulos)
def main():
"""Luo käyttöliittymäikkunan, jossa on vasemmalla tekstikenttä otsikoineen,
kaksi nappia (muunnosnappi ja quit) ja oikealla tekstilaatikko."""
global tekstilaatikko
global tekstikentta
ikkuna = ik.luo_ikkuna("Kompleksilukumuunnin")
nappikehys = ik.luo_kehys(ikkuna, ik.VASEN)
tekstirivi = ik.luo_tekstirivi(nappikehys, "Kompleksiluku: ")
tekstikentta = ik.luo_tekstikentta(nappikehys)
muutosnappi = ik.luo_nappi(nappikehys, "Muunna", muuta_osoitinmuotoon)
quitnappi = ik.luo_nappi(nappikehys, "Lopeta", ik.lopeta)
ylakehys = ik.luo_kehys(ikkuna, ik.VASEN)
tekstilaatikko = ik.luo_tekstilaatikko(ylakehys, leveys=80, korkeus=20)
ik.kaynnista()
def piikin_intensiteetti(alku, loppu):
"""
Laskee integroimalla piikin intensiteetin käyttäen
puolisuunnikassääntöä annetulla energiavälillä.
Tämä toteutetaan käyttäen numpy-kirjaston trapz-funktiota.
Luo lopuksi piikkien suhteen laskemisnapin, jos sitä ei vielä ole.
:param int alku: indeksi, jonka perusteella löydetään piikin alkupiste
:param int loppu: indeksi, jonka perusteella löydetään piikin loppupiste
"""
otsikko = "Lasketaan piikin intensiteetti"
ilmoitus = "Lasketaan piikin intensiteetti käyttäen energiaväliä\n"
energiavali = "{:.3f} eV - {:.3f} eV".format(LISTAT["energiat"][alku],
LISTAT["energiat"][loppu])
ikkunasto.avaa_viesti_ikkuna(otsikko, ilmoitus + energiavali + ".")
intensiteetti = numpy.trapz(LISTAT["intensiteetit"][alku:loppu],
LISTAT["energiat"][alku:loppu])
if len(LISTAT["piikkien_I"]) >= 2:
LISTAT["piikkien_I"].remove(LISTAT["piikkien_I"][0])
LISTAT["piikkien_I"].append(intensiteetti)
intensiteetti_ilmoitus = (
"Intensiteetti energiavälillä {} on {:.3f}.".format(
energiavali, intensiteetti))
ikkunasto.kirjoita_tekstilaatikkoon(ELEMENTIT["tekstilaatikko"],
intensiteetti_ilmoitus)
LISTAT["pisteet"] = []
if len(LISTAT["piikkien_I"]) >= 2 and not ELEMENTIT["suhdenappi"]:
ELEMENTIT["suhdenappi"] = ikkunasto.luo_nappi(
ELEMENTIT["vasen_yla_kehys"], "Suhde", piikkien_suhde)
def tilastot():
palikat["tilasto"] = ik.luo_ali_ikkuna("Tilastot")
ylakehys = ik.luo_kehys(palikat["tilasto"], ik.YLA)
alakehys = ik.luo_kehys(palikat["tilasto"], ik.ALA)
nollaa = ik.luo_nappi(alakehys, "Nollaa tilastot", nollaus)
palikat["tilastolaatikko"] = ik.luo_tekstilaatikko(ylakehys, 55, 25)
ik.kirjoita_tekstilaatikkoon(palikat["tilastolaatikko"], tilasto())
def main():
global jannite_kentta
global taajuus_kentta
global vastus_kentta
global kela_kentta
global kondensaattori_kentta
ikkuna = ik.luo_ikkuna("Ikkuna")
nappikehys = ik.luo_kehys(ikkuna, ik.VASEN)
jannite_rivi = ik.luo_tekstirivi(nappikehys, "Aseta jännitteen suuruus:")
jannite_kentta = ik.luo_tekstikentta(nappikehys)
taajuus_rivi = ik.luo_tekstirivi(nappikehys, "Aseta taajuuden suuruus:")
taajuus_kentta = ik.luo_tekstikentta(nappikehys)
vastus_rivi = ik.luo_tekstirivi(nappikehys, "Aseta vastuksen arvo:")
vastus_kentta = ik.luo_tekstikentta(nappikehys)
kondensaattori_rivi = ik.luo_tekstirivi(nappikehys, "Aseta kondensaattorin arvo:")
kondensaattori_kentta = ik.luo_tekstikentta(nappikehys)
kela_rivi = ik.luo_tekstirivi(nappikehys, "Aseta kelan arvo:")
kela_kentta = ik.luo_tekstikentta(nappikehys)
jannite_nappi = ik.luo_nappi(nappikehys, "Aseta jännite", aseta_jannite)
taajuus_nappi = ik.luo_nappi(nappikehys, "Aseta taajuus", aseta_taajuus)
vastus_nappi = ik.luo_nappi(nappikehys, "Lisää vastus", lisaa_vastus)
kondensaattori_nappi = ik.luo_nappi(nappikehys, "Lisää kondensaattori", lisaa_kondensaattori)
kela_nappi = ik.luo_nappi(nappikehys, "Lisää kela", lisaa_kela)
piirto_nappi = ik.luo_nappi(nappikehys, "Piirrä piiri", piirra_piiri)
lopetusnappi = ik.luo_nappi(nappikehys, "Lopeta", ik.lopeta)
ylakehys = ik.luo_kehys(ikkuna, ik.VASEN)
tila["laatikko"] = ik.luo_tekstilaatikko(nappikehys, leveys=20, korkeus=60)
piirto_alue = pi.luo_piiri(ikkuna, leveys=600, korkeus=400, fonttikoko=16)
ik.kaynnista()
def aloita_peli():
'''Funktio kysyy pelaajalta kentän koon sekä miinojen määrän sekä
palauttaa nämä arvot. Avataan ali-ikkunaan jonne syötetään kentan
leveys, korkeus sekä miinojen määrä (ei implementoitu vielä).'''
ala = iku.luo_ali_ikkuna('')
ala_kehys1 = iku.luo_kehys(ala)
ala_kehys2 = iku.luo_kehys(ala)
ala_teksti1 = iku.luo_tekstilaatikko(ala_kehys1, 20, 1)
iku.kirjoita_tekstilaatikkoon(ala_teksti1, "Anna kentän korkeus")
elementit["korkeus"] = iku.luo_tekstikentta(ala_kehys1)
ala_teksti2 = iku.luo_tekstilaatikko(ala_kehys2, 20, 1)
iku.kirjoita_tekstilaatikkoon(ala_teksti2, "Anna kentän leveys")
elementit["leveys"] = iku.luo_tekstikentta(ala_kehys2)
ala_kehys3 = iku.luo_kehys(ala)
ala_teksti3 = iku.luo_tekstilaatikko(ala_kehys3, 20, 1)
iku.kirjoita_tekstilaatikkoon(ala_teksti3, "Anna miinojen määrä")
elementit["miinat"] = iku.luo_tekstikentta(ala_kehys3)
iku.luo_nappi(ala_kehys2, 'Syötä arvot ja aloita peli', arvo_kasittelija)
iku.luo_nappi(ala_kehys2, 'Yllätä minut', yllata)
def tilastot():
"""
Luo uuden ikkunan, lukee tilastot tiedostosta ja kirjoittaa
ne tekstilaatikkoon. Jos tilastoja tai tiedostoa ei ole,
tai niitä ei voi lukea, tulostuu virheviesti.
"""
ikkunasto.lopeta()
tilasto_ikkuna = ikkunasto.luo_ikkuna("Tilastot")
ylakehys = ikkunasto.luo_kehys(tilasto_ikkuna, ikkunasto.YLA)
alakehys = ikkunasto.luo_kehys(tilasto_ikkuna, ikkunasto.YLA)
tyhjenna_nappi = ikkunasto.luo_nappi(ylakehys, "Tyhjennä tilastot",
tyhjenna_tilastot)
takaisin_nappi = ikkunasto.luo_nappi(ylakehys, "Takaisin",
takaisin_nappi_kasittelija)
global tilastolaatikko
tilastolaatikko = ikkunasto.luo_tekstilaatikko(alakehys, 70, 30)
try:
with open("tilastot.txt") as luku:
try:
sisalto = luku.readlines()
if not sisalto:
ikkunasto.kirjoita_tekstilaatikkoon(
tilastolaatikko, "Tilastoja ei ole.")
for rivi in sisalto:
voitto = ""
lista = rivi.split(",")
if lista[3] == "True":
voitto = "Voitto"
elif lista[3] == "False":
voitto = "Häviö"
ikkunasto.kirjoita_tekstilaatikkoon(
tilastolaatikko,
"{}\n{}! Pelaaja: {}. Aika: {}. Vuorot: {}\nKentän koko: {}x{}. Miinoja: {}"
.format(lista[1], voitto, lista[0], lista[2], lista[4],
lista[5], lista[6], lista[7]))
except IndexError:
ikkunasto.kirjoita_tekstilaatikkoon(
tilastolaatikko,
"Tilastoja ei voida lukea. Tyhjennä tilastot", True)
except FileNotFoundError:
ikkunasto.kirjoita_tekstilaatikkoon(tilastolaatikko,
"Tilastoja ei ole.")
def valinnat():
palikat["valinnat"] = ik.luo_ali_ikkuna("Valinnat")
ylakehys = ik.luo_kehys(palikat["valinnat"], ik.YLA)
syotekehys = ik.luo_kehys(ylakehys, ik.VASEN)
nappikehys = ik.luo_kehys(ylakehys, ik.VASEN)
korkeusohje = ik.luo_tekstirivi(syotekehys, "Korkeus:")
palikat["korkeuskentta"] = ik.luo_tekstikentta(syotekehys)
leveysohje = ik.luo_tekstirivi(syotekehys, "Leveys:")
palikat["leveyskentta"] = ik.luo_tekstikentta(syotekehys)
miinatohje = ik.luo_tekstirivi(syotekehys, "Miinojen lukumäärä:")
palikat["miinatkentta"] = ik.luo_tekstikentta(syotekehys)
oknappi = ik.luo_nappi(nappikehys, "Ok", ok)
def kysyja():
ikkuna = ikkunasto.luo_ikkuna("Koko")
kehys = ikkunasto.luo_kehys(ikkuna)
laatikko = ikkunasto.luo_tekstilaatikko(kehys)
teksti = ikkunasto.kirjoita_tekstilaatikkoon(
laatikko,
"Syötä kentän koko (x ruutua kertaa y ruutua)\nYlempään x ja alempaan y"
)
kysyja.kenttax = ikkunasto.luo_tekstikentta(kehys)
kysyja.kenttay = ikkunasto.luo_tekstikentta(kehys)
nappi = ikkunasto.luo_nappi(kehys, "Paina tästä aloittaaksesi",
ikkunasto_napin_kasittelija)
ikkunasto.kaynnista()
def main():
"""
Luo käyttöliittymäikkunan, joka sisältää käyttöliittymän napit eri toimintoihin,
kuvaajan ja tekstilaatikon. Oletuksena sovellus avataan koko näytölle.
Käyttöliittymäelementtien koot voidaan määrätä vakioiden avulla.
"""
ikkuna = ik.luo_ikkuna(OTSIKKO)
ikkuna.state("zoomed") # Avataan oletuksena koko näytölle.
nappikehys = ik.luo_kehys(ikkuna, ik.VASEN)
napit["LATAA"] = ik.luo_nappi(nappikehys, NAPPI_LATAA, avaa_kansio)
napit["PIIRRA"] = ik.luo_nappi(nappikehys, NAPPI_PIIRRA, piirra_data)
napit["POISTA"] = ik.luo_nappi(nappikehys, NAPPI_POISTA, poista_tausta)
napit["LASKE"] = ik.luo_nappi(nappikehys, NAPPI_LASKE, laske_intensiteetit)
napit["TALLENNA"] = ik.luo_nappi(nappikehys, NAPPI_TALLENNA,
tallenna_kuvaaja)
# Määritellään napit ja asetetaan niille käsittelijät.
laatikkokehys = ik.luo_kehys(ikkuna,
ik.VASEN) # Luodaan kehys tekstilaatikolle.
elementit["alue"], elementit["kuvaaja"] = ik.luo_kuvaaja(
nappikehys, kasittele_pistevalinta, KUVAAJAN_KOKO[0], KUVAAJAN_KOKO[1])
elementit["piirto"] = elementit["kuvaaja"].add_subplot(1, 1, 1)
# Luodaan kuvaaja ja sille subplot.
elementit["piirto"].set_xlabel(X_AKSELI)
elementit["piirto"].set_ylabel(Y_AKSELI) # Asetetaan akseleille nimet.
elementit["tekstilaatikko"] = ik.luo_tekstilaatikko(
laatikkokehys, leveys=LAATIKON_KOKO[0], korkeus=LAATIKON_KOKO[1])
# Luodaan tekstilaatikko.
ik.kirjoita_tekstilaatikkoon(elementit["tekstilaatikko"],
INFO) # Kirjoitetaan infoteksti.
ik.kaynnista() # Käyntiin!
def piirra_data():
"""
Piirtää sen hetkisen ohjelman muistista löytyvän datan näkyviin.
Luo lopuksi lineaarisen taustan poistonapin sekä tallennusnapin,
jos niitä ei vielä ole.
"""
ELEMENTIT["akselit"].cla()
ELEMENTIT["akselit"].set_xlabel("Sidosenergia (eV)")
ELEMENTIT["akselit"].set_ylabel("Intensiteetti (mielivaltainen yksikkö)")
ELEMENTIT["akselit"].grid(True)
ELEMENTIT["akselit"].plot(LISTAT["energiat"], LISTAT["intensiteetit"])
ELEMENTIT["piirtoalue"].draw()
piirtoilmoitus = "Nykyinen data piirretty."
ikkunasto.kirjoita_tekstilaatikkoon(ELEMENTIT["tekstilaatikko"],
piirtoilmoitus)
ikkunasto.paivita_tekstirivi(ELEMENTIT["tekstirivi"], "Valitse piste")
LISTAT["pisteet"] = []
if not ELEMENTIT["tallennusnappi"]:
ELEMENTIT["tallennusnappi"] = ikkunasto.luo_nappi(
ELEMENTIT["vasen_yla_kehys"], "Tallenna...", tallenna_kuvaaja)
if not ELEMENTIT["poistonappi"]:
ELEMENTIT["poistonappi"] = ikkunasto.luo_nappi(
ELEMENTIT["vasen_yla_kehys"], "Poista tausta", poista_tausta)
def pyyda_syotteet():
"""
Pyytää pelajaalta pelikentän koon ja miinojen lukumäärän.
"""
if syotteet["ikkuna"]:
ikkunasto.poista_elementti(syotteet["ikkuna"])
syotteet["ikkuna"] = None
if loppuikkuna["ikkuna"]:
sulje_lopputulos()
loppuikkuna["ikkuna"] = None
syotteet["ikkuna"] = ikkunasto.luo_ali_ikkuna("Pelikentän tiedot")
ikkunasto.luo_tekstirivi(syotteet["ikkuna"], "Pelikentän korkeus:")
syotteet["korkeus"] = ikkunasto.luo_tekstikentta(syotteet["ikkuna"])
ikkunasto.luo_tekstirivi(syotteet["ikkuna"], "Pelikentän leveys:")
syotteet["leveys"] = ikkunasto.luo_tekstikentta(syotteet["ikkuna"])
ikkunasto.luo_tekstirivi(syotteet["ikkuna"], "Miinojen lukumäärä:")
syotteet["miinojen_lkm"] = ikkunasto.luo_tekstikentta(syotteet["ikkuna"])
ikkunasto.luo_vaakaerotin(syotteet["ikkuna"])
aloitusnappi = ikkunasto.luo_nappi(syotteet["ikkuna"], "Aloita", tarkista_syotteet)
def mainmenu():
'''Valikon mainfunktio joka luo käyttöikkunan käyttäen ikkunastoa'''
ikkuna = iku.luo_ikkuna('Miinaharava')
kehys1 = iku.luo_kehys(ikkuna)
elementit["kehys1"] = iku.luo_kehys(ikkuna, iku.YLA)
elementit["kehys2"] = iku.luo_kehys(ikkuna, iku.ALA)
iku.luo_nappi(kehys1, "Aloita peli", aloita_peli)
iku.luo_nappi(kehys1, "Katsele tuloksia", tulokset)
iku.luo_nappi(kehys1, "Lopeta", lopeta)
elementit["teksti1"] = iku.luo_tekstilaatikko(elementit["kehys1"], 20, 3)
elementit["teksti2"] = iku.luo_tekstilaatikko(elementit["kehys2"], 20, 1)
iku.kirjoita_tekstilaatikkoon(elementit["teksti1"], "MIINAHARAVA")
iku.kirjoita_tekstilaatikkoon(elementit["teksti2"], "A game by Aleksi")
iku.kaynnista()
def poista_tausta():
"""
Napinkäsittelijä, joka poistaa spektristä mittauslaitteistosta johtuvan lineaarisen taustan.
Käyttäjälle ilmoitetaan, mitä pisteitä tullaan käyttämään.
Luo lopuksi intensiteetin laskemisnapin, jos sitä ei vielä ole.
:param float x1, y1, x2, y2: pisteet, joiden välille sovitetaan suora
"""
virhe_otsikko = "Lineaarisen taustan poistaminen epäonnistui"
valintaohje = "Valitse kuvaajan alku- ja loppupäästä kaksi pistettä klikkaamalla."
minimivali = numpy.abs(LISTAT["energiat"][-1] - LISTAT["energiat"][0]) / 4
x1, y1, x2, y2 = tarkista_pisteet(virhe_otsikko, valintaohje, minimivali)
if x1 == None and y1 == None and x2 == None and y2 == None:
# Tässähän voisi tarkistaa vain yhden näistä Noneksi, mutta perfektionismi.
pass
else:
poisto_otsikko = "Poistetaan lineaarinen tausta"
poistoilmoitus = "Poistetaan lineaarinen tausta käyttäen pisteitä\n"
pisteet = ("({x1:.3f}, {y1:.3f}) ja ({x2:.3f}, {y2:.3f}).".format(
x1=x1, y1=y1, x2=x2, y2=y2))
ikkunasto.avaa_viesti_ikkuna(poisto_otsikko, poistoilmoitus + pisteet)
k, b = laske_parametrit(x1, y1, x2, y2)
if k == None:
# Tämä ilmoitus tulee ainoastaan tekstilaatikkoon,
# koska siitä avataan viesti-ikkuna jo laske_parametrit-funktion sisällä.
ikkunasto.kirjoita_tekstilaatikkoon(ELEMENTIT["tekstilaatikko"],
virhe_otsikko)
else:
suoran_arvot = laske_pisteet_suoralla(k, b, LISTAT["energiat"])
for i, y in enumerate(suoran_arvot):
LISTAT["intensiteetit"][i] = LISTAT["intensiteetit"][i] - y
kuittaus = "Lineaarinen tausta poistettu käyttäen pisteitä:\n"
ikkunasto.kirjoita_tekstilaatikkoon(ELEMENTIT["tekstilaatikko"],
kuittaus + pisteet)
piirra_data()
LISTAT["pisteet"] = []
if not ELEMENTIT["intensiteettinappi"]:
ELEMENTIT["intensiteettinappi"] = ikkunasto.luo_nappi(
ELEMENTIT["vasen_yla_kehys"], "Intensiteetti",
valmistele_intensiteetti)
def peli_loppu():
'''Funktio joka suorittaa kaiken pelin loppumisen jälkeen tapahtuvan'''
ikkuna = iku.luo_ikkuna('')
ali = iku.luo_kehys(ikkuna)
if liput['voitto'] == 1:
iku.avaa_viesti_ikkuna('', 'VOITIT PELIN')
elif liput['voitto'] == 2:
iku.avaa_viesti_ikkuna('', 'HÄVISIT PELIN')
iku.luo_tekstirivi(
ali, 'Liputit {} miinaa, kun miinoja oli {} kpl'.format(
peli['liputetut'], peli['miinat']))
iku.luo_tekstirivi(ali, 'Aikaa kului {} sekuntia'.format(stats['aika']))
iku.luo_nappi(ali, 'Pelaa uudelleen', uusiksi)
iku.luo_nappi(ali, 'Tallenna tulokset', save)
iku.luo_nappi(ali, 'Palaa päävalikkoon', back)
iku.kaynnista()
def main():
"""
Luo käyttöliittymäikkunan,
jossa vasemmalla on kolme nappia,
joista kaksi alinta on erotettu vaakaerottimella,
oikealla taas on kuvaaja, tekstirivi sekä tekstilaatikko.
Käyttöliittymä koostuu yhteensä neljästä kehyksestä;
vasen "emo" kehys ja oikea kehys jakavat ikkunan kahteen osaan.
Vasen kehys taas jaetaan pystysuunnassa vielä kahteen osaan,
mikä mahdollistaa nappien lisäämisen ohjelman edetessä ilman,
että vaakaerottimen alle tulevat lopetus- ja tyhjennysnapit
menevät muiden kanssa sekaisin.
"""
ikkuna = ikkunasto.luo_ikkuna("Spektrimestari v.{}".format(VERSIO))
vasen_emo_kehys = ikkunasto.luo_kehys(ikkuna)
ELEMENTIT["vasen_yla_kehys"] = ikkunasto.luo_kehys(vasen_emo_kehys,
ikkunasto.YLA)
vasen_ala_kehys = ikkunasto.luo_kehys(vasen_emo_kehys, ikkunasto.YLA)
oikea_kehys = ikkunasto.luo_kehys(ikkuna)
ikkunasto.luo_nappi(ELEMENTIT["vasen_yla_kehys"], "Avaa...", avaa_kansio)
ikkunasto.luo_vaakaerotin(vasen_ala_kehys)
ikkunasto.luo_nappi(vasen_ala_kehys, "Ohje", nayta_ohje)
ikkunasto.luo_nappi(vasen_ala_kehys, "Tyhjennä", tyhjaa_muisti)
ikkunasto.luo_nappi(vasen_ala_kehys, "Lopeta", ikkunasto.lopeta)
piirtoalue, kuvaaja = ikkunasto.luo_kuvaaja(oikea_kehys, valitse_datapiste,
600, 400)
akselit = kuvaaja.subplots()
kuvaaja.suptitle("Spektri")
akselit.grid(True)
ELEMENTIT["piirtoalue"] = piirtoalue
ELEMENTIT["kuvaaja"] = kuvaaja
ELEMENTIT["akselit"] = akselit
ELEMENTIT["tekstirivi"] = ikkunasto.luo_tekstirivi(oikea_kehys, "")
ELEMENTIT["tekstilaatikko"] = ikkunasto.luo_tekstilaatikko(
oikea_kehys, 60, 20)
ikkunasto.kaynnista()
def wizard():
"""
Funktio, jolla lähdetään kysymään piirtämiseen tarvittavat arvot.
Funktio jatkuu Komponenttien lisäämiseen uudella funktiolla.
"""
KLIITTYMÄ["wizAk"] = ikn.luo_ali_ikkuna("Wizard")
# Jännite:
ikn.luo_tekstirivi(KLIITTYMÄ["wizAk"], "Anna jännite ilman yksikköä:")
KLIITTYMÄ["syote"[0]] = ikn.luo_tekstikentta(KLIITTYMÄ["wizAk"])
ikn.luo_nappi(KLIITTYMÄ["wizAk"], "Aseta jännite", asetaJannite)
ikn.luo_vaakaerotin(KLIITTYMÄ["wizAk"])
# Taajuus:
ikn.luo_tekstirivi(KLIITTYMÄ["wizAk"], "Anna taajuus ilman yksikköä:")
KLIITTYMÄ["syote"[1]] = ikn.luo_tekstikentta(KLIITTYMÄ["wizAk"])
ikn.luo_nappi(KLIITTYMÄ["wizAk"], "Aseta taajuus", asetaTaajuus)
ikn.luo_vaakaerotin(KLIITTYMÄ["wizAk"])
ikn.luo_nappi(KLIITTYMÄ["wizAk"], "Seuraava", lisaaKomponenttiKL)
def main():
"""
Luo käyttöliittymäikkunan, jossa on vasemmalla puolella syötekenttä numeroarvoille,
neljä nappia ja tekstilaatikko. Oikealla puolella on piirikaaviokuva.
"""
ikkuna = ik.luo_ikkuna("Piiri pieni pyörii")
vasen_kehys = ik.luo_kehys(ikkuna, ik.VASEN)
oikea_kehys = ik.luo_kehys(ikkuna, ik.OIKEA)
tk_otsikko = ik.luo_tekstirivi(vasen_kehys, "arvo:")
tila["syote"] = ik.luo_tekstikentta(vasen_kehys)
jannitenappi = ik.luo_nappi(vasen_kehys, "aseta jännite", aseta_jannite)
taajuusnappi = ik.luo_nappi(vasen_kehys, "aseta taajuus", aseta_taajuus)
haaranappi = ik.luo_nappi(vasen_kehys, "luo uusi haara", luo_haara)
komponenttinappi = ik.luo_nappi(vasen_kehys, "anna komponentin tyyppi",
valitse_tyyppi)
arvonappi = ik.luo_nappi(vasen_kehys, "anna komponentin arvo", laske_arvo)
lopetusnappi = ik.luo_nappi(vasen_kehys, "quit", ik.lopeta)
tila["laatikko"] = ik.luo_tekstilaatikko(vasen_kehys, 50, 40)
tila["piiri"] = psto.luo_piiri(oikea_kehys, 700, 700, 10)
ik.kaynnista()
palikat["leveyskentta"] = ik.luo_tekstikentta(syotekehys)
miinatohje = ik.luo_tekstirivi(syotekehys, "Miinojen lukumäärä:")
palikat["miinatkentta"] = ik.luo_tekstikentta(syotekehys)
oknappi = ik.luo_nappi(nappikehys, "Ok", ok)
def ok():
try:
parametrit["korkeus"] = int(
ik.lue_kentan_sisalto(palikat["korkeuskentta"]))
parametrit["leveys"] = int(
ik.lue_kentan_sisalto(palikat["leveyskentta"]))
parametrit["miinalkm"] = int(
ik.lue_kentan_sisalto(palikat["miinatkentta"]))
ik.piilota_ali_ikkuna(palikat["valinnat"])
except ValueError:
ik.avaa_viesti_ikkuna("Virhe", "Syötä kolme kokonaislukua", virhe=True)
#Pääohjelma
valikko_ikkuna = ik.luo_ikkuna("Miinaharava")
ylakehys = ik.luo_kehys(valikko_ikkuna, ik.YLA)
alakehys = ik.luo_kehys(valikko_ikkuna, ik.YLA)
nappikehys = ik.luo_kehys(ylakehys, ik.VASEN)
pelinappi = ik.luo_nappi(nappikehys, "Aloita uusi peli", main)
valinnatnappi = ik.luo_nappi(nappikehys, "Valinnat", valinnat)
tilastotnappi = ik.luo_nappi(nappikehys, "Tilastot", tilastot)
lopetusnappi = ik.luo_nappi(nappikehys, "Lopeta", ik.lopeta)
ik.kaynnista()
"""
KLIITTYMÄ["komponentit"] = [[]]
KLIITTYMÄ["jannite"] = 0
KLIITTYMÄ["taajuus"] = 0
tyhjaaLaskut()
tyhjaaLogi()
piiristo.tyhjaa_piiri(KLIITTYMÄ["piirikuva"])
# Pääohjelma
if __name__ == "__main__":
akkuna = ikn.luo_ikkuna("Piiri pieni pyörii")
kehysK = ikn.luo_kehys(akkuna)
kehysO = ikn.luo_kehys(akkuna)
KLIITTYMÄ["piirikuva"] = piiristo.luo_piiri(kehysK)
ikn.luo_nappi(kehysO, "Aloita piirtäminen", wizard)
ikn.luo_tekstirivi(kehysO, "Jännite/Taajuuslogi:")
KLIITTYMÄ["logi"] = ikn.luo_tekstilaatikko(kehysO, leveys=40, korkeus=4)
ikn.luo_nappi(kehysO, "Tyhjää logi", tyhjaaLogi)
ikn.luo_tekstirivi(kehysO, "Laskentatulokset:")
KLIITTYMÄ["laskentatulokset"] = ikn.luo_tekstilaatikko(kehysO,
leveys=40,
korkeus=10)
ikn.luo_nappi(kehysO, "Tyhjää laskelmat", tyhjaaLaskut)
ikn.luo_nappi(kehysO, "Nollaa arvot", nollaus)
ikn.luo_nappi(kehysO, "Lopeta", ikn.lopeta)
wizard() # Avataan Wizard automaattisesti
ikn.kaynnista()
_piirra_komponentti(piiri, komponentti[0], komponentti[1],
pituusyksikko)
if loppujohdin:
piiri.add(e.LINE, d="down", l=3 * pituusyksikko)
if not viimeinen:
piiri.add(e.DOT)
piiri.add(e.LINE, d="right", l=h_asetteluvali / 2, move_cur=False)
piiri.add(e.LINE, d="left", l=h_asetteluvali / 2)
if __name__ == "__main__":
import ikkunasto as ui
def piirra_testipiiri():
haara = [[("r", 100), ("r", 100)], ("r", 200),
[("r", 100), ("r", 100), ("r", 100)]]
piirra_jannitelahde(piiri, 10, "10k", 2)
piirra_haara(piiri, haara, 3, 2, viimeinen=True)
haara = [("c", "1.0n")]
#piirra_haara(piiri, haara, 1, 2, viimeinen=True)
piirra_piiri(piiri)
ikkuna = ui.luo_ikkuna("much circuit")
kehys = ui.luo_kehys(ikkuna, TOP)
ui.luo_nappi(kehys, "TESTAA", piirra_testipiiri)
ui.luo_nappi(kehys, "LOPETA", ui.lopeta)
piiri = luo_piiri(kehys, 600, 600, 10)
ui.kaynnista()
