# -*- coding: utf-8 -*-

# Tässä pelissä läiskitään ympäriinsä lenteleviä hyttysiä

import pygame
import random
from math import sqrt

Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Tausta = (160, 200, 255)

# Peli-ikkunan koko pikseleinä. Pikseli on piste näytöllä.
Wx = 800
Wy = 600
Wxy = (Wx, Wy)  # peli-ikkunan korkeus ja leveys

Nayttotaajuus = 24  # Voit kokeilla eri näyttötaajuuksia

Dt = 1.0/Nayttotaajuus

# # # # # # # # # # # # # # # # # # # # # # # # # # #
# Pääohjelma alkaa tästä
# # # # # # # # # # # # # # # # # # # # # # # # # # #

pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä. Pikseli on piste näytöllä.
D_Info = pygame.display.Info()
Wx = D_Info.current_w
Wy = int(0.9*D_Info.current_h)
Wxy = (Wx, Wy)  # peli-ikkunan korkeus ja leveys

screen = pygame.display.set_mode((Wx, Wy))
pygame.display.set_caption(
    "Hyttysjahti")
pygame.init()
clock = pygame.time.Clock()
random.seed()

#
# Toistetaan allaolevaa while-silmukkaa, kunnes käyttäjä sulkee peli-ikkunan
# tai painaa ESC-iä
#
loppu = False
while not loppu:

    clock.tick(Nayttotaajuus)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            loppu = True
        if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
            loppu = True

    screen.fill(Tausta)

    # näytetään kaikki yllä 'piirretty' näytöllä
    pygame.display.flip()
    #
    # while silmukka päättyy tähän
#
# Ohjelman loppu
pygame.quit()

 #  -*- coding: utf-8 -*-

 #  Tässä pe­lis­sä läis­ki­tään ym­pä­riin­sä len­te­le­viä hyt­ty­siä

import pygame
import random
from math import sqrt

Musta = (0, 0, 0)  #  Mus­tas­sa ei ole mi­tään valoa
Sin = (0, 0, 255)  #  vain si­nis­tä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Valk = (255, 255, 255)  #  val­koi­ses­sa on kai­ken­vä­ris­tä valoa
Tausta = (160, 200, 255)

 #  Peli-ik­ku­nan koko pik­se­lei­nä. Pik­se­li on piste näy­töl­lä.
Wx = 800
Wy = 600
Wxy = (Wx, Wy)  #  peli-ik­ku­nan kor­keus ja le­veys

Nayttotaajuus = 24  #  Voit ko­keil­la eri näyt­tö­taa­juuk­sia

Dt = 1.0/Nayttotaajuus

 #  # # # # # # # # # # # # # # # # # # # # # # # # # #
 #  Pää­oh­jel­ma alkaa tästä
 #  # # # # # # # # # # # # # # # # # # # # # # # # # #

pygame.display.init()
 #  Sel­vi­te­tään peli-ik­ku­nan koko näy­töl­lä pik­se­lei­nä. Pik­se­li on piste näy­töl­lä.
D_Info = pygame.display.Info()
Wx = D_Info.current_w
Wy = int(0.9*D_Info.current_h)
Wxy = (Wx, Wy)  #  peli-ik­ku­nan kor­keus ja le­veys

screen = pygame.display.set_mode((Wx, Wy))
pygame.display.set_caption(
    "Hyttysjahti")
pygame.init()
clock = pygame.time.Clock()
random.seed()

 #
 #  Tois­te­taan allaolevaa while-silmukkaa, kun­nes käyt­tä­jä sul­kee peli-ik­ku­nan
 #  tai pai­naa ESC-iä
 #
loppu = False
while not loppu:

    clock.tick(Nayttotaajuus)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            loppu = True
        if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
            loppu = True

    screen.fill(Tausta)

    #  näy­te­tään kaik­ki yllä 'piir­ret­ty' näy­töl­lä
    pygame.display.flip()
    #
    #  while sil­muk­ka päät­tyy tähän
 #
 #  Oh­jel­man loppu
pygame.quit()

# -*- coding: utf-8 -*-

# Tässä pelissä läiskitään ympäriinsä lenteleviä hyttysiä

import pygame
import random
from math import sqrt

Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Tausta = (160, 200, 255)

# Peli-ikkunan koko pikseleinä. Pikseli on piste näytöllä.
Wx = 800
Wy = 600
Wxy = (Wx, Wy)  # peli-ikkunan korkeus ja leveys

Nayttotaajuus = 24  # Voit kokeilla eri näyttötaajuuksia

Dt = 1.0/Nayttotaajuus

# Peliin liittyviä muuttujia.
VLatka = 200.0  # Lätkän nopeus

# __init__(self, x, y, koko) on metodi, jolla lätkä luodaan

class Cl_Latka:
    def __init__(self, x, y, koko):
        self.paikka = (x, y)
        self.koko = koko
        self.color = Vihr
        self.liikkuu = False

    def piirra(self):
        (x, y) = self.paikka
        iPaikka = (int(x), int(y))
        pygame.draw.circle(screen, self.color, iPaikka, self.koko, 0)
        pygame.draw.circle(screen, Pun, iPaikka, int(self.koko/2), 0)

    def liiku(self, vxvy):
        (x, y) = self.paikka
        (vx, vy) = vxvy
        (x, y) = (x + vx*Dt, y + vy*Dt)
        # Lisäämällä tähän väliin muutaman if lauseen, voit korjata ohjelmaa
        #  niin, että Lätkä ei karkaa peli-ikkunan reunan ulkopuolelle
        # jos x on suurempi kuin niin Wx x.stä kannattaa vähentää Wx jne...
        self.paikka = (x, y)
        self.liikkuu = True

# # # # # # # # # # # # # # # # # # # # # # # # # # #
# Pääohjelma alkaa tästä
# # # # # # # # # # # # # # # # # # # # # # # # # # #

pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä. Pikseli on piste näytöllä.
D_Info = pygame.display.Info()
Wx = D_Info.current_w
Wy = int(0.9*D_Info.current_h)
Wxy = (Wx, Wy)  # peli-ikkunan korkeus ja leveys

screen = pygame.display.set_mode((Wx, Wy))
pygame.display.set_caption(
    "Hyttysjahti")
pygame.init()
clock = pygame.time.Clock()
random.seed()

# Luodaan 'olio' tyyppiä Cl_latka
Latka = Cl_Latka(Wx-50, Wy-50, 15)

#
# Toistetaan allaolevaa while-silmukkaa, kunnes käyttäjä sulkee peli-ikkunan
# tai painaa ESC-iä
#
loppu = False
while not loppu:

    clock.tick(Nayttotaajuus)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            loppu = True
        if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
            loppu = True

    screen.fill(Tausta)

    Latka.liikkuu = False
#   Tarkistetaan, onko joku tai jotkin lätkää ohjaavista näppäimistä
# painettuna. Liikutetaan lätkää vastaavasti.
    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_UP]:
        Latka.liiku((0.0, -VLatka))  # ylös
    if pressed[pygame.K_DOWN]:
        Latka.liiku((0.0, VLatka))  # alas
    if pressed[pygame.K_z]:
        Latka.liiku((-VLatka, 0.0))  # vasemmalle
    if pressed[pygame.K_x]:
        Latka.liiku((VLatka, 0.0))  # oikealle
    # Piirretään lätkä uudelle paikalleen
    Latka.piirra()

    # näytetään kaikki yllä 'piirretty' näytöllä
    pygame.display.flip()
    #
    # while silmukka päättyy tähän
#
# Ohjelman loppu
pygame.quit()

import pygame
import random
from math import sqrt

Nayttotaajuus = 24  #  Voit ko­keil­la eri näyt­tö­taa­juuk­sia

 #  Pe­liin liit­ty­viä muut­tu­jia.
VLatka = 200.0  #  Lät­kän no­peus

 #  __init__(self, x, y, koko) on me­to­di, jolla lätkä luo­daan

class Cl_Latka:
    def __init__(self, x, y, koko):
        self.paikka = (x, y)
        self.koko = koko
        self.color = Vihr
        self.liikkuu = False

    def piirra(self):
        (x, y) = self.paikka
        iPaikka = (int(x), int(y))
        pygame.draw.circle(screen, self.color, iPaikka, self.koko, 0)
        pygame.draw.circle(screen, Pun, iPaikka, int(self.koko/2), 0)

    def liiku(self, vxvy):
        (x, y) = self.paikka
        (vx, vy) = vxvy
        (x, y) = (x + vx*Dt, y + vy*Dt)
        #  Li­sää­mäl­lä tähän vä­liin muu­ta­man if lau­seen, voit kor­ja­ta oh­jel­maa
        #   niin, että Lätkä ei kar­kaa peli-ik­ku­nan reu­nan ulko­puo­lel­le
        #  jos x on suu­rem­pi kuin niin Wx x.stä kan­nat­taa vä­hen­tää Wx jne...
        self.paikka = (x, y)
        self.liikkuu = True

 #  # # # # # # # # # # # # # # # # # # # # # # # # # #
 #  Pää­oh­jel­ma alkaa tästä
 #  # # # # # # # # # # # # # # # # # # # # # # # # # #

 #  Luo­daan 'olio' tyyp­piä Cl_latka
Latka = Cl_Latka(Wx-50, Wy-50, 15)

 #
 #  Tois­te­taan allaolevaa while-silmukkaa, kun­nes käyt­tä­jä sul­kee peli-ik­ku­nan
 #  tai pai­naa ESC-iä
 #
loppu = False
while not loppu:

    Latka.liikkuu = False

 #    Tar­kis­te­taan, onko joku tai jot­kin lät­kää oh­jaa­vis­ta näp­päi­mis­tä
 #  pai­net­tu­na. Lii­ku­te­taan lät­kää vas­taa­vas­ti.
    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_UP]:
        Latka.liiku((0.0, -VLatka))  #  ylös
    if pressed[pygame.K_DOWN]:
        Latka.liiku((0.0, VLatka))  #  alas
    if pressed[pygame.K_z]:
        Latka.liiku((-VLatka, 0.0))  #  va­sem­mal­le
    if pressed[pygame.K_x]:
        Latka.liiku((VLatka, 0.0))  #  oi­keal­le

    #  Piir­re­tään lätkä uu­del­le pai­kal­leen
    Latka.piirra()

    #  näy­te­tään kaik­ki yllä 'piir­ret­ty' näy­töl­lä
    pygame.display.flip()
    #
    #  while sil­muk­ka päät­tyy tähän
 #
 #  Oh­jel­man loppu
pygame.quit()

# -*- coding: utf-8 -*-

# Tässä pelissä läiskitään ympäriinsä lenteleviä hyttysiä

import pygame
import random
from math import sqrt

Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Tausta = (160, 200, 255)

# Peli-ikkunan koko pikseleinä. Pikseli on piste näytöllä.
Wx = 800
Wy = 600
Wxy = (Wx, Wy)  # peli-ikkunan korkeus ja leveys

Nayttotaajuus = 24  # Voit kokeilla eri näyttötaajuuksia

Dt = 1.0/Nayttotaajuus

# Peliin liittyviä muuttujia.
VLatka = 200.0  # Lätkän nopeus

Vmax = 250.0
MaxKiihtyvyys = 400.0

# __init__(self, x, y, koko) on metodi, jolla lätkä luodaan

class Cl_Latka:
    def __init__(self, x, y, koko):
        self.paikka = (x, y)
        self.koko = koko
        self.color = Vihr
        self.liikkuu = False

    def piirra(self):
        (x, y) = self.paikka
        iPaikka = (int(x), int(y))
        pygame.draw.circle(screen, self.color, iPaikka, self.koko, 0)
        pygame.draw.circle(screen, Pun, iPaikka, int(self.koko/2), 0)

    def liiku(self, vxvy):
        (x, y) = self.paikka
        (vx, vy) = vxvy
        (x, y) = (x + vx*Dt, y + vy*Dt)
        # Lisäämällä tähän väliin muutaman if lauseen, voit korjata ohjelmaa
        #  niin, että Lätkä ei karkaa peli-ikkunan reunan ulkopuolelle
        # jos x on suurempi kuin niin Wx x.stä kannattaa vähentää Wx jne...
        self.paikka = (x, y)
        self.liikkuu = True

class Cl_Hyttynen:
    def __init__(self, x, y):
        self.paikka = (x, y)

        self.nopeus = (70.0, 50.0)  # kokeile tähän eri arvoja

        self.koko = 10
        self.color = (random.randint(0, 255),
                      random.randint(0, 255),
                      random.randint(0, 255))
        self.elossa = True

    def piirra(self):
        iPaikka = (int(self.paikka[0]), int(self.paikka[1]))
        iEllxy = (iPaikka[0], iPaikka[1], 4*self.koko, self.koko)
        if self.elossa:
            pygame.draw.circle(screen, self.color, iPaikka, self.koko, 0)
        else:
            pygame.draw.ellipse(screen, self.color, iEllxy, 0)

    def liiku_suoraan(self):
        (x, y) = self.paikka
        (vx, vy) = self.nopeus
        (x, y) = (x + vx*Dt, y + vy*Dt)
        # poista seuraavista kommenttimerkki,
        # niin saat hyttysen pysymään ruudulla
#        if (x > Wx and vx > 0) or (x < 0 and vx < 0):
#            vx = -vx
#        elif (y > Wy and vy > 0) or (y < 0 and vy < 0):
#            vy = -vy
        self.paikka = (x, y)
        self.nopeus = (vx, vy)

# # # # # # # # # # # # # # # # # # # # # # # # # # #
# Pääohjelma alkaa tästä
# # # # # # # # # # # # # # # # # # # # # # # # # # #

pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä. Pikseli on piste näytöllä.
D_Info = pygame.display.Info()
Wx = D_Info.current_w
Wy = int(0.9*D_Info.current_h)
Wxy = (Wx, Wy)  # peli-ikkunan korkeus ja leveys

screen = pygame.display.set_mode((Wx, Wy))
pygame.display.set_caption(
    "Hyttysjahti")
pygame.init()
clock = pygame.time.Clock()
random.seed()

# Luodaan 'olio' tyyppiä Cl_latka
Latka = Cl_Latka(Wx-50, Wy-50, 15)

# Luodaan yksi hyttynen
hyttynen = Cl_Hyttynen(50, 50)

#
# Toistetaan allaolevaa while-silmukkaa, kunnes käyttäjä sulkee peli-ikkunan
# tai painaa ESC-iä
#
loppu = False
while not loppu:

    clock.tick(Nayttotaajuus)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            loppu = True
        if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
            loppu = True

    screen.fill(Tausta)

    hyttynen.liiku_suoraan()

    hyttynen.piirra()

    Latka.liikkuu = False
#   Tarkistetaan, onko joku tai jotkin lätkää ohjaavista näppäimistä
# painettuna. Liikutetaan lätkää vastaavasti.
    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_UP]:
        Latka.liiku((0.0, -VLatka))  # ylös
    if pressed[pygame.K_DOWN]:
        Latka.liiku((0.0, VLatka))  # alas
    if pressed[pygame.K_z]:
        Latka.liiku((-VLatka, 0.0))  # vasemmalle
    if pressed[pygame.K_x]:
        Latka.liiku((VLatka, 0.0))  # oikealle
    # Piirretään lätkä uudelle paikalleen
    Latka.piirra()

    # näytetään kaikki yllä 'piirretty' näytöllä
    pygame.display.flip()
    #
    # while silmukka päättyy tähän
#
# Ohjelman loppu
pygame.quit()

import pygame
import random
from math import sqrt

Nayttotaajuus = 24  #  Voit ko­keil­la eri näyt­tö­taa­juuk­sia

 #  Pe­liin liit­ty­viä muut­tu­jia.
VLatka = 200.0  #  Lät­kän no­peus

Vmax = 250.0
MaxKiihtyvyys = 400.0

class Cl_Hyttynen:
    def __init__(self, x, y):
        self.paikka = (x, y)

        self.nopeus = (70.0, 50.0)  #  ko­kei­le tähän eri ar­vo­ja

        self.koko = 10
        self.color = (random.randint(0, 255),
                      random.randint(0, 255),
                      random.randint(0, 255))
        self.elossa = True

    def piirra(self):
        iPaikka = (int(self.paikka[0]), int(self.paikka[1]))
        iEllxy = (iPaikka[0], iPaikka[1], 4*self.koko, self.koko)
        if self.elossa:
            pygame.draw.circle(screen, self.color, iPaikka, self.koko, 0)
        else:
            pygame.draw.ellipse(screen, self.color, iEllxy, 0)

    def liiku_suoraan(self):
        (x, y) = self.paikka
        (vx, vy) = self.nopeus
        (x, y) = (x + vx*Dt, y + vy*Dt)
        #  pois­ta seu­raa­vis­ta kom­ment­ti­merk­ki,
        #  niin saat hyt­ty­sen py­sy­mään ruu­dul­la
 #         if (x > Wx and vx > 0) or (x < 0 and vx < 0):
 #             vx = -vx
 #         elif (y > Wy and vy > 0) or (y < 0 and vy < 0):
 #             vy = -vy
        self.paikka = (x, y)
        self.nopeus = (vx, vy)

 #  # # # # # # # # # # # # # # # # # # # # # # # # # #
 #  Pää­oh­jel­ma alkaa tästä
 #  # # # # # # # # # # # # # # # # # # # # # # # # # #

 #  Luo­daan 'olio' tyyp­piä Cl_latka
Latka = Cl_Latka(Wx-50, Wy-50, 15)

 #  Luo­daan yksi hyt­ty­nen
hyttynen = Cl_Hyttynen(50, 50)

 #
 #  Tois­te­taan allaolevaa while-silmukkaa, kun­nes käyt­tä­jä sul­kee peli-ik­ku­nan
 #  tai pai­naa ESC-iä
 #
loppu = False
while not loppu:

    hyttynen.liiku_suoraan()

    hyttynen.piirra()

    #  näy­te­tään kaik­ki yllä 'piir­ret­ty' näy­töl­lä
    pygame.display.flip()
    #
    #  while sil­muk­ka päät­tyy tähän
 #
 #  Oh­jel­man loppu
pygame.quit()

# -*- coding: utf-8 -*-

# Tässä pelissä läiskitään ympäriinsä lenteleviä hyttysiä

import pygame
import random
from math import sqrt

Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Tausta = (160, 200, 255)

# Peli-ikkunan koko pikseleinä. Pikseli on piste näytöllä.
Wx = 800
Wy = 600
Wxy = (Wx, Wy)  # peli-ikkunan korkeus ja leveys

Nayttotaajuus = 24  # Voit kokeilla eri näyttötaajuuksia

Dt = 1.0/Nayttotaajuus

# Peliin liittyviä muuttujia.
VLatka = 200.0  # Lätkän nopeus

Vmax = 250.0
MaxKiihtyvyys = 400.0

# __init__(self, x, y, koko) on metodi, jolla lätkä luodaan

class Cl_Latka:
    def __init__(self, x, y, koko):
        self.paikka = (x, y)
        self.koko = koko
        self.color = Vihr
        self.liikkuu = False

    def piirra(self):
        (x, y) = self.paikka
        iPaikka = (int(x), int(y))
        pygame.draw.circle(screen, self.color, iPaikka, self.koko, 0)
        pygame.draw.circle(screen, Pun, iPaikka, int(self.koko/2), 0)

    def liiku(self, vxvy):
        (x, y) = self.paikka
        (vx, vy) = vxvy
        (x, y) = (x + vx*Dt, y + vy*Dt)
        # Lisäämällä tähän väliin muutaman if lauseen, voit korjata ohjelmaa
        #  niin, että Lätkä ei karkaa peli-ikkunan reunan ulkopuolelle
        # jos x on suurempi kuin niin Wx x.stä kannattaa vähentää Wx jne...
        self.paikka = (x, y)
        self.liikkuu = True

class Cl_Hyttynen:
    def __init__(self, x, y):
        self.paikka = (x, y)

        self.nopeus = (70.0, 50.0)  # kokeile tähän eri arvoja

        self.koko = 10
        self.color = (random.randint(0, 255),
                      random.randint(0, 255),
                      random.randint(0, 255))
        self.elossa = True

    def piirra(self):
        iPaikka = (int(self.paikka[0]), int(self.paikka[1]))
        iEllxy = (iPaikka[0], iPaikka[1], 4*self.koko, self.koko)
        if self.elossa:
            pygame.draw.circle(screen, self.color, iPaikka, self.koko, 0)
        else:
            pygame.draw.ellipse(screen, self.color, iEllxy, 0)

    def liiku_suoraan(self):
        (x, y) = self.paikka
        (vx, vy) = self.nopeus
        (x, y) = (x + vx*Dt, y + vy*Dt)
        # poista seuraavista kommenttimerkki,
        # niin saat hyttysen pysymään ruudulla
#        if (x > Wx and vx > 0) or (x < 0 and vx < 0):
#            vx = -vx
#        elif (y > Wy and vy > 0) or (y < 0 and vy < 0):
#            vy = -vy
        self.paikka = (x, y)
        self.nopeus = (vx, vy)

    def liiku(self):

        self.nopeus = lenna(self.paikka, self.nopeus)

# Siirrytään eteenpäin nopeus kertaa aikaväli
        self.paikka = dfdt(self.paikka, self.nopeus)

def lenna(paikka, nopeus):
    kiihtyvyys = (random.uniform(-MaxKiihtyvyys, MaxKiihtyvyys),
                  random.uniform(-MaxKiihtyvyys, MaxKiihtyvyys))
    nopeus = reunat(paikka, dfdt(nopeus, kiihtyvyys))
    return nopeus
# matka = nopeus*aika
def dfdt(xy, dxdy):
    (x, y) = xy
    (dx, dy) = dxdy
    return (x + dx*Dt, y + dy*Dt)

def reunat(xy, vxvy):
    (vx, vy) = vxvy
    (x, y) = xy
    # ei päästetä hyttystä reunojen ulkopuolelle
    if (x > Wx and vx > 0) or (x < 0 and vx < 0):
        vx = -vx
    elif (y > Wy and vy > 0) or (y < 0 and vy < 0):
        vy = -vy
    # pysäytetään hyttynen, mikäli se lentää tolkuttoman lujaa
    elif sqrt(vx**2 + vy**2) > Vmax:
        vx, vy = 0.0, 0.0
    return (vx, vy)

# # # # # # # # # # # # # # # # # # # # # # # # # # #
# Pääohjelma alkaa tästä
# # # # # # # # # # # # # # # # # # # # # # # # # # #

pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä. Pikseli on piste näytöllä.
D_Info = pygame.display.Info()
Wx = D_Info.current_w
Wy = int(0.9*D_Info.current_h)
Wxy = (Wx, Wy)  # peli-ikkunan korkeus ja leveys

screen = pygame.display.set_mode((Wx, Wy))
pygame.display.set_caption(
    "Hyttysjahti")
pygame.init()
clock = pygame.time.Clock()
random.seed()

# Luodaan 'olio' tyyppiä Cl_latka
Latka = Cl_Latka(Wx-50, Wy-50, 15)

# Luodaan yksi hyttynen
hyttynen = Cl_Hyttynen(50, 50)

#
# Toistetaan allaolevaa while-silmukkaa, kunnes käyttäjä sulkee peli-ikkunan
# tai painaa ESC-iä
#
loppu = False
while not loppu:

    clock.tick(Nayttotaajuus)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            loppu = True
        if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
            loppu = True

    screen.fill(Tausta)

    hyttynen.liiku_suoraan()

    hyttynen.liiku()

    hyttynen.piirra()

    Latka.liikkuu = False
#   Tarkistetaan, onko joku tai jotkin lätkää ohjaavista näppäimistä
# painettuna. Liikutetaan lätkää vastaavasti.
    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_UP]:
        Latka.liiku((0.0, -VLatka))  # ylös
    if pressed[pygame.K_DOWN]:
        Latka.liiku((0.0, VLatka))  # alas
    if pressed[pygame.K_z]:
        Latka.liiku((-VLatka, 0.0))  # vasemmalle
    if pressed[pygame.K_x]:
        Latka.liiku((VLatka, 0.0))  # oikealle
    # Piirretään lätkä uudelle paikalleen
    Latka.piirra()

    # näytetään kaikki yllä 'piirretty' näytöllä
    pygame.display.flip()
    #
    # while silmukka päättyy tähän
#
# Ohjelman loppu
pygame.quit()

import pygame
import random
from math import sqrt

Nayttotaajuus = 24  #  Voit ko­keil­la eri näyt­tö­taa­juuk­sia

    def liiku_suoraan(self):
        (x, y) = self.paikka
        (vx, vy) = self.nopeus
        (x, y) = (x + vx*Dt, y + vy*Dt)
        #  pois­ta seu­raa­vis­ta kom­ment­ti­merk­ki,
        #  niin saat hyt­ty­sen py­sy­mään ruu­dul­la
 #         if (x > Wx and vx > 0) or (x < 0 and vx < 0):
 #             vx = -vx
 #         elif (y > Wy and vy > 0) or (y < 0 and vy < 0):
 #             vy = -vy
        self.paikka = (x, y)
        self.nopeus = (vx, vy)

    def liiku(self):

        self.nopeus = lenna(self.paikka, self.nopeus)

 #  Siir­ry­tään eteen­päin no­peus ker­taa aika­väli
        self.paikka = dfdt(self.paikka, self.nopeus)

def lenna(paikka, nopeus):
    kiihtyvyys = (random.uniform(-MaxKiihtyvyys, MaxKiihtyvyys),
                  random.uniform(-MaxKiihtyvyys, MaxKiihtyvyys))
    nopeus = reunat(paikka, dfdt(nopeus, kiihtyvyys))
    return nopeus

 #  matka = no­peus*aika


def dfdt(xy, dxdy):
    (x, y) = xy
    (dx, dy) = dxdy
    return (x + dx*Dt, y + dy*Dt)

def reunat(xy, vxvy):
    (vx, vy) = vxvy
    (x, y) = xy
    #  ei pääs­te­tä hyt­tys­tä reu­no­jen ulko­puo­lel­le
    if (x > Wx and vx > 0) or (x < 0 and vx < 0):
        vx = -vx
    elif (y > Wy and vy > 0) or (y < 0 and vy < 0):
        vy = -vy
    #  py­säy­te­tään hyt­ty­nen, mi­kä­li se len­tää tol­kut­to­man lujaa
    elif sqrt(vx**2 + vy**2) > Vmax:
        vx, vy = 0.0, 0.0
    return (vx, vy)

 #  # # # # # # # # # # # # # # # # # # # # # # # # # #
 #  Pää­oh­jel­ma alkaa tästä
 #  # # # # # # # # # # # # # # # # # # # # # # # # # #

 #  Luo­daan 'olio' tyyp­piä Cl_latka
Latka = Cl_Latka(Wx-50, Wy-50, 15)

 #  Luo­daan yksi hyt­ty­nen
hyttynen = Cl_Hyttynen(50, 50)

 #
 #  Tois­te­taan allaolevaa while-silmukkaa, kun­nes käyt­tä­jä sul­kee peli-ik­ku­nan
 #  tai pai­naa ESC-iä
 #
loppu = False
while not loppu:

    hyttynen.liiku_suoraan()

    hyttynen.liiku()

    hyttynen.piirra()

    #  näy­te­tään kaik­ki yllä 'piir­ret­ty' näy­töl­lä
    pygame.display.flip()
    #
    #  while sil­muk­ka päät­tyy tähän
 #
 #  Oh­jel­man loppu
pygame.quit()

# -*- coding: utf-8 -*-

# Tässä pelissä läiskitään ympäriinsä lenteleviä hyttysiä

import pygame
import random
from math import sqrt

Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Tausta = (160, 200, 255)

# Peli-ikkunan koko pikseleinä. Pikseli on piste näytöllä.
Wx = 800
Wy = 600
Wxy = (Wx, Wy)  # peli-ikkunan korkeus ja leveys

Nayttotaajuus = 24  # Voit kokeilla eri näyttötaajuuksia

Dt = 1.0/Nayttotaajuus

# Peliin liittyviä muuttujia.
VLatka = 200.0  # Lätkän nopeus

Vmax = 250.0
MaxKiihtyvyys = 400.0

# __init__(self, x, y, koko) on metodi, jolla lätkä luodaan

class Cl_Latka:
    def __init__(self, x, y, koko):
        self.paikka = (x, y)
        self.koko = koko
        self.color = Vihr
        self.liikkuu = False

    def piirra(self):
        (x, y) = self.paikka
        iPaikka = (int(x), int(y))
        pygame.draw.circle(screen, self.color, iPaikka, self.koko, 0)
        pygame.draw.circle(screen, Pun, iPaikka, int(self.koko/2), 0)

    def liiku(self, vxvy):
        (x, y) = self.paikka
        (vx, vy) = vxvy
        (x, y) = (x + vx*Dt, y + vy*Dt)
        # Lisäämällä tähän väliin muutaman if lauseen, voit korjata ohjelmaa
        #  niin, että Lätkä ei karkaa peli-ikkunan reunan ulkopuolelle
        # jos x on suurempi kuin niin Wx x.stä kannattaa vähentää Wx jne...
        self.paikka = (x, y)
        self.liikkuu = True

class Cl_Hyttynen:
    def __init__(self, x, y):
        self.paikka = (x, y)

        self.nopeus = (70.0, 50.0)  # kokeile tähän eri arvoja

        self.koko = 10
        self.color = (random.randint(0, 255),
                      random.randint(0, 255),
                      random.randint(0, 255))
        self.elossa = True

    def piirra(self):
        iPaikka = (int(self.paikka[0]), int(self.paikka[1]))
        iEllxy = (iPaikka[0], iPaikka[1], 4*self.koko, self.koko)
        if self.elossa:
            pygame.draw.circle(screen, self.color, iPaikka, self.koko, 0)
        else:
            pygame.draw.ellipse(screen, self.color, iEllxy, 0)

    def liiku(self):

        self.isku()  # Onko lätkä osunut?
        if self.elossa:
            self.nopeus = lenna(self.paikka, self.nopeus)

        else:
            self.nopeus = self.putoa()

# Siirrytään eteenpäin nopeus kertaa aikaväli
        self.paikka = dfdt(self.paikka, self.nopeus)

#   Jos Latka on lähellä tätä hyttystä sekä x- että y-suunnassa
#   lätkä osuu, hyttynen kuolee – litistyy ja muuttuu punaiseksi.
    def isku(self):
        if (etaisyys(self.paikka, Latka.paikka) < Latka.koko and
            Latka.liikkuu):
            self.elossa = False
            self.color = Pun

    def putoa(self):
        vx = random.uniform(-10, 10)
        if self.paikka[1] < Wy-self.koko:
            vy = random.uniform(20, 70)
        else:
            vx = 0
            vy = 0
        return (vx, vy)

def lenna(paikka, nopeus):
    kiihtyvyys = (random.uniform(-MaxKiihtyvyys, MaxKiihtyvyys),
                  random.uniform(-MaxKiihtyvyys, MaxKiihtyvyys))
    nopeus = reunat(paikka, dfdt(nopeus, kiihtyvyys))
    return nopeus
# matka = nopeus*aika
def dfdt(xy, dxdy):
    (x, y) = xy
    (dx, dy) = dxdy
    return (x + dx*Dt, y + dy*Dt)

def reunat(xy, vxvy):
    (vx, vy) = vxvy
    (x, y) = xy
    # ei päästetä hyttystä reunojen ulkopuolelle
    if (x > Wx and vx > 0) or (x < 0 and vx < 0):
        vx = -vx
    elif (y > Wy and vy > 0) or (y < 0 and vy < 0):
        vy = -vy
    # pysäytetään hyttynen, mikäli se lentää tolkuttoman lujaa
    elif sqrt(vx**2 + vy**2) > Vmax:
        vx, vy = 0.0, 0.0
    return (vx, vy)

# kahden pisteen p0 ja p1 välinen etäisyys xy-tasossa
def etaisyys(p0, p1):
    (x0, y0) = p0
    (x1, y1) = p1
    return sqrt((x1-x0)**2 + (y1-y0)**2)
# def ei_hyttysia(parvi):
#   for a in parvi:
#       if a.elossa:
#           return False
#   return True

# # # # # # # # # # # # # # # # # # # # # # # # # # #
# Pääohjelma alkaa tästä
# # # # # # # # # # # # # # # # # # # # # # # # # # #

pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä. Pikseli on piste näytöllä.
D_Info = pygame.display.Info()
Wx = D_Info.current_w
Wy = int(0.9*D_Info.current_h)
Wxy = (Wx, Wy)  # peli-ikkunan korkeus ja leveys

screen = pygame.display.set_mode((Wx, Wy))
pygame.display.set_caption(
    "Hyttysjahti")
pygame.init()
clock = pygame.time.Clock()
random.seed()

# Luodaan 'olio' tyyppiä Cl_latka
Latka = Cl_Latka(Wx-50, Wy-50, 15)

# Luodaan yksi hyttynen
hyttynen = Cl_Hyttynen(50, 50)

#
# Toistetaan allaolevaa while-silmukkaa, kunnes käyttäjä sulkee peli-ikkunan
# tai painaa ESC-iä
#
loppu = False
while not loppu:

    clock.tick(Nayttotaajuus)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            loppu = True
        if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
            loppu = True

    screen.fill(Tausta)

    hyttynen.liiku()

    hyttynen.piirra()

    Latka.liikkuu = False
#   Tarkistetaan, onko joku tai jotkin lätkää ohjaavista näppäimistä
# painettuna. Liikutetaan lätkää vastaavasti.
    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_UP]:
        Latka.liiku((0.0, -VLatka))  # ylös
    if pressed[pygame.K_DOWN]:
        Latka.liiku((0.0, VLatka))  # alas
    if pressed[pygame.K_z]:
        Latka.liiku((-VLatka, 0.0))  # vasemmalle
    if pressed[pygame.K_x]:
        Latka.liiku((VLatka, 0.0))  # oikealle
    # Piirretään lätkä uudelle paikalleen
    Latka.piirra()

    # näytetään kaikki yllä 'piirretty' näytöllä
    pygame.display.flip()
    #
    # while silmukka päättyy tähän
#
# Ohjelman loppu
pygame.quit()

import pygame
import random
from math import sqrt

Nayttotaajuus = 24  #  Voit ko­keil­la eri näyt­tö­taa­juuk­sia

        self.isku()  #  Onko lätkä osu­nut?
        if self.elossa:
            self.nopeus = lenna(self.paikka, self.nopeus)

        else:
            self.nopeus = self.putoa()

 #    Jos Latka on lä­hel­lä tätä hyt­tys­tä sekä x- että y-suun­nas­sa
 #    lätkä osuu, hyt­ty­nen kuo­lee – li­tis­tyy ja muut­tuu pu­nai­sek­si.
    def isku(self):
        if (etaisyys(self.paikka, Latka.paikka) < Latka.koko and
            Latka.liikkuu):
            self.elossa = False
            self.color = Pun

    def putoa(self):
        vx = random.uniform(-10, 10)
        if self.paikka[1] < Wy-self.koko:
            vy = random.uniform(20, 70)
        else:
            vx = 0
            vy = 0
        return (vx, vy)

 #  kah­den pis­teen p0 ja p1 vä­li­nen etäi­syys xy-tasossa


def etaisyys(p0, p1):
    (x0, y0) = p0
    (x1, y1) = p1
    return sqrt((x1-x0)**2 + (y1-y0)**2)

 #  def ei_hyttysia(parvi):
 #    for a in parvi:
 #        if a.elossa:
 #            return False
 #    return True

 #  # # # # # # # # # # # # # # # # # # # # # # # # # #
 #  Pää­oh­jel­ma alkaa tästä
 #  # # # # # # # # # # # # # # # # # # # # # # # # # #

 #  Luo­daan 'olio' tyyp­piä Cl_latka
Latka = Cl_Latka(Wx-50, Wy-50, 15)

 #  Luo­daan yksi hyt­ty­nen
hyttynen = Cl_Hyttynen(50, 50)

 #
 #  Tois­te­taan allaolevaa while-silmukkaa, kun­nes käyt­tä­jä sul­kee peli-ik­ku­nan
 #  tai pai­naa ESC-iä
 #
loppu = False
while not loppu:

    hyttynen.liiku()

    hyttynen.piirra()

    #  näy­te­tään kaik­ki yllä 'piir­ret­ty' näy­töl­lä
    pygame.display.flip()
    #
    #  while sil­muk­ka päät­tyy tähän
 #
 #  Oh­jel­man loppu
pygame.quit()

# -*- coding: utf-8 -*-

# Tässä pelissä läiskitään ympäriinsä lenteleviä hyttysiä

import pygame
import random
from math import sqrt

Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Tausta = (160, 200, 255)

# Peli-ikkunan koko pikseleinä. Pikseli on piste näytöllä.
Wx = 800
Wy = 600
Wxy = (Wx, Wy)  # peli-ikkunan korkeus ja leveys

Nayttotaajuus = 24  # Voit kokeilla eri näyttötaajuuksia

Dt = 1.0/Nayttotaajuus

# Peliin liittyviä muuttujia.
VLatka = 200.0  # Lätkän nopeus

Vmax = 250.0
MaxKiihtyvyys = 400.0

N_hyttyset = 100

# __init__(self, x, y, koko) on metodi, jolla lätkä luodaan

class Cl_Latka:
    def __init__(self, x, y, koko):
        self.paikka = (x, y)
        self.koko = koko
        self.color = Vihr
        self.liikkuu = False

    def piirra(self):
        (x, y) = self.paikka
        iPaikka = (int(x), int(y))
        pygame.draw.circle(screen, self.color, iPaikka, self.koko, 0)
        pygame.draw.circle(screen, Pun, iPaikka, int(self.koko/2), 0)

    def liiku(self, vxvy):
        (x, y) = self.paikka
        (vx, vy) = vxvy
        (x, y) = (x + vx*Dt, y + vy*Dt)
        # Lisäämällä tähän väliin muutaman if lauseen, voit korjata ohjelmaa
        #  niin, että Lätkä ei karkaa peli-ikkunan reunan ulkopuolelle
        # jos x on suurempi kuin niin Wx x.stä kannattaa vähentää Wx jne...
        self.paikka = (x, y)
        self.liikkuu = True

class Cl_Hyttynen:
    def __init__(self, x, y):
        self.paikka = (x, y)

        self.nopeus = (70.0, 50.0)  # kokeile tähän eri arvoja

        self.koko = 10
        self.color = (random.randint(0, 255),
                      random.randint(0, 255),
                      random.randint(0, 255))
        self.elossa = True

    def piirra(self):
        iPaikka = (int(self.paikka[0]), int(self.paikka[1]))
        iEllxy = (iPaikka[0], iPaikka[1], 4*self.koko, self.koko)
        if self.elossa:
            pygame.draw.circle(screen, self.color, iPaikka, self.koko, 0)
        else:
            pygame.draw.ellipse(screen, self.color, iEllxy, 0)

    def liiku(self):

        self.isku()  # Onko lätkä osunut?
        if self.elossa:
            self.nopeus = lenna(self.paikka, self.nopeus)

        else:
            self.nopeus = self.putoa()

# Siirrytään eteenpäin nopeus kertaa aikaväli
        self.paikka = dfdt(self.paikka, self.nopeus)

#   Jos Latka on lähellä tätä hyttystä sekä x- että y-suunnassa
#   lätkä osuu, hyttynen kuolee – litistyy ja muuttuu punaiseksi.
    def isku(self):
        if (etaisyys(self.paikka, Latka.paikka) < Latka.koko and
            Latka.liikkuu):
            self.elossa = False
            self.color = Pun

    def putoa(self):
        vx = random.uniform(-10, 10)
        if self.paikka[1] < Wy-self.koko:
            vy = random.uniform(20, 70)
        else:
            vx = 0
            vy = 0
        return (vx, vy)

def lenna(paikka, nopeus):
    kiihtyvyys = (random.uniform(-MaxKiihtyvyys, MaxKiihtyvyys),
                  random.uniform(-MaxKiihtyvyys, MaxKiihtyvyys))
    nopeus = reunat(paikka, dfdt(nopeus, kiihtyvyys))
    return nopeus
# matka = nopeus*aika
def dfdt(xy, dxdy):
    (x, y) = xy
    (dx, dy) = dxdy
    return (x + dx*Dt, y + dy*Dt)

def reunat(xy, vxvy):
    (vx, vy) = vxvy
    (x, y) = xy
    # ei päästetä hyttystä reunojen ulkopuolelle
    if (x > Wx and vx > 0) or (x < 0 and vx < 0):
        vx = -vx
    elif (y > Wy and vy > 0) or (y < 0 and vy < 0):
        vy = -vy
    # pysäytetään hyttynen, mikäli se lentää tolkuttoman lujaa
    elif sqrt(vx**2 + vy**2) > Vmax:
        vx, vy = 0.0, 0.0
    return (vx, vy)

# kahden pisteen p0 ja p1 välinen etäisyys xy-tasossa
def etaisyys(p0, p1):
    (x0, y0) = p0
    (x1, y1) = p1
    return sqrt((x1-x0)**2 + (y1-y0)**2)
# def ei_hyttysia(parvi):
#   for a in parvi:
#       if a.elossa:
#           return False
#   return True

# # # # # # # # # # # # # # # # # # # # # # # # # # #
# Pääohjelma alkaa tästä
# # # # # # # # # # # # # # # # # # # # # # # # # # #

pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä. Pikseli on piste näytöllä.
D_Info = pygame.display.Info()
Wx = D_Info.current_w
Wy = int(0.9*D_Info.current_h)
Wxy = (Wx, Wy)  # peli-ikkunan korkeus ja leveys

screen = pygame.display.set_mode((Wx, Wy))
pygame.display.set_caption(
    "Hyttysjahti")
pygame.init()
clock = pygame.time.Clock()
random.seed()

# Luodaan 'olio' tyyppiä Cl_latka
Latka = Cl_Latka(Wx-50, Wy-50, 15)

# Luodaan yksi hyttynen
hyttynen = Cl_Hyttynen(50, 50)

hyttyset = list(range(N_hyttyset))
for i in range(N_hyttyset):
    hyttyset[i] = Cl_Hyttynen(50, 50)

#
# Toistetaan allaolevaa while-silmukkaa, kunnes käyttäjä sulkee peli-ikkunan
# tai painaa ESC-iä
#
loppu = False
while not loppu:

    clock.tick(Nayttotaajuus)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            loppu = True
        if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
            loppu = True

    screen.fill(Tausta)

    hyttynen.liiku()

    hyttynen.piirra()

#  Lasketaan hyttysille uudet paikat ja piiretään ne
    for i in range(N_hyttyset):
        hyttyset[i].liiku()
        hyttyset[i].piirra()

    Latka.liikkuu = False
#   Tarkistetaan, onko joku tai jotkin lätkää ohjaavista näppäimistä
# painettuna. Liikutetaan lätkää vastaavasti.
    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_UP]:
        Latka.liiku((0.0, -VLatka))  # ylös
    if pressed[pygame.K_DOWN]:
        Latka.liiku((0.0, VLatka))  # alas
    if pressed[pygame.K_z]:
        Latka.liiku((-VLatka, 0.0))  # vasemmalle
    if pressed[pygame.K_x]:
        Latka.liiku((VLatka, 0.0))  # oikealle
    # Piirretään lätkä uudelle paikalleen
    Latka.piirra()

    # näytetään kaikki yllä 'piirretty' näytöllä
    pygame.display.flip()
    #
    # while silmukka päättyy tähän
#
# Ohjelman loppu
pygame.quit()

import pygame
import random
from math import sqrt

Nayttotaajuus = 24  #  Voit ko­keil­la eri näyt­tö­taa­juuk­sia

 #  Pe­liin liit­ty­viä muut­tu­jia.
VLatka = 200.0  #  Lät­kän no­peus

Vmax = 250.0
MaxKiihtyvyys = 400.0

N_hyttyset = 100

 #  # # # # # # # # # # # # # # # # # # # # # # # # # #
 #  Pää­oh­jel­ma alkaa tästä
 #  # # # # # # # # # # # # # # # # # # # # # # # # # #

 #  Luo­daan 'olio' tyyp­piä Cl_latka
Latka = Cl_Latka(Wx-50, Wy-50, 15)

 #  Luo­daan yksi hyt­ty­nen
hyttynen = Cl_Hyttynen(50, 50)

hyttyset = list(range(N_hyttyset))
for i in range(N_hyttyset):
    hyttyset[i] = Cl_Hyttynen(50, 50)

 #
 #  Tois­te­taan allaolevaa while-silmukkaa, kun­nes käyt­tä­jä sul­kee peli-ik­ku­nan
 #  tai pai­naa ESC-iä
 #
loppu = False
while not loppu:

    hyttynen.liiku()

    hyttynen.piirra()

 #   Las­ke­taan hyt­ty­sil­le uudet pai­kat ja piiretään ne
    for i in range(N_hyttyset):
        hyttyset[i].liiku()
        hyttyset[i].piirra()

    #  näy­te­tään kaik­ki yllä 'piir­ret­ty' näy­töl­lä
    pygame.display.flip()
    #
    #  while sil­muk­ka päät­tyy tähän
 #
 #  Oh­jel­man loppu
pygame.quit()

# -*- coding: utf-8 -*-
import pygame
import random
from math import pi, cos, sin, sqrt
Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Kelt = (255, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Tausta = (160, 200, 255)
MaastoVari = (95, 95, 20)

# Peli-ikkuna päivitetään Nayttotaajuus kertaa sekunnissa
Nayttotaajuus = 48

# Tällä tykin säätö saadaan jouhevaksi kaikilla näyttötaajuuksilla
saatoaskel = 48.0/Nayttotaajuus

# Nopeutus = 1.0 ->  oikea "filmin" nopeus
Nopeutus = 5

g_maa = 9.81  # putoamiskiihtyvyys
RKuula = 0.1  # kuulan säde metreinä

# Lasketaan, mihin tietty pelimaailman piste kuuluu peli-ikkunassa
def xy_ruudulla(xmaasto, ymaasto):
    xpikseli = int(xmaasto*scale)
    ypikseli = int(Wy-ymaasto*scale)
    return (xpikseli, ypikseli)

def xy_skaalaus(w, h):
    xpikseli = int(w*scale)
    ypikseli = int(h*scale)
    return (xpikseli, ypikseli)

def r_xy(kulma, r):
    return (r*cos(kulma), r*sin(kulma))

def kuulanMassa(tiheys):
    VKuula = 4/3*pi*RKuula**3
    return tiheys*VKuula

def kiihtyvyys0():
    ax = 0.0
    ay = -g_maa
    return (ax, ay)

# Vuori ja "tuuliviiri"
class Cl_vuori:
    def __init__(self):
        self.x1 = random.uniform(0.3*Wxmaasto, 0.6*Wxmaasto)
        self.leveys = 0.1*Wxmaasto
        self.h = random.uniform(0.0, 0.6*Wymaasto)
    def piirra(self):
        # Vuori
        (a, b) = xy_ruudulla(self.x1, self.h)
        (w, h) = xy_skaalaus(self.leveys, self.h)
        pygame.draw.rect(screen, MaastoVari, (a, b, w, h), 0)

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Morssari
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_morssari:
    def __init__(self):
        self.x = 0.05*Wxmaasto
        self.y = 0.01*Wymaasto
        (w, h) = xy_skaalaus(0.05*Wxmaasto, 0.03*Wymaasto)
        self.w = w
        self.h = h
        self.ruuti = 1.0
        self.KuulanTiheys = 5000.0
        self.kuulanVari = Sin
        self.latausaika = Nayttotaajuus
        self.kulma = pi/7.0  # piipun asento
        self.p1x = 0.0  # piipun pään x-koordinaatti
        self.p1y = 0.0  # piipun pään y-koordinaatti
        self.vaunu = pygame.Rect(0, 0, w, h)

    def piirra(self):
        (x, y) = xy_ruudulla(self.x, self.y)
        # piirretään mörssärin piippu
        (sx, sy) = r_xy(self.kulma, 200.0)
        self.p1x = self.x + sx
        self.p1y = self.y + sy
        if self.latausaika > 0:
            self.latausaika = self.latausaika - 1
            vari = Musta
        else:
            vari = Pun
        pygame.draw.line(screen, vari, (x, y),
                         xy_ruudulla(self.p1x, self.p1y), 10)
        # Ajopanosten ruutimäärän osoitin
        pygame.draw.line(screen, Sin, (10, Wy),
                         (10, Wy-int(self.ruuti/12.0*Wy)), 8)
        # vaunu
        self.vaunu.center = (x-self.w/4, y)
        pygame.draw.ellipse(screen, Musta, self.vaunu, 0)

    # Vaunun liikuttelua z ja x näppäimillä.
    # Vaunulla ei pääse vuoren läpi ;-)
    def liiku_x(self, dx):
        self.x = self.x + dx
        if self.x > vuori.x1:
            self.x = 0.0

# num+ ja num- näppäimillä kutsutaan tätä metodia
    def add_ruuti(self, m):
        self.ruuti = min(11.0, max(1.0, self.ruuti + 0.5*m))

# num-1, num-2 ja num-3 näppäimillä valitaan kuulan tyyppi
    def valitseKuula(self, tyyppi):
        if tyyppi ==  'puu':
            self.KuulanTiheys = 1000.0
            self.kuulanVari = Kelt
        elif tyyppi ==  'rauta':
            self.KuulanTiheys = 5000.0
            self.kuulanVari = Sin
        elif tyyppi ==  'lyijy':
            self.KuulanTiheys = 12000.0
            self.kuulanVari = Musta

# Käännetään piippua nuolinäppäimillä
    def asento(self, dkulma):
        self.kulma = self.kulma + dkulma

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Pääohjelma alkaa tästä
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
print("alku")
pygame.init()

pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä
D_Info = pygame.display.Info()
Wx = D_Info.current_w
Wy = int(0.9*D_Info.current_h)
# pelimaailman leveys "metreinä"
Wxmaasto = 5000.0
scale = Wx/Wxmaasto
# Korkeus pelimaailmassa
Wymaasto = Wy/scale
screen = pygame.display.set_mode((Wx, Wy))
pygame.display.set_caption(
    "Morssari")
clock = pygame.time.Clock()
random.seed()
screen.fill(Tausta)
# Luodaan mörssäri ja vuori
vuori = Cl_vuori()
morssari = Cl_morssari()
kuulat = []

loppu = False
MuistaVanhat = False
while not loppu:
    clock.tick(Nayttotaajuus)
    if not MuistaVanhat:
        screen.fill(Tausta)
    for event in pygame.event.get():
        # Lopetetaan peli sulkemalla ikkuna tai painamalla ESC
        if event.type ==  pygame.QUIT:
            loppu = True
        if event.type ==  pygame.KEYDOWN:
            if event.key ==  pygame.K_ESCAPE:
                loppu = True
            # Pyyhitäänkö peli-ikkuna puhtaaksi joka kierroksella vai ei
            if event.key ==  pygame.K_F1:
                MuistaVanhat = not MuistaVanhat
            # säädellään ajopanoksen ruutimäärää
            if event.key ==  pygame.K_KP_PLUS:
                morssari.add_ruuti(1)
            if event.key ==  pygame.K_KP_MINUS:
                morssari.add_ruuti(-1)
            # valitaan kuulan tyyppi
            if event.key ==  pygame.K_KP1:
                morssari.valitseKuula('puu')
            if event.key ==  pygame.K_KP2:
                morssari.valitseKuula('rauta')
            if event.key ==  pygame.K_KP3:
                morssari.valitseKuula('lyijy')
    # Suunnataan ja siirrellään mörssäriä
    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_UP]:
        morssari.asento(0.005*saatoaskel)
    if pressed[pygame.K_DOWN]:
        morssari.asento(-0.005*saatoaskel)
    if pressed[pygame.K_x]:
        morssari.liiku_x(saatoaskel)
    if pressed[pygame.K_z]:
        morssari.liiku_x(-saatoaskel)

    # Piirretään kaikki oliot peli-ikkunaan ja lasketaan kuulille ja
    # sirpaleille uudet paikat peli-ikkunassa
    morssari.piirra()
    vuori.piirra()

    pygame.display.flip()
    # while silmukka päättyy tähän
pygame.quit()

 #  Peli-ik­ku­na päi­vi­te­tään Nayttotaajuus ker­taa se­kun­nis­sa
Nayttotaajuus = 48

 #  Tällä tykin säätö saa­daan jou­he­vak­si kai­kil­la näyt­tö­taa­juuk­sil­la
saatoaskel = 48.0/Nayttotaajuus

 #  No­peu­tus = 1.0 ->  oikea "fil­min" no­peus
Nopeutus = 5

g_maa = 9.81  #  pu­toa­mis­kiih­ty­vyys
RKuula = 0.1  #  kuu­lan säde met­rei­nä

 #  Las­ke­taan, mihin tiet­ty peli­maailman piste kuu­luu peli-ik­ku­nas­sa
def xy_ruudulla(xmaasto, ymaasto):
    xpikseli = int(xmaasto*scale)
    ypikseli = int(Wy-ymaasto*scale)
    return (xpikseli, ypikseli)

def xy_skaalaus(w, h):
    xpikseli = int(w*scale)
    ypikseli = int(h*scale)
    return (xpikseli, ypikseli)

def r_xy(kulma, r):
    return (r*cos(kulma), r*sin(kulma))

def kuulanMassa(tiheys):
    VKuula = 4/3*pi*RKuula**3
    return tiheys*VKuula

def kiihtyvyys0():
    ax = 0.0
    ay = -g_maa
    return (ax, ay)

 #  Vuori ja "tuuli­viiri"
class Cl_vuori:
    def __init__(self):
        self.x1 = random.uniform(0.3*Wxmaasto, 0.6*Wxmaasto)
        self.leveys = 0.1*Wxmaasto
        self.h = random.uniform(0.0, 0.6*Wymaasto)

    def piirra(self):
        #  Vuori
        (a, b) = xy_ruudulla(self.x1, self.h)
        (w, h) = xy_skaalaus(self.leveys, self.h)
        pygame.draw.rect(screen, MaastoVari, (a, b, w, h), 0)

 #  = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
 #  Morssari
 #  = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_morssari:
    def __init__(self):
        self.x = 0.05*Wxmaasto
        self.y = 0.01*Wymaasto
        (w, h) = xy_skaalaus(0.05*Wxmaasto, 0.03*Wymaasto)
        self.w = w
        self.h = h
        self.ruuti = 1.0
        self.KuulanTiheys = 5000.0
        self.kuulanVari = Sin
        self.latausaika = Nayttotaajuus
        self.kulma = pi/7.0  #  pii­pun asen­to
        self.p1x = 0.0  #  pii­pun pään x-koor­di­naat­ti
        self.p1y = 0.0  #  pii­pun pään y-koor­di­naat­ti
        self.vaunu = pygame.Rect(0, 0, w, h)

    def piirra(self):
        (x, y) = xy_ruudulla(self.x, self.y)
        #  piir­re­tään mörs­sä­rin piip­pu
        (sx, sy) = r_xy(self.kulma, 200.0)
        self.p1x = self.x + sx
        self.p1y = self.y + sy
        if self.latausaika > 0:
            self.latausaika = self.latausaika - 1
            vari = Musta
        else:
            vari = Pun
        pygame.draw.line(screen, vari, (x, y),
                         xy_ruudulla(self.p1x, self.p1y), 10)
        #  Ajo­pa­nos­ten ruuti­mää­rän osoi­tin
        pygame.draw.line(screen, Sin, (10, Wy),
                         (10, Wy-int(self.ruuti/12.0*Wy)), 8)
        #  vaunu
        self.vaunu.center = (x-self.w/4, y)
        pygame.draw.ellipse(screen, Musta, self.vaunu, 0)

    #  Vau­nun lii­kut­te­lua z ja x näp­päi­mil­lä.
    #  Vau­nul­la ei pääse vuo­ren läpi ;-)
    def liiku_x(self, dx):
        self.x = self.x + dx
        if self.x > vuori.x1:
            self.x = 0.0

 #  num+ ja num- näp­päi­mil­lä kut­su­taan tätä me­to­dia
    def add_ruuti(self, m):
        self.ruuti = min(11.0, max(1.0, self.ruuti + 0.5*m))

 #  num-1, num-2 ja num-3 näp­päi­mil­lä va­li­taan kuu­lan tyyp­pi
    def valitseKuula(self, tyyppi):
        if tyyppi ==  'puu':
            self.KuulanTiheys = 1000.0
            self.kuulanVari = Kelt
        elif tyyppi ==  'rauta':
            self.KuulanTiheys = 5000.0
            self.kuulanVari = Sin
        elif tyyppi ==  'lyijy':
            self.KuulanTiheys = 12000.0
            self.kuulanVari = Musta

 #  Kään­ne­tään piip­pua nuoli­näp­päi­mil­lä
    def asento(self, dkulma):
        self.kulma = self.kulma + dkulma

 #  = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
 #  Pää­oh­jel­ma alkaa tästä
 #  = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

print("alku")
pygame.init()

    #  Piir­re­tään kaik­ki oliot peli-ik­ku­naan ja las­ke­taan kuu­lil­le ja
    #  sir­pa­leil­le uudet pai­kat peli-ik­ku­nas­sa
    morssari.piirra()
    vuori.piirra()

    pygame.display.flip()
    #  while sil­muk­ka päät­tyy tähän

pygame.quit()

# -*- coding: utf-8 -*-
import pygame
import random
from math import pi, cos, sin, sqrt
Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Kelt = (255, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Tausta = (160, 200, 255)
MaastoVari = (95, 95, 20)

# Peli-ikkuna päivitetään Nayttotaajuus kertaa sekunnissa
Nayttotaajuus = 48

# Tällä tykin säätö saadaan jouhevaksi kaikilla näyttötaajuuksilla
saatoaskel = 48.0/Nayttotaajuus

# Nopeutus = 1.0 ->  oikea "filmin" nopeus
Nopeutus = 5

g_maa = 9.81  # putoamiskiihtyvyys
RKuula = 0.1  # kuulan säde metreinä

# Lasketaan, mihin tietty pelimaailman piste kuuluu peli-ikkunassa
def xy_ruudulla(xmaasto, ymaasto):
    xpikseli = int(xmaasto*scale)
    ypikseli = int(Wy-ymaasto*scale)
    return (xpikseli, ypikseli)

def xy_skaalaus(w, h):
    xpikseli = int(w*scale)
    ypikseli = int(h*scale)
    return (xpikseli, ypikseli)

def r_xy(kulma, r):
    return (r*cos(kulma), r*sin(kulma))

def kuulanMassa(tiheys):
    VKuula = 4/3*pi*RKuula**3
    return tiheys*VKuula

def kiihtyvyys0():
    ax = 0.0
    ay = -g_maa
    return (ax, ay)

# Siirtymä ja nopeuden muutos ajassa dt
def integ_euler(x, y, vx, vy, A, M):
    dt = 1.0/Nayttotaajuus
    for i in range(Nopeutus):

        (ax, ay) = kiihtyvyys0()

        (x, y, vx, vy) = (x + vx*dt, y + vy*dt, vx + ax*dt, vy + ay*dt)
    return (x, y, vx, vy)

# Vuori ja "tuuliviiri"
class Cl_vuori:
    def __init__(self):
        self.x1 = random.uniform(0.3*Wxmaasto, 0.6*Wxmaasto)
        self.leveys = 0.1*Wxmaasto
        self.h = random.uniform(0.0, 0.6*Wymaasto)
    def piirra(self):
        # Vuori
        (a, b) = xy_ruudulla(self.x1, self.h)
        (w, h) = xy_skaalaus(self.leveys, self.h)
        pygame.draw.rect(screen, MaastoVari, (a, b, w, h), 0)

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Morssari
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_morssari:
    def __init__(self):
        self.x = 0.05*Wxmaasto
        self.y = 0.01*Wymaasto
        (w, h) = xy_skaalaus(0.05*Wxmaasto, 0.03*Wymaasto)
        self.w = w
        self.h = h
        self.ruuti = 1.0
        self.KuulanTiheys = 5000.0
        self.kuulanVari = Sin
        self.latausaika = Nayttotaajuus
        self.kulma = pi/7.0  # piipun asento
        self.p1x = 0.0  # piipun pään x-koordinaatti
        self.p1y = 0.0  # piipun pään y-koordinaatti
        self.vaunu = pygame.Rect(0, 0, w, h)

    def piirra(self):
        (x, y) = xy_ruudulla(self.x, self.y)
        # piirretään mörssärin piippu
        (sx, sy) = r_xy(self.kulma, 200.0)
        self.p1x = self.x + sx
        self.p1y = self.y + sy
        if self.latausaika > 0:
            self.latausaika = self.latausaika - 1
            vari = Musta
        else:
            vari = Pun
        pygame.draw.line(screen, vari, (x, y),
                         xy_ruudulla(self.p1x, self.p1y), 10)
        # Ajopanosten ruutimäärän osoitin
        pygame.draw.line(screen, Sin, (10, Wy),
                         (10, Wy-int(self.ruuti/12.0*Wy)), 8)
        # vaunu
        self.vaunu.center = (x-self.w/4, y)
        pygame.draw.ellipse(screen, Musta, self.vaunu, 0)

    # Vaunun liikuttelua z ja x näppäimillä.
    # Vaunulla ei pääse vuoren läpi ;-)
    def liiku_x(self, dx):
        self.x = self.x + dx
        if self.x > vuori.x1:
            self.x = 0.0

# num+ ja num- näppäimillä kutsutaan tätä metodia
    def add_ruuti(self, m):
        self.ruuti = min(11.0, max(1.0, self.ruuti + 0.5*m))

# num-1, num-2 ja num-3 näppäimillä valitaan kuulan tyyppi
    def valitseKuula(self, tyyppi):
        if tyyppi ==  'puu':
            self.KuulanTiheys = 1000.0
            self.kuulanVari = Kelt
        elif tyyppi ==  'rauta':
            self.KuulanTiheys = 5000.0
            self.kuulanVari = Sin
        elif tyyppi ==  'lyijy':
            self.KuulanTiheys = 12000.0
            self.kuulanVari = Musta

# Käännetään piippua nuolinäppäimillä
    def asento(self, dkulma):
        self.kulma = self.kulma + dkulma

# laukaistaan mörssäri välilyöntinäppäimellä
    def ammu(self):

        self.latausaika = random.randint(Nayttotaajuus/2, 2*Nayttotaajuus)
        M = kuulanMassa(self.KuulanTiheys)
        (vx, vy) = self.kuulan_alkunopeus(M)
        return Cl_ammus(self.p1x, self.p1y, vx, vy, M, self.kuulanVari)

    def kuulan_alkunopeus(self, M):
        Cv0 = 600.0
        v0 = Cv0*sqrt(self.ruuti/M)
        print("ruuti: {:2.1f}".format(self.ruuti),
              "kulma: {:2.1f}".format(self.kulma*180.0/pi),
              "massa: {:4.1f}".format(M),
              "nopeus: {:4.0f}".format(v0))
        return (v0*cos(self.kulma),
                v0*sin(self.kulma))

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Ammus
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_ammus:
    def __init__(self, x, y, vx, vy, M, vari):
        self.x = x
        self.y = y
        self.vx = vx
        self.vy = vy
        self.M = M  # kg/m**3
        self.A = pi*RKuula**2
        self.vari = vari

    def piirra0(self):
        pygame.draw.circle(screen, self.vari,
                           xy_ruudulla(self.x, self.y), 5, 0)

    def liiku0(self):
        (self.x, self.y, self.vx, self.vy) = integ_euler(
            self.x, self.y, self.vx, self.vy, self.A, self.M)

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Pääohjelma alkaa tästä
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
print("alku")
pygame.init()

pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä
D_Info = pygame.display.Info()
Wx = D_Info.current_w
Wy = int(0.9*D_Info.current_h)
# pelimaailman leveys "metreinä"
Wxmaasto = 5000.0
scale = Wx/Wxmaasto
# Korkeus pelimaailmassa
Wymaasto = Wy/scale
screen = pygame.display.set_mode((Wx, Wy))
pygame.display.set_caption(
    "Morssari")
clock = pygame.time.Clock()
random.seed()
screen.fill(Tausta)
# Luodaan mörssäri ja vuori
vuori = Cl_vuori()
morssari = Cl_morssari()
kuulat = []

loppu = False
MuistaVanhat = False
while not loppu:
    clock.tick(Nayttotaajuus)
    if not MuistaVanhat:
        screen.fill(Tausta)
    for event in pygame.event.get():
        # Lopetetaan peli sulkemalla ikkuna tai painamalla ESC
        if event.type ==  pygame.QUIT:
            loppu = True
        if event.type ==  pygame.KEYDOWN:
            if event.key ==  pygame.K_ESCAPE:
                loppu = True
            # Pyyhitäänkö peli-ikkuna puhtaaksi joka kierroksella vai ei
            if event.key ==  pygame.K_F1:
                MuistaVanhat = not MuistaVanhat
            # säädellään ajopanoksen ruutimäärää
            if event.key ==  pygame.K_KP_PLUS:
                morssari.add_ruuti(1)
            if event.key ==  pygame.K_KP_MINUS:
                morssari.add_ruuti(-1)
            # valitaan kuulan tyyppi
            if event.key ==  pygame.K_KP1:
                morssari.valitseKuula('puu')
            if event.key ==  pygame.K_KP2:
                morssari.valitseKuula('rauta')
            if event.key ==  pygame.K_KP3:
                morssari.valitseKuula('lyijy')
    # Suunnataan ja siirrellään mörssäriä
    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_UP]:
        morssari.asento(0.005*saatoaskel)
    if pressed[pygame.K_DOWN]:
        morssari.asento(-0.005*saatoaskel)
    if pressed[pygame.K_x]:
        morssari.liiku_x(saatoaskel)
    if pressed[pygame.K_z]:
        morssari.liiku_x(-saatoaskel)

    # Laukaistaan mörssäri
    if pressed[pygame.K_SPACE] and morssari.latausaika ==  0:
        kuulat.append(morssari.ammu())

    # Piirretään kaikki oliot peli-ikkunaan ja lasketaan kuulille ja
    # sirpaleille uudet paikat peli-ikkunassa
    morssari.piirra()
    vuori.piirra()

#    if not kuulat =  []:
#        for kuula in kuulat:

#            kuula.liiku0()
#            kuula.piirra0()

    if not kuulat ==  []:
        for k, kuula in enumerate(kuulat):

            kuula.liiku0()
            kuula.piirra0()

    pygame.display.flip()
    # while silmukka päättyy tähän
pygame.quit()

 #  Siir­ty­mä ja no­peu­den muu­tos ajas­sa dt
def integ_euler(x, y, vx, vy, A, M):
    dt = 1.0/Nayttotaajuus
    for i in range(Nopeutus):

        (ax, ay) = kiihtyvyys0()

        (x, y, vx, vy) = (x + vx*dt, y + vy*dt, vx + ax*dt, vy + ay*dt)
    return (x, y, vx, vy)

 #  lau­kais­taan mörs­sä­ri väli­lyön­ti­näp­päi­mel­lä
    def ammu(self):

        self.latausaika = random.randint(Nayttotaajuus/2, 2*Nayttotaajuus)
        M = kuulanMassa(self.KuulanTiheys)
        (vx, vy) = self.kuulan_alkunopeus(M)
        return Cl_ammus(self.p1x, self.p1y, vx, vy, M, self.kuulanVari)

    def kuulan_alkunopeus(self, M):
        Cv0 = 600.0
        v0 = Cv0*sqrt(self.ruuti/M)
        print("ruuti: {:2.1f}".format(self.ruuti),
              "kulma: {:2.1f}".format(self.kulma*180.0/pi),
              "massa: {:4.1f}".format(M),
              "nopeus: {:4.0f}".format(v0))
        return (v0*cos(self.kulma),
                v0*sin(self.kulma))

 #  = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
 #  Ammus
 #  = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_ammus:
    def __init__(self, x, y, vx, vy, M, vari):
        self.x = x
        self.y = y
        self.vx = vx
        self.vy = vy
        self.M = M  #  kg/m**3
        self.A = pi*RKuula**2
        self.vari = vari

    def piirra0(self):
        pygame.draw.circle(screen, self.vari,
                           xy_ruudulla(self.x, self.y), 5, 0)

    def liiku0(self):
        (self.x, self.y, self.vx, self.vy) = integ_euler(
            self.x, self.y, self.vx, self.vy, self.A, self.M)

    #  Lau­kais­taan mörs­sä­ri
    if pressed[pygame.K_SPACE] and morssari.latausaika ==  0:
        kuulat.append(morssari.ammu())

 #     if not kuu­lat =  []:
 #         for kuula in kuu­lat:

 #             kuula.liiku0()
 #             kuula.piirra0()

    if not kuulat ==  []:
        for k, kuula in enumerate(kuulat):

            kuula.liiku0()
            kuula.piirra0()

# -*- coding: utf-8 -*-
import pygame
import random
from math import pi, cos, sin, sqrt
Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Kelt = (255, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Tausta = (160, 200, 255)
MaastoVari = (95, 95, 20)

# Peli-ikkuna päivitetään Nayttotaajuus kertaa sekunnissa
Nayttotaajuus = 48

# Tällä tykin säätö saadaan jouhevaksi kaikilla näyttötaajuuksilla
saatoaskel = 48.0/Nayttotaajuus

# Nopeutus = 1.0 ->  oikea "filmin" nopeus
Nopeutus = 5

Tuuli = random.uniform(-50.0, 50.0)
# Tuuli = -50.0

g_maa = 9.81  # putoamiskiihtyvyys
RKuula = 0.1  # kuulan säde metreinä

# Lasketaan, mihin tietty pelimaailman piste kuuluu peli-ikkunassa
def xy_ruudulla(xmaasto, ymaasto):
    xpikseli = int(xmaasto*scale)
    ypikseli = int(Wy-ymaasto*scale)
    return (xpikseli, ypikseli)

def xy_skaalaus(w, h):
    xpikseli = int(w*scale)
    ypikseli = int(h*scale)
    return (xpikseli, ypikseli)

def r_xy(kulma, r):
    return (r*cos(kulma), r*sin(kulma))

def kuulanMassa(tiheys):
    VKuula = 4/3*pi*RKuula**3
    return tiheys*VKuula

def kiihtyvyys0():
    ax = 0.0
    ay = -g_maa
    return (ax, ay)

# Siirtymä ja nopeuden muutos ajassa dt
def integ_euler(x, y, vx, vy, A, M):
    dt = 1.0/Nayttotaajuus
    for i in range(Nopeutus):

        (ax, ay) = kiihtyvyys0()

        (x, y, vx, vy) = (x + vx*dt, y + vy*dt, vx + ax*dt, vy + ay*dt)
    return (x, y, vx, vy)

# Vuori ja "tuuliviiri"
class Cl_vuori:
    def __init__(self):
        self.x1 = random.uniform(0.3*Wxmaasto, 0.6*Wxmaasto)
        self.leveys = 0.1*Wxmaasto
        self.h = random.uniform(0.0, 0.6*Wymaasto)
    def piirra(self):
        # Vuori
        (a, b) = xy_ruudulla(self.x1, self.h)
        (w, h) = xy_skaalaus(self.leveys, self.h)
        pygame.draw.rect(screen, MaastoVari, (a, b, w, h), 0)

        # Tuuliviirin masto
        tuulix = Tuuli/50.0*0.05*Wx
        mastonKorkeus = 0.05*Wy
        pygame.draw.line(screen, Musta, (a+w/2, b),
                         (a+w/2, b-mastonKorkeus), 4)
        # Tuuliviiri
        pygame.draw.line(screen, Sin, (a+w/2, b-mastonKorkeus),
                         (a+w/2+tuulix, b-mastonKorkeus), 12)

    # Tarkistetaan, onko kuula, jonka koordinaatit ovat x ja y osunut vuoreen
    def osuma(self, x, y):
        return y < self.h and self.x1 < x and x < self.x1 + self.leveys

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Maali
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_maali:
    def __init__(self, xmin):
        self.x = random.uniform(xmin, 0.95*Wxmaasto)
        self.y = 0.0
        self.leveys = 0.05*Wxmaasto
        self.korkeus = 0.03*Wymaasto
        (x, y) = xy_ruudulla(self.x, self.korkeus)
        (w, h) = xy_skaalaus(self.leveys, self.korkeus)
        self.vaunu = pygame.Rect(x, y, w, h)
        self.vari = (225, 255, 0)
        self.ehja = True

    def piirra(self):
        if self.ehja:
            pygame.draw.ellipse(screen, self.vari, self.vaunu, 0)
    def osuma(self, x, y):
        if (self.ehja and y < self.korkeus and
          self.x < x < self.x + self.leveys):
            self.ehja = False

            return True
        else:
            return False

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Morssari
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_morssari:
    def __init__(self):
        self.x = 0.05*Wxmaasto
        self.y = 0.01*Wymaasto
        (w, h) = xy_skaalaus(0.05*Wxmaasto, 0.03*Wymaasto)
        self.w = w
        self.h = h
        self.ruuti = 1.0
        self.KuulanTiheys = 5000.0
        self.kuulanVari = Sin
        self.latausaika = Nayttotaajuus
        self.kulma = pi/7.0  # piipun asento
        self.p1x = 0.0  # piipun pään x-koordinaatti
        self.p1y = 0.0  # piipun pään y-koordinaatti
        self.vaunu = pygame.Rect(0, 0, w, h)

    def piirra(self):
        (x, y) = xy_ruudulla(self.x, self.y)
        # piirretään mörssärin piippu
        (sx, sy) = r_xy(self.kulma, 200.0)
        self.p1x = self.x + sx
        self.p1y = self.y + sy
        if self.latausaika > 0:
            self.latausaika = self.latausaika - 1
            vari = Musta
        else:
            vari = Pun
        pygame.draw.line(screen, vari, (x, y),
                         xy_ruudulla(self.p1x, self.p1y), 10)
        # Ajopanosten ruutimäärän osoitin
        pygame.draw.line(screen, Sin, (10, Wy),
                         (10, Wy-int(self.ruuti/12.0*Wy)), 8)
        # vaunu
        self.vaunu.center = (x-self.w/4, y)
        pygame.draw.ellipse(screen, Musta, self.vaunu, 0)

    # Vaunun liikuttelua z ja x näppäimillä.
    # Vaunulla ei pääse vuoren läpi ;-)
    def liiku_x(self, dx):
        self.x = self.x + dx
        if self.x > vuori.x1:
            self.x = 0.0

# num+ ja num- näppäimillä kutsutaan tätä metodia
    def add_ruuti(self, m):
        self.ruuti = min(11.0, max(1.0, self.ruuti + 0.5*m))

# num-1, num-2 ja num-3 näppäimillä valitaan kuulan tyyppi
    def valitseKuula(self, tyyppi):
        if tyyppi ==  'puu':
            self.KuulanTiheys = 1000.0
            self.kuulanVari = Kelt
        elif tyyppi ==  'rauta':
            self.KuulanTiheys = 5000.0
            self.kuulanVari = Sin
        elif tyyppi ==  'lyijy':
            self.KuulanTiheys = 12000.0
            self.kuulanVari = Musta

# Käännetään piippua nuolinäppäimillä
    def asento(self, dkulma):
        self.kulma = self.kulma + dkulma

# laukaistaan mörssäri välilyöntinäppäimellä
    def ammu(self):

        self.latausaika = random.randint(Nayttotaajuus/2, 2*Nayttotaajuus)
        M = kuulanMassa(self.KuulanTiheys)
        (vx, vy) = self.kuulan_alkunopeus(M)
        return Cl_ammus(self.p1x, self.p1y, vx, vy, M, self.kuulanVari)

    def kuulan_alkunopeus(self, M):
        Cv0 = 600.0
        v0 = Cv0*sqrt(self.ruuti/M)
        print("ruuti: {:2.1f}".format(self.ruuti),
              "kulma: {:2.1f}".format(self.kulma*180.0/pi),
              "massa: {:4.1f}".format(M),
              "nopeus: {:4.0f}".format(v0))
        return (v0*cos(self.kulma),
                v0*sin(self.kulma))

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Ammus
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_ammus:
    def __init__(self, x, y, vx, vy, M, vari):
        self.x = x
        self.y = y
        self.vx = vx
        self.vy = vy
        self.M = M  # kg/m**3
        self.A = pi*RKuula**2
        self.vari = vari

    def piirra0(self):
        pygame.draw.circle(screen, self.vari,
                           xy_ruudulla(self.x, self.y), 5, 0)

    def liiku0(self):
        (self.x, self.y, self.vx, self.vy) = integ_euler(
            self.x, self.y, self.vx, self.vy, self.A, self.M)

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Pääohjelma alkaa tästä
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
print("alku")
pygame.init()

pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä
D_Info = pygame.display.Info()
Wx = D_Info.current_w
Wy = int(0.9*D_Info.current_h)
# pelimaailman leveys "metreinä"
Wxmaasto = 5000.0
scale = Wx/Wxmaasto
# Korkeus pelimaailmassa
Wymaasto = Wy/scale
screen = pygame.display.set_mode((Wx, Wy))
pygame.display.set_caption(
    "Morssari")
clock = pygame.time.Clock()
random.seed()
screen.fill(Tausta)
# Luodaan mörssäri ja vuori
vuori = Cl_vuori()
morssari = Cl_morssari()
kuulat = []

maali = Cl_maali(vuori.x1+2.0*vuori.leveys)

loppu = False
MuistaVanhat = False
while not loppu:
    clock.tick(Nayttotaajuus)
    if not MuistaVanhat:
        screen.fill(Tausta)
    for event in pygame.event.get():
        # Lopetetaan peli sulkemalla ikkuna tai painamalla ESC
        if event.type ==  pygame.QUIT:
            loppu = True
        if event.type ==  pygame.KEYDOWN:
            if event.key ==  pygame.K_ESCAPE:
                loppu = True
            # Pyyhitäänkö peli-ikkuna puhtaaksi joka kierroksella vai ei
            if event.key ==  pygame.K_F1:
                MuistaVanhat = not MuistaVanhat
            # säädellään ajopanoksen ruutimäärää
            if event.key ==  pygame.K_KP_PLUS:
                morssari.add_ruuti(1)
            if event.key ==  pygame.K_KP_MINUS:
                morssari.add_ruuti(-1)
            # valitaan kuulan tyyppi
            if event.key ==  pygame.K_KP1:
                morssari.valitseKuula('puu')
            if event.key ==  pygame.K_KP2:
                morssari.valitseKuula('rauta')
            if event.key ==  pygame.K_KP3:
                morssari.valitseKuula('lyijy')
    # Suunnataan ja siirrellään mörssäriä
    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_UP]:
        morssari.asento(0.005*saatoaskel)
    if pressed[pygame.K_DOWN]:
        morssari.asento(-0.005*saatoaskel)
    if pressed[pygame.K_x]:
        morssari.liiku_x(saatoaskel)
    if pressed[pygame.K_z]:
        morssari.liiku_x(-saatoaskel)

    # Laukaistaan mörssäri
    if pressed[pygame.K_SPACE] and morssari.latausaika ==  0:
        kuulat.append(morssari.ammu())

    # Piirretään kaikki oliot peli-ikkunaan ja lasketaan kuulille ja
    # sirpaleille uudet paikat peli-ikkunassa
    morssari.piirra()
    vuori.piirra()

    if maali.ehja:
        maali.piirra()

#    if not kuulat =  []:
#        for kuula in kuulat:

#            kuula.liiku0()
#            kuula.piirra0()

    if not kuulat ==  []:
        for k, kuula in enumerate(kuulat):

            kuula.liiku0()
            kuula.piirra0()

    pygame.display.flip()
    # while silmukka päättyy tähän
pygame.quit()

Tuuli = random.uniform(-50.0, 50.0)
 #  Tuuli = -50.0

        #  Tuuli­vii­rin masto
        tuulix = Tuuli/50.0*0.05*Wx
        mastonKorkeus = 0.05*Wy
        pygame.draw.line(screen, Musta, (a+w/2, b),
                         (a+w/2, b-mastonKorkeus), 4)
        #  Tuuli­viiri
        pygame.draw.line(screen, Sin, (a+w/2, b-mastonKorkeus),
                         (a+w/2+tuulix, b-mastonKorkeus), 12)

    #  Tar­kis­te­taan, onko kuula, jonka koor­di­naa­tit ovat x ja y osu­nut vuo­reen

    def osuma(self, x, y):
        return y < self.h and self.x1 < x and x < self.x1 + self.leveys

 #  = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
 #  Maali
 #  = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_maali:
    def __init__(self, xmin):
        self.x = random.uniform(xmin, 0.95*Wxmaasto)
        self.y = 0.0
        self.leveys = 0.05*Wxmaasto
        self.korkeus = 0.03*Wymaasto
        (x, y) = xy_ruudulla(self.x, self.korkeus)
        (w, h) = xy_skaalaus(self.leveys, self.korkeus)
        self.vaunu = pygame.Rect(x, y, w, h)
        self.vari = (225, 255, 0)
        self.ehja = True

    def piirra(self):
        if self.ehja:
            pygame.draw.ellipse(screen, self.vari, self.vaunu, 0)

    def osuma(self, x, y):
        if (self.ehja and y < self.korkeus and
          self.x < x < self.x + self.leveys):
            self.ehja = False

            return True
        else:
            return False

    def piirra0(self):
        pygame.draw.circle(screen, self.vari,
                           xy_ruudulla(self.x, self.y), 5, 0)

    def liiku0(self):
        (self.x, self.y, self.vx, self.vy) = integ_euler(
            self.x, self.y, self.vx, self.vy, self.A, self.M)

maali = Cl_maali(vuori.x1+2.0*vuori.leveys)

    if maali.ehja:
        maali.piirra()

 #             kuula.liiku0()
 #             kuula.piirra0()

            kuula.liiku0()
            kuula.piirra0()

# -*- coding: utf-8 -*-
import pygame
import random
from math import pi, cos, sin, sqrt
Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Kelt = (255, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Tausta = (160, 200, 255)
MaastoVari = (95, 95, 20)

# Peli-ikkuna päivitetään Nayttotaajuus kertaa sekunnissa
Nayttotaajuus = 48

# Tällä tykin säätö saadaan jouhevaksi kaikilla näyttötaajuuksilla
saatoaskel = 48.0/Nayttotaajuus

# Nopeutus = 1.0 ->  oikea "filmin" nopeus
Nopeutus = 5

Tuuli = random.uniform(-50.0, 50.0)
# Tuuli = -50.0

g_maa = 9.81  # putoamiskiihtyvyys
RKuula = 0.1  # kuulan säde metreinä

# Lasketaan, mihin tietty pelimaailman piste kuuluu peli-ikkunassa
def xy_ruudulla(xmaasto, ymaasto):
    xpikseli = int(xmaasto*scale)
    ypikseli = int(Wy-ymaasto*scale)
    return (xpikseli, ypikseli)

def xy_skaalaus(w, h):
    xpikseli = int(w*scale)
    ypikseli = int(h*scale)
    return (xpikseli, ypikseli)

def r_xy(kulma, r):
    return (r*cos(kulma), r*sin(kulma))

def kuulanMassa(tiheys):
    VKuula = 4/3*pi*RKuula**3
    return tiheys*VKuula

def kiihtyvyys0():
    ax = 0.0
    ay = -g_maa
    return (ax, ay)

# Siirtymä ja nopeuden muutos ajassa dt
def integ_euler(x, y, vx, vy, A, M):
    dt = 1.0/Nayttotaajuus
    for i in range(Nopeutus):

        (ax, ay) = kiihtyvyys0()

        (x, y, vx, vy) = (x + vx*dt, y + vy*dt, vx + ax*dt, vy + ay*dt)
    return (x, y, vx, vy)

# Vuori ja "tuuliviiri"
class Cl_vuori:
    def __init__(self):
        self.x1 = random.uniform(0.3*Wxmaasto, 0.6*Wxmaasto)
        self.leveys = 0.1*Wxmaasto
        self.h = random.uniform(0.0, 0.6*Wymaasto)
    def piirra(self):
        # Vuori
        (a, b) = xy_ruudulla(self.x1, self.h)
        (w, h) = xy_skaalaus(self.leveys, self.h)
        pygame.draw.rect(screen, MaastoVari, (a, b, w, h), 0)

        # Tuuliviirin masto
        tuulix = Tuuli/50.0*0.05*Wx
        mastonKorkeus = 0.05*Wy
        pygame.draw.line(screen, Musta, (a+w/2, b),
                         (a+w/2, b-mastonKorkeus), 4)
        # Tuuliviiri
        pygame.draw.line(screen, Sin, (a+w/2, b-mastonKorkeus),
                         (a+w/2+tuulix, b-mastonKorkeus), 12)

    # Tarkistetaan, onko kuula, jonka koordinaatit ovat x ja y osunut vuoreen
    def osuma(self, x, y):
        return y < self.h and self.x1 < x and x < self.x1 + self.leveys

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Maali
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_maali:
    def __init__(self, xmin):
        self.x = random.uniform(xmin, 0.95*Wxmaasto)
        self.y = 0.0
        self.leveys = 0.05*Wxmaasto
        self.korkeus = 0.03*Wymaasto
        (x, y) = xy_ruudulla(self.x, self.korkeus)
        (w, h) = xy_skaalaus(self.leveys, self.korkeus)
        self.vaunu = pygame.Rect(x, y, w, h)
        self.vari = (225, 255, 0)
        self.ehja = True

    def piirra(self):
        if self.ehja:
            pygame.draw.ellipse(screen, self.vari, self.vaunu, 0)
    def osuma(self, x, y):
        if (self.ehja and y < self.korkeus and
          self.x < x < self.x + self.leveys):
            self.ehja = False

            return True
        else:
            return False

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Morssari
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_morssari:
    def __init__(self):
        self.x = 0.05*Wxmaasto
        self.y = 0.01*Wymaasto
        (w, h) = xy_skaalaus(0.05*Wxmaasto, 0.03*Wymaasto)
        self.w = w
        self.h = h
        self.ruuti = 1.0
        self.KuulanTiheys = 5000.0
        self.kuulanVari = Sin
        self.latausaika = Nayttotaajuus
        self.kulma = pi/7.0  # piipun asento
        self.p1x = 0.0  # piipun pään x-koordinaatti
        self.p1y = 0.0  # piipun pään y-koordinaatti
        self.vaunu = pygame.Rect(0, 0, w, h)

    def piirra(self):
        (x, y) = xy_ruudulla(self.x, self.y)
        # piirretään mörssärin piippu
        (sx, sy) = r_xy(self.kulma, 200.0)
        self.p1x = self.x + sx
        self.p1y = self.y + sy
        if self.latausaika > 0:
            self.latausaika = self.latausaika - 1
            vari = Musta
        else:
            vari = Pun
        pygame.draw.line(screen, vari, (x, y),
                         xy_ruudulla(self.p1x, self.p1y), 10)
        # Ajopanosten ruutimäärän osoitin
        pygame.draw.line(screen, Sin, (10, Wy),
                         (10, Wy-int(self.ruuti/12.0*Wy)), 8)
        # vaunu
        self.vaunu.center = (x-self.w/4, y)
        pygame.draw.ellipse(screen, Musta, self.vaunu, 0)

    # Vaunun liikuttelua z ja x näppäimillä.
    # Vaunulla ei pääse vuoren läpi ;-)
    def liiku_x(self, dx):
        self.x = self.x + dx
        if self.x > vuori.x1:
            self.x = 0.0

# num+ ja num- näppäimillä kutsutaan tätä metodia
    def add_ruuti(self, m):
        self.ruuti = min(11.0, max(1.0, self.ruuti + 0.5*m))

# num-1, num-2 ja num-3 näppäimillä valitaan kuulan tyyppi
    def valitseKuula(self, tyyppi):
        if tyyppi ==  'puu':
            self.KuulanTiheys = 1000.0
            self.kuulanVari = Kelt
        elif tyyppi ==  'rauta':
            self.KuulanTiheys = 5000.0
            self.kuulanVari = Sin
        elif tyyppi ==  'lyijy':
            self.KuulanTiheys = 12000.0
            self.kuulanVari = Musta

# Käännetään piippua nuolinäppäimillä
    def asento(self, dkulma):
        self.kulma = self.kulma + dkulma

# laukaistaan mörssäri välilyöntinäppäimellä
    def ammu(self):

        self.latausaika = random.randint(Nayttotaajuus/2, 2*Nayttotaajuus)
        M = kuulanMassa(self.KuulanTiheys)
        (vx, vy) = self.kuulan_alkunopeus(M)
        return Cl_ammus(self.p1x, self.p1y, vx, vy, M, self.kuulanVari)

    def kuulan_alkunopeus(self, M):
        Cv0 = 600.0
        v0 = Cv0*sqrt(self.ruuti/M)
        print("ruuti: {:2.1f}".format(self.ruuti),
              "kulma: {:2.1f}".format(self.kulma*180.0/pi),
              "massa: {:4.1f}".format(M),
              "nopeus: {:4.0f}".format(v0))
        return (v0*cos(self.kulma),
                v0*sin(self.kulma))

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Ammus
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_ammus:
    def __init__(self, x, y, vx, vy, M, vari):
        self.x = x
        self.y = y
        self.vx = vx
        self.vy = vy
        self.M = M  # kg/m**3
        self.A = pi*RKuula**2
        self.vari = vari

        self.rajahdys = False
        self.rajahdysvaihe = 0
        self.rajahtanyt = 0

    def piirra0(self):
        pygame.draw.circle(screen, self.vari,
                           xy_ruudulla(self.x, self.y), 5, 0)

    def piirra(self):
        if self.rajahdys:
            vari = Pun
        else:
            vari = self.vari
        if not self.rajahtanyt:
            pygame.draw.circle(screen, vari,
                               xy_ruudulla(self.x, self.y), 5, 0)
            (a, b) = xy_ruudulla(self.x, self.y)
            (c, d) = xy_ruudulla(self.x-self.vx, self.y-self.vy)
            pygame.draw.line(screen, Kelt, (a, b), (c, d), 2)

    def liiku0(self):
        (self.x, self.y, self.vx, self.vy) = integ_euler(
            self.x, self.y, self.vx, self.vy, self.A, self.M)

    def liiku(self):
        self.rajahdys = (vuori.osuma(self.x, self.y) or (self.y < 20) or
                         maali.osuma(self.x, self.y))
        if not self.rajahdys:
            (self.x, self.y, self.vx, self.vy) = integ_euler(
                    self.x, self.y, self.vx, self.vy, self.A, self.M)

        else:
            self.vx = 0.0
            self.vy = 0.0

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Pääohjelma alkaa tästä
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
print("alku")
pygame.init()

pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä
D_Info = pygame.display.Info()
Wx = D_Info.current_w
Wy = int(0.9*D_Info.current_h)
# pelimaailman leveys "metreinä"
Wxmaasto = 5000.0
scale = Wx/Wxmaasto
# Korkeus pelimaailmassa
Wymaasto = Wy/scale
screen = pygame.display.set_mode((Wx, Wy))
pygame.display.set_caption(
    "Morssari")
clock = pygame.time.Clock()
random.seed()
screen.fill(Tausta)
# Luodaan mörssäri ja vuori
vuori = Cl_vuori()
morssari = Cl_morssari()
kuulat = []

maali = Cl_maali(vuori.x1+2.0*vuori.leveys)

loppu = False
MuistaVanhat = False
while not loppu:
    clock.tick(Nayttotaajuus)
    if not MuistaVanhat:
        screen.fill(Tausta)
    for event in pygame.event.get():
        # Lopetetaan peli sulkemalla ikkuna tai painamalla ESC
        if event.type ==  pygame.QUIT:
            loppu = True
        if event.type ==  pygame.KEYDOWN:
            if event.key ==  pygame.K_ESCAPE:
                loppu = True
            # Pyyhitäänkö peli-ikkuna puhtaaksi joka kierroksella vai ei
            if event.key ==  pygame.K_F1:
                MuistaVanhat = not MuistaVanhat
            # säädellään ajopanoksen ruutimäärää
            if event.key ==  pygame.K_KP_PLUS:
                morssari.add_ruuti(1)
            if event.key ==  pygame.K_KP_MINUS:
                morssari.add_ruuti(-1)
            # valitaan kuulan tyyppi
            if event.key ==  pygame.K_KP1:
                morssari.valitseKuula('puu')
            if event.key ==  pygame.K_KP2:
                morssari.valitseKuula('rauta')
            if event.key ==  pygame.K_KP3:
                morssari.valitseKuula('lyijy')
    # Suunnataan ja siirrellään mörssäriä
    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_UP]:
        morssari.asento(0.005*saatoaskel)
    if pressed[pygame.K_DOWN]:
        morssari.asento(-0.005*saatoaskel)
    if pressed[pygame.K_x]:
        morssari.liiku_x(saatoaskel)
    if pressed[pygame.K_z]:
        morssari.liiku_x(-saatoaskel)

    # Laukaistaan mörssäri
    if pressed[pygame.K_SPACE] and morssari.latausaika ==  0:
        kuulat.append(morssari.ammu())

    # Piirretään kaikki oliot peli-ikkunaan ja lasketaan kuulille ja
    # sirpaleille uudet paikat peli-ikkunassa
    morssari.piirra()
    vuori.piirra()

    if maali.ehja:
        maali.piirra()

#    if not kuulat =  []:
#        for kuula in kuulat:

#            kuula.liiku0()
#            kuula.piirra0()

#            kuula.piirra()
#            kuula.liiku()

    if not kuulat ==  []:
        for k, kuula in enumerate(kuulat):

            kuula.liiku0()
            kuula.piirra0()

            kuula.liiku()
            kuula.piirra()

    pygame.display.flip()
    # while silmukka päättyy tähän
pygame.quit()

        self.rajahdys = False
        self.rajahdysvaihe = 0
        self.rajahtanyt = 0

    def piirra0(self):
        pygame.draw.circle(screen, self.vari,
                           xy_ruudulla(self.x, self.y), 5, 0)

    def piirra(self):
        if self.rajahdys:
            vari = Pun
        else:
            vari = self.vari
        if not self.rajahtanyt:
            pygame.draw.circle(screen, vari,
                               xy_ruudulla(self.x, self.y), 5, 0)
            (a, b) = xy_ruudulla(self.x, self.y)
            (c, d) = xy_ruudulla(self.x-self.vx, self.y-self.vy)
            pygame.draw.line(screen, Kelt, (a, b), (c, d), 2)

    def liiku0(self):
        (self.x, self.y, self.vx, self.vy) = integ_euler(
            self.x, self.y, self.vx, self.vy, self.A, self.M)

    def liiku(self):
        self.rajahdys = (vuori.osuma(self.x, self.y) or (self.y < 20) or
                         maali.osuma(self.x, self.y))
        if not self.rajahdys:
            (self.x, self.y, self.vx, self.vy) = integ_euler(
                    self.x, self.y, self.vx, self.vy, self.A, self.M)

        else:
            self.vx = 0.0
            self.vy = 0.0

 #             kuula.liiku0()
 #             kuula.piirra0()

 #             kuula.piirra()
 #             kuula.liiku()

            kuula.liiku0()
            kuula.piirra0()

            kuula.liiku()
            kuula.piirra()

# -*- coding: utf-8 -*-
import pygame
import random
from math import pi, cos, sin, sqrt
Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Kelt = (255, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Tausta = (160, 200, 255)
MaastoVari = (95, 95, 20)

# Peli-ikkuna päivitetään Nayttotaajuus kertaa sekunnissa
Nayttotaajuus = 48

# Tällä tykin säätö saadaan jouhevaksi kaikilla näyttötaajuuksilla
saatoaskel = 48.0/Nayttotaajuus

# Nopeutus = 1.0 ->  oikea "filmin" nopeus
Nopeutus = 5

Tuuli = random.uniform(-50.0, 50.0)
# Tuuli = -50.0

g_maa = 9.81  # putoamiskiihtyvyys
RKuula = 0.1  # kuulan säde metreinä

# Lasketaan, mihin tietty pelimaailman piste kuuluu peli-ikkunassa
def xy_ruudulla(xmaasto, ymaasto):
    xpikseli = int(xmaasto*scale)
    ypikseli = int(Wy-ymaasto*scale)
    return (xpikseli, ypikseli)

def xy_skaalaus(w, h):
    xpikseli = int(w*scale)
    ypikseli = int(h*scale)
    return (xpikseli, ypikseli)

def r_xy(kulma, r):
    return (r*cos(kulma), r*sin(kulma))

def kuulanMassa(tiheys):
    VKuula = 4/3*pi*RKuula**3
    return tiheys*VKuula

def kiihtyvyys0():
    ax = 0.0
    ay = -g_maa
    return (ax, ay)

# Siirtymä ja nopeuden muutos ajassa dt
def integ_euler(x, y, vx, vy, A, M):
    dt = 1.0/Nayttotaajuus
    for i in range(Nopeutus):

        (ax, ay) = kiihtyvyys0()

        (x, y, vx, vy) = (x + vx*dt, y + vy*dt, vx + ax*dt, vy + ay*dt)
    return (x, y, vx, vy)

# Vuori ja "tuuliviiri"
class Cl_vuori:
    def __init__(self):
        self.x1 = random.uniform(0.3*Wxmaasto, 0.6*Wxmaasto)
        self.leveys = 0.1*Wxmaasto
        self.h = random.uniform(0.0, 0.6*Wymaasto)
    def piirra(self):
        # Vuori
        (a, b) = xy_ruudulla(self.x1, self.h)
        (w, h) = xy_skaalaus(self.leveys, self.h)
        pygame.draw.rect(screen, MaastoVari, (a, b, w, h), 0)

        # Tuuliviirin masto
        tuulix = Tuuli/50.0*0.05*Wx
        mastonKorkeus = 0.05*Wy
        pygame.draw.line(screen, Musta, (a+w/2, b),
                         (a+w/2, b-mastonKorkeus), 4)
        # Tuuliviiri
        pygame.draw.line(screen, Sin, (a+w/2, b-mastonKorkeus),
                         (a+w/2+tuulix, b-mastonKorkeus), 12)

    # Tarkistetaan, onko kuula, jonka koordinaatit ovat x ja y osunut vuoreen
    def osuma(self, x, y):
        return y < self.h and self.x1 < x and x < self.x1 + self.leveys

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Maali
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_maali:
    def __init__(self, xmin):
        self.x = random.uniform(xmin, 0.95*Wxmaasto)
        self.y = 0.0
        self.leveys = 0.05*Wxmaasto
        self.korkeus = 0.03*Wymaasto
        (x, y) = xy_ruudulla(self.x, self.korkeus)
        (w, h) = xy_skaalaus(self.leveys, self.korkeus)
        self.vaunu = pygame.Rect(x, y, w, h)
        self.vari = (225, 255, 0)
        self.ehja = True

    def piirra(self):
        if self.ehja:
            pygame.draw.ellipse(screen, self.vari, self.vaunu, 0)
    def osuma(self, x, y):
        if (self.ehja and y < self.korkeus and
          self.x < x < self.x + self.leveys):
            self.ehja = False

            return True
        else:
            return False

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Morssari
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_morssari:
    def __init__(self):
        self.x = 0.05*Wxmaasto
        self.y = 0.01*Wymaasto
        (w, h) = xy_skaalaus(0.05*Wxmaasto, 0.03*Wymaasto)
        self.w = w
        self.h = h
        self.ruuti = 1.0
        self.KuulanTiheys = 5000.0
        self.kuulanVari = Sin
        self.latausaika = Nayttotaajuus
        self.kulma = pi/7.0  # piipun asento
        self.p1x = 0.0  # piipun pään x-koordinaatti
        self.p1y = 0.0  # piipun pään y-koordinaatti
        self.vaunu = pygame.Rect(0, 0, w, h)

    def piirra(self):
        (x, y) = xy_ruudulla(self.x, self.y)
        # piirretään mörssärin piippu
        (sx, sy) = r_xy(self.kulma, 200.0)
        self.p1x = self.x + sx
        self.p1y = self.y + sy
        if self.latausaika > 0:
            self.latausaika = self.latausaika - 1
            vari = Musta
        else:
            vari = Pun
        pygame.draw.line(screen, vari, (x, y),
                         xy_ruudulla(self.p1x, self.p1y), 10)
        # Ajopanosten ruutimäärän osoitin
        pygame.draw.line(screen, Sin, (10, Wy),
                         (10, Wy-int(self.ruuti/12.0*Wy)), 8)
        # vaunu
        self.vaunu.center = (x-self.w/4, y)
        pygame.draw.ellipse(screen, Musta, self.vaunu, 0)

    # Vaunun liikuttelua z ja x näppäimillä.
    # Vaunulla ei pääse vuoren läpi ;-)
    def liiku_x(self, dx):
        self.x = self.x + dx
        if self.x > vuori.x1:
            self.x = 0.0

# num+ ja num- näppäimillä kutsutaan tätä metodia
    def add_ruuti(self, m):
        self.ruuti = min(11.0, max(1.0, self.ruuti + 0.5*m))

# num-1, num-2 ja num-3 näppäimillä valitaan kuulan tyyppi
    def valitseKuula(self, tyyppi):
        if tyyppi ==  'puu':
            self.KuulanTiheys = 1000.0
            self.kuulanVari = Kelt
        elif tyyppi ==  'rauta':
            self.KuulanTiheys = 5000.0
            self.kuulanVari = Sin
        elif tyyppi ==  'lyijy':
            self.KuulanTiheys = 12000.0
            self.kuulanVari = Musta

# Käännetään piippua nuolinäppäimillä
    def asento(self, dkulma):
        self.kulma = self.kulma + dkulma

# laukaistaan mörssäri välilyöntinäppäimellä
    def ammu(self):

        self.latausaika = random.randint(Nayttotaajuus/2, 2*Nayttotaajuus)
        M = kuulanMassa(self.KuulanTiheys)
        (vx, vy) = self.kuulan_alkunopeus(M)
        return Cl_ammus(self.p1x, self.p1y, vx, vy, M, self.kuulanVari)

    def kuulan_alkunopeus(self, M):
        Cv0 = 600.0
        v0 = Cv0*sqrt(self.ruuti/M)
        print("ruuti: {:2.1f}".format(self.ruuti),
              "kulma: {:2.1f}".format(self.kulma*180.0/pi),
              "massa: {:4.1f}".format(M),
              "nopeus: {:4.0f}".format(v0))
        return (v0*cos(self.kulma),
                v0*sin(self.kulma))

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Ammus
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_ammus:
    def __init__(self, x, y, vx, vy, M, vari):
        self.x = x
        self.y = y
        self.vx = vx
        self.vy = vy
        self.M = M  # kg/m**3
        self.A = pi*RKuula**2
        self.vari = vari

        self.rajahdys = False
        self.rajahdysvaihe = 0
        self.rajahtanyt = 0

    def piirra(self):
        if self.rajahdys:
            vari = Pun
        else:
            vari = self.vari
        if not self.rajahtanyt:
            pygame.draw.circle(screen, vari,
                               xy_ruudulla(self.x, self.y), 5, 0)
            (a, b) = xy_ruudulla(self.x, self.y)
            (c, d) = xy_ruudulla(self.x-self.vx, self.y-self.vy)
            pygame.draw.line(screen, Kelt, (a, b), (c, d), 2)

    def liiku(self):
        self.rajahdys = (vuori.osuma(self.x, self.y) or (self.y < 20) or
                         maali.osuma(self.x, self.y))
        if not self.rajahdys:
            (self.x, self.y, self.vx, self.vy) = integ_euler(
                    self.x, self.y, self.vx, self.vy, self.A, self.M)

        else:
            self.vx = 0.0
            self.vy = 0.0

            self.rajahda()

    def rajahda(self):
        if self.rajahdysvaihe < Nayttotaajuus/2:

            self.rajahdysvaihe = self.rajahdysvaihe + 1
            for i in range(200):
                (p0x, p0y) = xy_ruudulla(self.x, self.y)
                (dx, dy) = r_xy(random.uniform(0, 2*pi),
                           self.rajahdysvaihe*random.uniform(0.25, 2.5))
                p1x = p0x + int(dx)
                p1y = p0y - int(dy)
                vari = (random.randint(160, 255),
                        random.randint(80, 255), 0)
                pygame.draw.line(screen, vari, (p0x, p0y), (p1x, p1y), 1)
        else:
            self.rajahtanyt = True

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Pääohjelma alkaa tästä
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
print("alku")
pygame.init()

pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä
D_Info = pygame.display.Info()
Wx = D_Info.current_w
Wy = int(0.9*D_Info.current_h)
# pelimaailman leveys "metreinä"
Wxmaasto = 5000.0
scale = Wx/Wxmaasto
# Korkeus pelimaailmassa
Wymaasto = Wy/scale
screen = pygame.display.set_mode((Wx, Wy))
pygame.display.set_caption(
    "Morssari")
clock = pygame.time.Clock()
random.seed()
screen.fill(Tausta)
# Luodaan mörssäri ja vuori
vuori = Cl_vuori()
morssari = Cl_morssari()
kuulat = []

maali = Cl_maali(vuori.x1+2.0*vuori.leveys)

loppu = False
MuistaVanhat = False
while not loppu:
    clock.tick(Nayttotaajuus)
    if not MuistaVanhat:
        screen.fill(Tausta)
    for event in pygame.event.get():
        # Lopetetaan peli sulkemalla ikkuna tai painamalla ESC
        if event.type ==  pygame.QUIT:
            loppu = True
        if event.type ==  pygame.KEYDOWN:
            if event.key ==  pygame.K_ESCAPE:
                loppu = True
            # Pyyhitäänkö peli-ikkuna puhtaaksi joka kierroksella vai ei
            if event.key ==  pygame.K_F1:
                MuistaVanhat = not MuistaVanhat
            # säädellään ajopanoksen ruutimäärää
            if event.key ==  pygame.K_KP_PLUS:
                morssari.add_ruuti(1)
            if event.key ==  pygame.K_KP_MINUS:
                morssari.add_ruuti(-1)
            # valitaan kuulan tyyppi
            if event.key ==  pygame.K_KP1:
                morssari.valitseKuula('puu')
            if event.key ==  pygame.K_KP2:
                morssari.valitseKuula('rauta')
            if event.key ==  pygame.K_KP3:
                morssari.valitseKuula('lyijy')
    # Suunnataan ja siirrellään mörssäriä
    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_UP]:
        morssari.asento(0.005*saatoaskel)
    if pressed[pygame.K_DOWN]:
        morssari.asento(-0.005*saatoaskel)
    if pressed[pygame.K_x]:
        morssari.liiku_x(saatoaskel)
    if pressed[pygame.K_z]:
        morssari.liiku_x(-saatoaskel)

    # Laukaistaan mörssäri
    if pressed[pygame.K_SPACE] and morssari.latausaika ==  0:
        kuulat.append(morssari.ammu())

    # Piirretään kaikki oliot peli-ikkunaan ja lasketaan kuulille ja
    # sirpaleille uudet paikat peli-ikkunassa
    morssari.piirra()
    vuori.piirra()

    if maali.ehja:
        maali.piirra()

#    if not kuulat =  []:
#        for kuula in kuulat:

#            kuula.piirra()
#            kuula.liiku()

    if not kuulat ==  []:
        for k, kuula in enumerate(kuulat):

            kuula.liiku()
            kuula.piirra()

    pygame.display.flip()
    # while silmukka päättyy tähän
pygame.quit()

            self.rajahda()

    def rajahda(self):
        if self.rajahdysvaihe < Nayttotaajuus/2:

            self.rajahdysvaihe = self.rajahdysvaihe + 1
            for i in range(200):
                (p0x, p0y) = xy_ruudulla(self.x, self.y)
                (dx, dy) = r_xy(random.uniform(0, 2*pi),
                           self.rajahdysvaihe*random.uniform(0.25, 2.5))
                p1x = p0x + int(dx)
                p1y = p0y - int(dy)
                vari = (random.randint(160, 255),
                        random.randint(80, 255), 0)
                pygame.draw.line(screen, vari, (p0x, p0y), (p1x, p1y), 1)
        else:
            self.rajahtanyt = True

# -*- coding: utf-8 -*-
import pygame
import random
from math import pi, cos, sin, sqrt
Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Kelt = (255, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Tausta = (160, 200, 255)
MaastoVari = (95, 95, 20)

# Peli-ikkuna päivitetään Nayttotaajuus kertaa sekunnissa
Nayttotaajuus = 48

# Tällä tykin säätö saadaan jouhevaksi kaikilla näyttötaajuuksilla
saatoaskel = 48.0/Nayttotaajuus

# Nopeutus = 1.0 ->  oikea "filmin" nopeus
Nopeutus = 5

Tuuli = random.uniform(-50.0, 50.0)
# Tuuli = -50.0

g_maa = 9.81  # putoamiskiihtyvyys
RKuula = 0.1  # kuulan säde metreinä

# Lasketaan, mihin tietty pelimaailman piste kuuluu peli-ikkunassa
def xy_ruudulla(xmaasto, ymaasto):
    xpikseli = int(xmaasto*scale)
    ypikseli = int(Wy-ymaasto*scale)
    return (xpikseli, ypikseli)

def xy_skaalaus(w, h):
    xpikseli = int(w*scale)
    ypikseli = int(h*scale)
    return (xpikseli, ypikseli)

def r_xy(kulma, r):
    return (r*cos(kulma), r*sin(kulma))

def kuulanMassa(tiheys):
    VKuula = 4/3*pi*RKuula**3
    return tiheys*VKuula

def kiihtyvyys0():
    ax = 0.0
    ay = -g_maa
    return (ax, ay)

def kiihtyvyys(vx, vy, A, m):
    c = 0.15
    vx = vx - Tuuli  # Kuulan vaakanopeus ilman suhteen
    v2 = vx**2 + vy**2
    v = sqrt(v2)
    Fd = -c*A*v2/m
    ax = vx/v*Fd
    ay = vy/v*Fd-g_maa
    return (ax, ay)

# Siirtymä ja nopeuden muutos ajassa dt
def integ_euler(x, y, vx, vy, A, M):
    dt = 1.0/Nayttotaajuus
    for i in range(Nopeutus):

        (ax, ay) = kiihtyvyys0()

        (ax, ay) = kiihtyvyys(vx, vy, A, M)

        (x, y, vx, vy) = (x + vx*dt, y + vy*dt, vx + ax*dt, vy + ay*dt)
    return (x, y, vx, vy)

def hehku(color):
    (r, g, b) = color
    r = max(0, min(255, r + random.randint(-10, 10)))
    g = max(0, min(255, g + random.randint(-10, 10)))
    b = max(0, min(255, b + random.randint(-10, 10)))
    return (r, g, b)

# Vuori ja "tuuliviiri"
class Cl_vuori:
    def __init__(self):
        self.x1 = random.uniform(0.3*Wxmaasto, 0.6*Wxmaasto)
        self.leveys = 0.1*Wxmaasto
        self.h = random.uniform(0.0, 0.6*Wymaasto)
    def piirra(self):
        # Vuori
        (a, b) = xy_ruudulla(self.x1, self.h)
        (w, h) = xy_skaalaus(self.leveys, self.h)
        pygame.draw.rect(screen, MaastoVari, (a, b, w, h), 0)

        # Tuuliviirin masto
        tuulix = Tuuli/50.0*0.05*Wx
        mastonKorkeus = 0.05*Wy
        pygame.draw.line(screen, Musta, (a+w/2, b),
                         (a+w/2, b-mastonKorkeus), 4)
        # Tuuliviiri
        pygame.draw.line(screen, Sin, (a+w/2, b-mastonKorkeus),
                         (a+w/2+tuulix, b-mastonKorkeus), 12)

    # Tarkistetaan, onko kuula, jonka koordinaatit ovat x ja y osunut vuoreen
    def osuma(self, x, y):
        return y < self.h and self.x1 < x and x < self.x1 + self.leveys

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Maali
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_maali:
    def __init__(self, xmin):
        self.x = random.uniform(xmin, 0.95*Wxmaasto)
        self.y = 0.0
        self.leveys = 0.05*Wxmaasto
        self.korkeus = 0.03*Wymaasto
        (x, y) = xy_ruudulla(self.x, self.korkeus)
        (w, h) = xy_skaalaus(self.leveys, self.korkeus)
        self.vaunu = pygame.Rect(x, y, w, h)
        self.vari = (225, 255, 0)
        self.ehja = True

    def piirra(self):
        if self.ehja:
            pygame.draw.ellipse(screen, self.vari, self.vaunu, 0)
    def osuma(self, x, y):
        if (self.ehja and y < self.korkeus and
          self.x < x < self.x + self.leveys):
            self.ehja = False

            for i in range(500):
                sirpaleet.append(Cl_sirpale(self.x, self.korkeus, self.vari))
            osuma_snd.play()

            return True
        else:
            return False

# Sirpale
class Cl_sirpale:
    def __init__(self, x, y, color):
        self.x = x
        self.y = y
        self.sx = self.x*random.uniform(2, 12)/100.0
        self.sy = self.y*random.uniform(2, 12)/100.0
        self.paksuus = self.y*random.uniform(2, 12)/100.0
        self.A = self.sx*self.sy
        self.M = self.A*self.paksuus*random.uniform(500.0, 2000.0)
        self.color = color
        (self.vx, self.vy) = r_xy(random.uniform(0.5, pi-0.5),
                             random.uniform(10.0, 150.0))

    def piirra(self):
        (x, y) = xy_ruudulla(self.x, self.y)
        pygame.draw.rect(screen, self.color,
                         (x+int(self.sx/2), y+int(self.sy/2),
                          int(self.sx), int(self.sy)), 0)

    # Sirpaleet liikkuvat samalla dynamiikalla kuin kuulatkin
    def liiku(self):
        if self.y > 2.0:

            self.sx = min(12, max(2, self.sx + random.randint(-2, 2)))
            self.sy = min(12, max(2, self.sy + random.randint(-2, 2)))
            self.color = hehku(self.color)

            (self.x, self.y, self.vx, self.vy) = integ_euler(
                        self.x, self.y, self.vx, self.vy, self.A, self.M)

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Morssari
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_morssari:
    def __init__(self):
        self.x = 0.05*Wxmaasto
        self.y = 0.01*Wymaasto
        (w, h) = xy_skaalaus(0.05*Wxmaasto, 0.03*Wymaasto)
        self.w = w
        self.h = h
        self.ruuti = 1.0
        self.KuulanTiheys = 5000.0
        self.kuulanVari = Sin
        self.latausaika = Nayttotaajuus
        self.kulma = pi/7.0  # piipun asento
        self.p1x = 0.0  # piipun pään x-koordinaatti
        self.p1y = 0.0  # piipun pään y-koordinaatti
        self.vaunu = pygame.Rect(0, 0, w, h)

    def piirra(self):
        (x, y) = xy_ruudulla(self.x, self.y)
        # piirretään mörssärin piippu
        (sx, sy) = r_xy(self.kulma, 200.0)
        self.p1x = self.x + sx
        self.p1y = self.y + sy
        if self.latausaika > 0:
            self.latausaika = self.latausaika - 1
            vari = Musta
        else:
            vari = Pun
        pygame.draw.line(screen, vari, (x, y),
                         xy_ruudulla(self.p1x, self.p1y), 10)
        # Ajopanosten ruutimäärän osoitin
        pygame.draw.line(screen, Sin, (10, Wy),
                         (10, Wy-int(self.ruuti/12.0*Wy)), 8)
        # vaunu
        self.vaunu.center = (x-self.w/4, y)
        pygame.draw.ellipse(screen, Musta, self.vaunu, 0)

    # Vaunun liikuttelua z ja x näppäimillä.
    # Vaunulla ei pääse vuoren läpi ;-)
    def liiku_x(self, dx):
        self.x = self.x + dx
        if self.x > vuori.x1:
            self.x = 0.0

# num+ ja num- näppäimillä kutsutaan tätä metodia
    def add_ruuti(self, m):
        self.ruuti = min(11.0, max(1.0, self.ruuti + 0.5*m))

        self.ruuti = min(11.0, max(1.0, self.ruuti + 2.0*m))

# num-1, num-2 ja num-3 näppäimillä valitaan kuulan tyyppi
    def valitseKuula(self, tyyppi):
        if tyyppi ==  'puu':
            self.KuulanTiheys = 1000.0
            self.kuulanVari = Kelt
        elif tyyppi ==  'rauta':
            self.KuulanTiheys = 5000.0
            self.kuulanVari = Sin
        elif tyyppi ==  'lyijy':
            self.KuulanTiheys = 12000.0
            self.kuulanVari = Musta

# Käännetään piippua nuolinäppäimillä
    def asento(self, dkulma):
        self.kulma = self.kulma + dkulma

# laukaistaan mörssäri välilyöntinäppäimellä
    def ammu(self):

        morssari_snd.play()

        self.latausaika = random.randint(Nayttotaajuus/2, 2*Nayttotaajuus)
        M = kuulanMassa(self.KuulanTiheys)
        (vx, vy) = self.kuulan_alkunopeus(M)
        return Cl_ammus(self.p1x, self.p1y, vx, vy, M, self.kuulanVari)

    def kuulan_alkunopeus(self, M):
        Cv0 = 600.0
        v0 = Cv0*sqrt(self.ruuti/M)
        print("ruuti: {:2.1f}".format(self.ruuti),
              "kulma: {:2.1f}".format(self.kulma*180.0/pi),
              "massa: {:4.1f}".format(M),
              "nopeus: {:4.0f}".format(v0))
        return (v0*cos(self.kulma),
                v0*sin(self.kulma))

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Ammus
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_ammus:
    def __init__(self, x, y, vx, vy, M, vari):
        self.x = x
        self.y = y
        self.vx = vx
        self.vy = vy
        self.M = M  # kg/m**3
        self.A = pi*RKuula**2
        self.vari = vari

        self.rajahdys = False
        self.rajahdysvaihe = 0
        self.rajahtanyt = 0

    def piirra(self):
        if self.rajahdys:
            vari = Pun
        else:
            vari = self.vari
        if not self.rajahtanyt:
            pygame.draw.circle(screen, vari,
                               xy_ruudulla(self.x, self.y), 5, 0)
            (a, b) = xy_ruudulla(self.x, self.y)
            (c, d) = xy_ruudulla(self.x-self.vx, self.y-self.vy)
            pygame.draw.line(screen, Kelt, (a, b), (c, d), 2)

    def liiku(self):
        self.rajahdys = (vuori.osuma(self.x, self.y) or (self.y < 20) or
                         maali.osuma(self.x, self.y))
        if not self.rajahdys:
            (self.x, self.y, self.vx, self.vy) = integ_euler(
                    self.x, self.y, self.vx, self.vy, self.A, self.M)

        else:
            self.vx = 0.0
            self.vy = 0.0

            self.rajahda()

    def rajahda(self):
        if self.rajahdysvaihe < Nayttotaajuus/2:

            if self.rajahdysvaihe ==  0:
                kuula_snd.play()
                kuula_snd.fadeout(600)

            self.rajahdysvaihe = self.rajahdysvaihe + 1
            for i in range(200):
                (p0x, p0y) = xy_ruudulla(self.x, self.y)
                (dx, dy) = r_xy(random.uniform(0, 2*pi),
                           self.rajahdysvaihe*random.uniform(0.25, 2.5))
                p1x = p0x + int(dx)
                p1y = p0y - int(dy)
                vari = (random.randint(160, 255),
                        random.randint(80, 255), 0)
                pygame.draw.line(screen, vari, (p0x, p0y), (p1x, p1y), 1)
        else:
            self.rajahtanyt = True

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Pääohjelma alkaa tästä
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
print("alku")
pygame.init()

pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=512)
osuma_snd = pygame.mixer.Sound(
    'Explosion_Ultra_Bass-Mark_DiAngelo-1810420658.wav')
morssari_snd = pygame.mixer.Sound('morssari.wav')
kuula_snd = pygame.mixer.Sound('kuula.wav')

pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä
D_Info = pygame.display.Info()
Wx = D_Info.current_w
Wy = int(0.9*D_Info.current_h)
# pelimaailman leveys "metreinä"
Wxmaasto = 5000.0
scale = Wx/Wxmaasto
# Korkeus pelimaailmassa
Wymaasto = Wy/scale
screen = pygame.display.set_mode((Wx, Wy))
pygame.display.set_caption(
    "Morssari")
clock = pygame.time.Clock()
random.seed()
screen.fill(Tausta)
# Luodaan mörssäri ja vuori
vuori = Cl_vuori()
morssari = Cl_morssari()
kuulat = []

maali = Cl_maali(vuori.x1+2.0*vuori.leveys)

sirpaleet = []

loppu = False
MuistaVanhat = False
while not loppu:
    clock.tick(Nayttotaajuus)
    if not MuistaVanhat:
        screen.fill(Tausta)
    for event in pygame.event.get():
        # Lopetetaan peli sulkemalla ikkuna tai painamalla ESC
        if event.type ==  pygame.QUIT:
            loppu = True
        if event.type ==  pygame.KEYDOWN:
            if event.key ==  pygame.K_ESCAPE:
                loppu = True
            # Pyyhitäänkö peli-ikkuna puhtaaksi joka kierroksella vai ei
            if event.key ==  pygame.K_F1:
                MuistaVanhat = not MuistaVanhat
            # säädellään ajopanoksen ruutimäärää
            if event.key ==  pygame.K_KP_PLUS:
                morssari.add_ruuti(1)
            if event.key ==  pygame.K_KP_MINUS:
                morssari.add_ruuti(-1)
            # valitaan kuulan tyyppi
            if event.key ==  pygame.K_KP1:
                morssari.valitseKuula('puu')
            if event.key ==  pygame.K_KP2:
                morssari.valitseKuula('rauta')
            if event.key ==  pygame.K_KP3:
                morssari.valitseKuula('lyijy')
    # Suunnataan ja siirrellään mörssäriä
    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_UP]:
        morssari.asento(0.005*saatoaskel)
    if pressed[pygame.K_DOWN]:
        morssari.asento(-0.005*saatoaskel)
    if pressed[pygame.K_x]:
        morssari.liiku_x(saatoaskel)
    if pressed[pygame.K_z]:
        morssari.liiku_x(-saatoaskel)

    # Laukaistaan mörssäri
    if pressed[pygame.K_SPACE] and morssari.latausaika ==  0:
        kuulat.append(morssari.ammu())

    # Piirretään kaikki oliot peli-ikkunaan ja lasketaan kuulille ja
    # sirpaleille uudet paikat peli-ikkunassa
    morssari.piirra()
    vuori.piirra()

    if maali.ehja:
        maali.piirra()

#            kuula.piirra()
#            kuula.liiku()

    if not kuulat ==  []:
        for k, kuula in enumerate(kuulat):

            kuula.liiku()
            kuula.piirra()

            if kuula.rajahtanyt:
                del kuulat[k]

    if not sirpaleet ==  []:
        for sirpale in sirpaleet:
            sirpale.liiku()
            sirpale.piirra()

    pygame.display.flip()
    # while silmukka päättyy tähän
pygame.quit()

def kiihtyvyys0():
    ax = 0.0
    ay = -g_maa
    return (ax, ay)

def kiihtyvyys(vx, vy, A, m):
    c = 0.15
    vx = vx - Tuuli  #  Kuu­lan vaaka­no­peus ilman suh­teen
    v2 = vx**2 + vy**2
    v = sqrt(v2)
    Fd = -c*A*v2/m
    ax = vx/v*Fd
    ay = vy/v*Fd-g_maa
    return (ax, ay)

        (ax, ay) = kiihtyvyys0()

        (ax, ay) = kiihtyvyys(vx, vy, A, M)

def hehku(color):
    (r, g, b) = color
    r = max(0, min(255, r + random.randint(-10, 10)))
    g = max(0, min(255, g + random.randint(-10, 10)))
    b = max(0, min(255, b + random.randint(-10, 10)))
    return (r, g, b)

    def piirra(self):
        if self.ehja:
            pygame.draw.ellipse(screen, self.vari, self.vaunu, 0)

    def osuma(self, x, y):
        if (self.ehja and y < self.korkeus and
          self.x < x < self.x + self.leveys):
            self.ehja = False

            for i in range(500):
                sirpaleet.append(Cl_sirpale(self.x, self.korkeus, self.vari))
            osuma_snd.play()

            return True
        else:
            return False

 #  Sir­pa­le
class Cl_sirpale:
    def __init__(self, x, y, color):
        self.x = x
        self.y = y
        self.sx = self.x*random.uniform(2, 12)/100.0
        self.sy = self.y*random.uniform(2, 12)/100.0
        self.paksuus = self.y*random.uniform(2, 12)/100.0
        self.A = self.sx*self.sy
        self.M = self.A*self.paksuus*random.uniform(500.0, 2000.0)
        self.color = color
        (self.vx, self.vy) = r_xy(random.uniform(0.5, pi-0.5),
                             random.uniform(10.0, 150.0))

    def piirra(self):
        (x, y) = xy_ruudulla(self.x, self.y)
        pygame.draw.rect(screen, self.color,
                         (x+int(self.sx/2), y+int(self.sy/2),
                          int(self.sx), int(self.sy)), 0)

    #  Sir­pa­leet liik­ku­vat sa­mal­la dy­na­mii­kal­la kuin kuu­lat­kin
    def liiku(self):
        if self.y > 2.0:

            self.sx = min(12, max(2, self.sx + random.randint(-2, 2)))
            self.sy = min(12, max(2, self.sy + random.randint(-2, 2)))
            self.color = hehku(self.color)

            (self.x, self.y, self.vx, self.vy) = integ_euler(
                        self.x, self.y, self.vx, self.vy, self.A, self.M)

        self.ruuti = min(11.0, max(1.0, self.ruuti + 2.0*m))

        morssari_snd.play()

            if self.rajahdysvaihe ==  0:
                kuula_snd.play()
                kuula_snd.fadeout(600)

pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=512)
osuma_snd = pygame.mixer.Sound(
    'Explosion_Ultra_Bass-Mark_DiAngelo-1810420658.wav')
morssari_snd = pygame.mixer.Sound('morssari.wav')
kuula_snd = pygame.mixer.Sound('kuula.wav')

sirpaleet = []

            if kuula.rajahtanyt:
                del kuulat[k]

    if not sirpaleet ==  []:
        for sirpale in sirpaleet:
            sirpale.liiku()
            sirpale.piirra()

# -*- coding: utf-8 -*-
import pygame
import random
from math import pi, cos, sin, sqrt
Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Kelt = (255, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Tausta = (160, 200, 255)
MaastoVari = (95, 95, 20)

# Peli-ikkuna päivitetään Nayttotaajuus kertaa sekunnissa
Nayttotaajuus = 48

# Tällä tykin säätö saadaan jouhevaksi kaikilla näyttötaajuuksilla
saatoaskel = 48.0/Nayttotaajuus

# Nopeutus = 1.0 ->  oikea "filmin" nopeus
Nopeutus = 5

Tuuli = random.uniform(-50.0, 50.0)
# Tuuli = -50.0

g_maa = 9.81  # putoamiskiihtyvyys
RKuula = 0.1  # kuulan säde metreinä

# Lasketaan, mihin tietty pelimaailman piste kuuluu peli-ikkunassa
def xy_ruudulla(xmaasto, ymaasto):
    xpikseli = int(xmaasto*scale)
    ypikseli = int(Wy-ymaasto*scale)
    return (xpikseli, ypikseli)

def xy_skaalaus(w, h):
    xpikseli = int(w*scale)
    ypikseli = int(h*scale)
    return (xpikseli, ypikseli)

def r_xy(kulma, r):
    return (r*cos(kulma), r*sin(kulma))

def kuulanMassa(tiheys):
    VKuula = 4/3*pi*RKuula**3
    return tiheys*VKuula

def kiihtyvyys(vx, vy, A, m):
    c = 0.15
    vx = vx - Tuuli  # Kuulan vaakanopeus ilman suhteen
    v2 = vx**2 + vy**2
    v = sqrt(v2)
    Fd = -c*A*v2/m
    ax = vx/v*Fd
    ay = vy/v*Fd-g_maa
    return (ax, ay)

# Siirtymä ja nopeuden muutos ajassa dt
def integ_euler(x, y, vx, vy, A, M):
    dt = 1.0/Nayttotaajuus
    for i in range(Nopeutus):

        (ax, ay) = kiihtyvyys(vx, vy, A, M)

        (x, y, vx, vy) = (x + vx*dt, y + vy*dt, vx + ax*dt, vy + ay*dt)
    return (x, y, vx, vy)

def hehku(color):
    (r, g, b) = color
    r = max(0, min(255, r + random.randint(-10, 10)))
    g = max(0, min(255, g + random.randint(-10, 10)))
    b = max(0, min(255, b + random.randint(-10, 10)))
    return (r, g, b)

# Vuori ja "tuuliviiri"
class Cl_vuori:
    def __init__(self):
        self.x1 = random.uniform(0.3*Wxmaasto, 0.6*Wxmaasto)
        self.leveys = 0.1*Wxmaasto
        self.h = random.uniform(0.0, 0.6*Wymaasto)
    def piirra(self):
        # Vuori
        (a, b) = xy_ruudulla(self.x1, self.h)
        (w, h) = xy_skaalaus(self.leveys, self.h)
        pygame.draw.rect(screen, MaastoVari, (a, b, w, h), 0)

        # Tuuliviirin masto
        tuulix = Tuuli/50.0*0.05*Wx
        mastonKorkeus = 0.05*Wy
        pygame.draw.line(screen, Musta, (a+w/2, b),
                         (a+w/2, b-mastonKorkeus), 4)
        # Tuuliviiri
        pygame.draw.line(screen, Sin, (a+w/2, b-mastonKorkeus),
                         (a+w/2+tuulix, b-mastonKorkeus), 12)

    # Tarkistetaan, onko kuula, jonka koordinaatit ovat x ja y osunut vuoreen
    def osuma(self, x, y):
        return y < self.h and self.x1 < x and x < self.x1 + self.leveys

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Maali
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_maali:
    def __init__(self, xmin):
        self.x = random.uniform(xmin, 0.95*Wxmaasto)
        self.y = 0.0
        self.leveys = 0.05*Wxmaasto
        self.korkeus = 0.03*Wymaasto
        (x, y) = xy_ruudulla(self.x, self.korkeus)
        (w, h) = xy_skaalaus(self.leveys, self.korkeus)
        self.vaunu = pygame.Rect(x, y, w, h)
        self.vari = (225, 255, 0)
        self.ehja = True

    def piirra(self):
        if self.ehja:
            pygame.draw.ellipse(screen, self.vari, self.vaunu, 0)
    def osuma(self, x, y):
        if (self.ehja and y < self.korkeus and
          self.x < x < self.x + self.leveys):
            self.ehja = False

            for i in range(500):
                sirpaleet.append(Cl_sirpale(self.x, self.korkeus, self.vari))
            osuma_snd.play()

            return True
        else:
            return False

# Sirpale
class Cl_sirpale:
    def __init__(self, x, y, color):
        self.x = x
        self.y = y
        self.sx = self.x*random.uniform(2, 12)/100.0
        self.sy = self.y*random.uniform(2, 12)/100.0
        self.paksuus = self.y*random.uniform(2, 12)/100.0
        self.A = self.sx*self.sy
        self.M = self.A*self.paksuus*random.uniform(500.0, 2000.0)
        self.color = color
        (self.vx, self.vy) = r_xy(random.uniform(0.5, pi-0.5),
                             random.uniform(10.0, 150.0))

    def piirra(self):
        (x, y) = xy_ruudulla(self.x, self.y)
        pygame.draw.rect(screen, self.color,
                         (x+int(self.sx/2), y+int(self.sy/2),
                          int(self.sx), int(self.sy)), 0)

    # Sirpaleet liikkuvat samalla dynamiikalla kuin kuulatkin
    def liiku(self):
        if self.y > 2.0:

            self.sx = min(12, max(2, self.sx + random.randint(-2, 2)))
            self.sy = min(12, max(2, self.sy + random.randint(-2, 2)))
            self.color = hehku(self.color)

            (self.x, self.y, self.vx, self.vy) = integ_euler(
                        self.x, self.y, self.vx, self.vy, self.A, self.M)

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Morssari
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_morssari:
    def __init__(self):
        self.x = 0.05*Wxmaasto
        self.y = 0.01*Wymaasto
        (w, h) = xy_skaalaus(0.05*Wxmaasto, 0.03*Wymaasto)
        self.w = w
        self.h = h
        self.ruuti = 1.0
        self.KuulanTiheys = 5000.0
        self.kuulanVari = Sin
        self.latausaika = Nayttotaajuus
        self.kulma = pi/7.0  # piipun asento
        self.p1x = 0.0  # piipun pään x-koordinaatti
        self.p1y = 0.0  # piipun pään y-koordinaatti
        self.vaunu = pygame.Rect(0, 0, w, h)

    def piirra(self):
        (x, y) = xy_ruudulla(self.x, self.y)
        # piirretään mörssärin piippu
        (sx, sy) = r_xy(self.kulma, 200.0)
        self.p1x = self.x + sx
        self.p1y = self.y + sy
        if self.latausaika > 0:
            self.latausaika = self.latausaika - 1
            vari = Musta
        else:
            vari = Pun
        pygame.draw.line(screen, vari, (x, y),
                         xy_ruudulla(self.p1x, self.p1y), 10)
        # Ajopanosten ruutimäärän osoitin
        pygame.draw.line(screen, Sin, (10, Wy),
                         (10, Wy-int(self.ruuti/12.0*Wy)), 8)
        # vaunu
        self.vaunu.center = (x-self.w/4, y)
        pygame.draw.ellipse(screen, Musta, self.vaunu, 0)

    # Vaunun liikuttelua z ja x näppäimillä.
    # Vaunulla ei pääse vuoren läpi ;-)
    def liiku_x(self, dx):
        self.x = self.x + dx
        if self.x > vuori.x1:
            self.x = 0.0

# num+ ja num- näppäimillä kutsutaan tätä metodia
    def add_ruuti(self, m):
        self.ruuti = min(11.0, max(1.0, self.ruuti + 0.5*m))

        self.ruuti = min(11.0, max(1.0, self.ruuti + 2.0*m))

# num-1, num-2 ja num-3 näppäimillä valitaan kuulan tyyppi
    def valitseKuula(self, tyyppi):
        if tyyppi ==  'puu':
            self.KuulanTiheys = 1000.0
            self.kuulanVari = Kelt
        elif tyyppi ==  'rauta':
            self.KuulanTiheys = 5000.0
            self.kuulanVari = Sin
        elif tyyppi ==  'lyijy':
            self.KuulanTiheys = 12000.0
            self.kuulanVari = Musta

# Käännetään piippua nuolinäppäimillä
    def asento(self, dkulma):
        self.kulma = self.kulma + dkulma

# laukaistaan mörssäri välilyöntinäppäimellä
    def ammu(self):

        morssari_snd.play()

        self.latausaika = random.randint(Nayttotaajuus/2, 2*Nayttotaajuus)
        M = kuulanMassa(self.KuulanTiheys)
        (vx, vy) = self.kuulan_alkunopeus(M)
        return Cl_ammus(self.p1x, self.p1y, vx, vy, M, self.kuulanVari)

    def kuulan_alkunopeus(self, M):
        Cv0 = 600.0
        v0 = Cv0*sqrt(self.ruuti/M)
        print("ruuti: {:2.1f}".format(self.ruuti),
              "kulma: {:2.1f}".format(self.kulma*180.0/pi),
              "massa: {:4.1f}".format(M),
              "nopeus: {:4.0f}".format(v0))
        return (v0*cos(self.kulma),
                v0*sin(self.kulma))

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Ammus
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
class Cl_ammus:
    def __init__(self, x, y, vx, vy, M, vari):
        self.x = x
        self.y = y
        self.vx = vx
        self.vy = vy
        self.M = M  # kg/m**3
        self.A = pi*RKuula**2
        self.vari = vari

        self.rajahdys = False
        self.rajahdysvaihe = 0
        self.rajahtanyt = 0

    def piirra(self):
        if self.rajahdys:
            vari = Pun
        else:
            vari = self.vari
        if not self.rajahtanyt:
            pygame.draw.circle(screen, vari,
                               xy_ruudulla(self.x, self.y), 5, 0)
            (a, b) = xy_ruudulla(self.x, self.y)
            (c, d) = xy_ruudulla(self.x-self.vx, self.y-self.vy)
            pygame.draw.line(screen, Kelt, (a, b), (c, d), 2)

    def liiku(self):
        self.rajahdys = (vuori.osuma(self.x, self.y) or (self.y < 20) or
                         maali.osuma(self.x, self.y))
        if not self.rajahdys:
            (self.x, self.y, self.vx, self.vy) = integ_euler(
                    self.x, self.y, self.vx, self.vy, self.A, self.M)

        else:
            self.vx = 0.0
            self.vy = 0.0

            self.rajahda()

    def rajahda(self):
        if self.rajahdysvaihe < Nayttotaajuus/2:

            if self.rajahdysvaihe ==  0:
                kuula_snd.play()
                kuula_snd.fadeout(600)

            self.rajahdysvaihe = self.rajahdysvaihe + 1
            for i in range(200):
                (p0x, p0y) = xy_ruudulla(self.x, self.y)
                (dx, dy) = r_xy(random.uniform(0, 2*pi),
                           self.rajahdysvaihe*random.uniform(0.25, 2.5))
                p1x = p0x + int(dx)
                p1y = p0y - int(dy)
                vari = (random.randint(160, 255),
                        random.randint(80, 255), 0)
                pygame.draw.line(screen, vari, (p0x, p0y), (p1x, p1y), 1)
        else:
            self.rajahtanyt = True

# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# Pääohjelma alkaa tästä
# = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
print("alku")
pygame.init()

pygame.mixer.init(frequency=22050, size=-16, channels=2, buffer=512)
osuma_snd = pygame.mixer.Sound(
    'Explosion_Ultra_Bass-Mark_DiAngelo-1810420658.wav')
morssari_snd = pygame.mixer.Sound('morssari.wav')
kuula_snd = pygame.mixer.Sound('kuula.wav')

pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä
D_Info = pygame.display.Info()
Wx = D_Info.current_w
Wy = int(0.9*D_Info.current_h)
# pelimaailman leveys "metreinä"
Wxmaasto = 5000.0
scale = Wx/Wxmaasto
# Korkeus pelimaailmassa
Wymaasto = Wy/scale
screen = pygame.display.set_mode((Wx, Wy))
pygame.display.set_caption(
    "Morssari")
clock = pygame.time.Clock()
random.seed()
screen.fill(Tausta)
# Luodaan mörssäri ja vuori
vuori = Cl_vuori()
morssari = Cl_morssari()
kuulat = []

maali = Cl_maali(vuori.x1+2.0*vuori.leveys)

sirpaleet = []

loppu = False
MuistaVanhat = False
while not loppu:
    clock.tick(Nayttotaajuus)
    if not MuistaVanhat:
        screen.fill(Tausta)
    for event in pygame.event.get():
        # Lopetetaan peli sulkemalla ikkuna tai painamalla ESC
        if event.type ==  pygame.QUIT:
            loppu = True
        if event.type ==  pygame.KEYDOWN:
            if event.key ==  pygame.K_ESCAPE:
                loppu = True
            # Pyyhitäänkö peli-ikkuna puhtaaksi joka kierroksella vai ei
            if event.key ==  pygame.K_F1:
                MuistaVanhat = not MuistaVanhat
            # säädellään ajopanoksen ruutimäärää
            if event.key ==  pygame.K_KP_PLUS:
                morssari.add_ruuti(1)
            if event.key ==  pygame.K_KP_MINUS:
                morssari.add_ruuti(-1)
            # valitaan kuulan tyyppi
            if event.key ==  pygame.K_KP1:
                morssari.valitseKuula('puu')
            if event.key ==  pygame.K_KP2:
                morssari.valitseKuula('rauta')
            if event.key ==  pygame.K_KP3:
                morssari.valitseKuula('lyijy')
    # Suunnataan ja siirrellään mörssäriä
    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_UP]:
        morssari.asento(0.005*saatoaskel)
    if pressed[pygame.K_DOWN]:
        morssari.asento(-0.005*saatoaskel)
    if pressed[pygame.K_x]:
        morssari.liiku_x(saatoaskel)
    if pressed[pygame.K_z]:
        morssari.liiku_x(-saatoaskel)

    # Laukaistaan mörssäri
    if pressed[pygame.K_SPACE] and morssari.latausaika ==  0:
        kuulat.append(morssari.ammu())

    # Piirretään kaikki oliot peli-ikkunaan ja lasketaan kuulille ja
    # sirpaleille uudet paikat peli-ikkunassa
    morssari.piirra()
    vuori.piirra()

    if maali.ehja:
        maali.piirra()

#            kuula.piirra()
#            kuula.liiku()

    if not kuulat ==  []:
        for k, kuula in enumerate(kuulat):

            kuula.liiku()
            kuula.piirra()

            if kuula.rajahtanyt:
                del kuulat[k]

    if not sirpaleet ==  []:
        for sirpale in sirpaleet:
            sirpale.liiku()
            sirpale.piirra()

    pygame.display.flip()
    # while silmukka päättyy tähän
pygame.quit()

 #  Peli-ik­ku­na päi­vi­te­tään Nayttotaajuus ker­taa se­kun­nis­sa
Nayttotaajuus = 48

Tuuli = random.uniform(-50.0, 50.0)
 #  Tuuli = -50.0

# -*- coding: utf-8 -*-
import pygame
import random
from math import pi, cos, sin, sqrt
Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Kelt = (255, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Harmaa = (128, 128, 128)
Keula = (0, 128, 255)
Pera = (255, 200, 0)
# Gravitaatiovakio
G = 6.674e-11
# Etäisyydellä r suunnassa kulma olevan pisteen
# x- ja y-koordinaatit
def rw_xy(r, kulma):
    return (r*cos(kulma), r*sin(kulma))

# Pelin ja simuloinnin ajoitus
# Nopeutus: Montako kertaa todellista nopeammin pelin
# halutaan etenevän
# Tscalea käytetään nopeutuksen sovittamisessa oikeaksi
class cl_Ajat:
    def __init__(self):
        self.Nopeutus = 2000.0
        self.Nayttotaajuus = 24
        self.Dt = 10.0
        self.Tscale = max(1, int(self.Nopeutus/self.Nayttotaajuus/self.Dt))

    def Hidasta(self):
        if self.Nopeutus > 4000:
            self.Nopeutus -= 4000
            self.Tscale = max(1, int(self.Nopeutus/self.Nayttotaajuus/self.Dt))
            self.aikaraportti(self.Tscale, self.Dt, self.Nayttotaajuus)
    def Nopeuta(self):
        self.Nopeutus += 4000
        self.Tscale = max(1, int(self.Nopeutus/self.Nayttotaajuus/self.Dt))
        self.aikaraportti(self.Tscale, self.Dt, self.Nayttotaajuus)
    def Reset(self):
        self.Nopeutus = 1
        self.Tscale = max(1, int(self.Nopeutus/self.Nayttotaajuus/self.Dt))
        self.aikaraportti(self.Tscale, self.Dt, self.Nayttotaajuus)
    def aikaraportti(self, Tsc, Dt, Nfrek):
        print('Aika kuluu ' + str(int(Tsc*Dt*Nfrek)) +
         ' kertaa todellista nopeammin')

# Pelimaailman kuvaaminen näytölle peli-ikkunaan.
# Kuvakulman ja zoomauksen säätelyä.
class Cl_Kamera:
    def __init__(self):
        self.focus = 'maa'
        self.Wx = 1.0e+9
        self.Wy = self.Wx
        self.Wx0 = 0.0
        self.Wy0 = 0.0
# Lasketaan mitä pikseliä näytöllä vastaa pelimaailman piste.
    def xy_naytolla(self, xy):
        scale = Wxnaytto/self.Wx
        (x, y) = xy
        xpikseli = int(Wxnaytto/2 + (x-self.Wx0)*scale)
        ypikseli = int(Wynaytto/2-(y-self.Wy0)*scale)
        return (xpikseli, ypikseli)
    def xy_skaalaus(self, w, h):
        scale = Wxnaytto/self.Wx
        xpikseli = int(w*scale)
        ypikseli = int(h*scale)
        return (xpikseli, ypikseli)
    def skaalaus(self, x):
        scale = Wxnaytto/self.Wx
        xpikseli = int(x*scale)
        return xpikseli
# Sidotaan näytön keskipiste joko Maahan tai Kuuhun
    def liiku(self):
        if self.focus == 'kuu':
            (self.Wx0, self.Wy0) = Kuu.paikka
        else:
            (self.Wx0, self.Wy0) = (0.0, 0.0)
    def zoom(self, z):
        self.Wx *= z
        self.Wy = self.Wx

# Maa. Käytetään todellisia fysikaalisia arvoja.
# Maa pysyy paikallaan pelimaailman keskipisteessä.
class Cl_Maa:
    def __init__(self):
        self.R = 6.37e+6
        self.M = 5.9737e+24
# Sininen ympyrä symboloi maata.
    def piirra(self):
        (xi, yi) = Kamera.xy_naytolla((0, 0))
        ri = Kamera.skaalaus(self.R)
        pygame.draw.circle(screen, Sin, (xi, yi), ri, 0)
# http://fi.wikipedia.org/wiki/Painovoima#Newtonin_painovoimalaki
    def vetovoima(self, xy, m):
        (x, y) = xy
        d = sqrt(x**2 + y**2)
        F = G*m*self.M/d**2
        Fx = -F*x/d
        Fy = -F*y/d
        return (Fx, Fy)
    def crash(self, pxy):
        return (dist(pxy, (0.0, 0.0)) < self.R)
# Kuu. Käytetään todellisia arvoja, paitsi massalle, jonka kasvatin
# moninkertaiseksi, että alus olisi helpompi ohjata Kuun kiertoradalle.
class Cl_Kuu:
    def __init__(self):
        self.R = 1.74e+6
#        self.M = 7.35e+22
        self.M = 18.0e+23  # moninkertainen massa
        self.distMaa = 3.844e+8
        self.kulma = 0.0  # Kuun paikka radallaan radiaaneina
        self.paikka = rw_xy(self.distMaa, self.kulma)
        self.w = 2*pi/(27.3*24.0*3600.0)  # kiertonopeus rad/s
# Kuuta symboloi keltainen ympyrä
    def piirra(self):
        (xi, yi) = Kamera.xy_naytolla(self.paikka)
        pygame.draw.circle(screen, Kelt, (xi, yi),
                           Kamera.skaalaus(self.R), 0)
# piirretään Kuun rata helpottamaan navigointia
        pygame.draw.circle(screen, Harmaa, Kamera.xy_naytolla((0, 0)),
                           Kamera.skaalaus(self.distMaa), 1)
# Kuu liikettä ei lasketa vetovoimalakien mukaan vaan se kiertää
# pakotettua ympyrärataa Maan ympäri.
    def liiku(self):
        self.kulma += self.w*Aika.Dt*Aika.Tscale
        self.paikka = rw_xy(self.distMaa, self.kulma)
    def vetovoima(self, xy, m):
        (x0, y0) = self.paikka
        (x1, y1) = xy
        dx = x1-x0
        dy = y1-y0
        d = sqrt(dx**2 + dy**2)
        F = G*m*self.M/d**2
        Fx = -F*dx/d
        Fy = -F*dy/d
        return (Fx, Fy)
    def crash(self, pxy):
        return (dist(pxy, self.paikka) < self.R)

##= = = = = = = = = = = = = = = = = = = = = = =
#
# Pääohjelma alkaa tästä
# = = = = = = = = = = = = = = = = = = = = = = =
# peli-ikkunan leveys näytöllä pikseleinä
pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä
D_Info = pygame.display.Info()
Wynaytto = int(1.0*D_Info.current_h)
Wxnaytto = Wynaytto
screen = pygame.display.set_mode((Wxnaytto, Wynaytto))
pygame.display.set_caption(
    "Matka Kuuhun")
pygame.init()
clock = pygame.time.Clock()
random.seed()
Kamera = Cl_Kamera()
Maa = Cl_Maa()
Kuu = Cl_Kuu()
Aika = cl_Ajat()

loppu = False
MuistaVanhat = False

while not loppu:

    if not MuistaVanhat:
        screen.fill(Musta)  # pyyhitään peli-ikkuna tyhjäksi
    for event in pygame.event.get():
        # Lopetetaan peli sulkemalla ikkuna tai painamalla ESC
        if event.type == pygame.QUIT:
            loppu = True
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_F1:
                MuistaVanhat = not MuistaVanhat

            if event.key == pygame.K_ESCAPE:
                loppu = True
            if event.key == pygame.K_KP_PLUS:
                Kamera.zoom(0.9)
            if event.key == pygame.K_KP_MINUS:
                Kamera.zoom(1.1)
            if event.key == pygame.K_m:
                Kamera.focus = 'maa'
            if event.key == pygame.K_k:
                Kamera.focus = 'kuu'
            if event.key == pygame.K_KP1:
                Aika.Nopeuta()
            if event.key == pygame.K_KP0:
                Aika.Hidasta()
            if event.key == pygame.K_KP_ENTER:
                Aika.Reset()

    Maa.piirra()
    Kuu.piirra()

    Kuu.liiku()
    Kamera.liiku()

    pygame.display.flip()
    clock.tick(Aika.Nayttotaajuus)
pygame.quit()

# -*- coding: utf-8 -*-
import pygame
import random
from math import pi, cos, sin, sqrt
Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Kelt = (255, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Harmaa = (128, 128, 128)
Keula = (0, 128, 255)
Pera = (255, 200, 0)
# Gravitaatiovakio
G = 6.674e-11
# Etäisyydellä r suunnassa kulma olevan pisteen
# x- ja y-koordinaatit
def rw_xy(r, kulma):
    return (r*cos(kulma), r*sin(kulma))

# Kahden pisteen välinen etäisyys
def dist(p1, p2):
    (x1, y1) = p1
    (x2, y2) = p2
    return sqrt((x2-x1)**2 + (y2-y1)**2)
# kiihtyvyys = Voima/massa, xy-tasossa
def Newton(F1, F2, F3, m):
    (f1x, f1y) = F1
    (f2x, f2y) = F2
    (f3x, f3y) = F3
    ax = (f1x+f2x+f3x)/m
    ay = (f1y+f2y+f3y)/m
    return (ax, ay)

# Kuun ja Maan vetovoimakentässä liikkuvan kappaleen
# kiihtyvyys. Riippu kappaleen paikasta, rakettimoottorin
# synnyttämästä voimasta ja kappaleen massasta
def kiihtyvyys(paikka, F, m):
    (x, y) = paikka
    Fmaa = Maa.vetovoima((x, y), m)
    Fkuu = Kuu.vetovoima((x, y), m)
    return Newton(Fmaa, Fkuu, F, m)
# paikan (x, y) ja nopeuden (vx, vy) derivaatat ajan suhteen
# (f1, f2, f3, f4)
# Ohjelma ei pysähdy, vaikka alus törmäisi Maahan tai Kuuhun.
# "Koukkaus" läheltä Maan ydintä aiheuttaa niin suuria kiihtyvyyksiä,
# että simulointi saattaa antaa epäfysikaalisia tuloksia.
# Siksi niistä varoitetaan.
def dfdt(yy, F, m):
    [x, y, vx, vy] = yy
    (ax, ay) = kiihtyvyys((x, y), F, m)
    if ax**2 + ay**2 > 300.0:
            Alus.warning((ax, ay))
    f1 = vx
    f2 = vy
    f3 = ax
    f4 = ay
    return [f1, f2, f3, f4]
# Paikan ja nopeuden muutokset ajassa Dt
# lasketaan Runge-Kutta algoritmilla
def rk(yy, m, F):
    yk1 = [0, 0, 0, 0]
    yk2 = [0, 0, 0, 0]
    yk3 = [0, 0, 0, 0]
    yy1 = [0, 0, 0, 0]
    kk1 = dfdt(yy, F, m)
    for i in range(4):
        yk1[i] = yy[i]+kk1[i]*Aika.Dt/2.0
    kk2 = dfdt(yk1, F, m)
    for i in range(4):
        yk2[i] = yy[i]+kk2[i]*Aika.Dt/2.0
    kk3 = dfdt(yk2, F, m)
    for i in range(4):
        yk3[i] = yy[i]+kk3[i]*Aika.Dt
    kk4 = dfdt(yk3, F, m)
    for i in range(4):
        yy1[i] = yy[i] + Aika.Dt/6.0*(kk1[i] +
                2.0*kk2[i] + 2.0*kk3[i] + kk4[i])
    return(yy1)

# Pelin ja simuloinnin ajoitus
# Nopeutus: Montako kertaa todellista nopeammin pelin
# halutaan etenevän
# Tscalea käytetään nopeutuksen sovittamisessa oikeaksi
class cl_Ajat:
    def __init__(self):
        self.Nopeutus = 2000.0
        self.Nayttotaajuus = 24
        self.Dt = 10.0
        self.Tscale = max(1, int(self.Nopeutus/self.Nayttotaajuus/self.Dt))

    def Hidasta(self):
        if self.Nopeutus > 4000:
            self.Nopeutus -= 4000
            self.Tscale = max(1, int(self.Nopeutus/self.Nayttotaajuus/self.Dt))
            self.aikaraportti(self.Tscale, self.Dt, self.Nayttotaajuus)
    def Nopeuta(self):
        self.Nopeutus += 4000
        self.Tscale = max(1, int(self.Nopeutus/self.Nayttotaajuus/self.Dt))
        self.aikaraportti(self.Tscale, self.Dt, self.Nayttotaajuus)
    def Reset(self):
        self.Nopeutus = 1
        self.Tscale = max(1, int(self.Nopeutus/self.Nayttotaajuus/self.Dt))
        self.aikaraportti(self.Tscale, self.Dt, self.Nayttotaajuus)
    def aikaraportti(self, Tsc, Dt, Nfrek):
        print('Aika kuluu ' + str(int(Tsc*Dt*Nfrek)) +
         ' kertaa todellista nopeammin')

# Pelimaailman kuvaaminen näytölle peli-ikkunaan.
# Kuvakulman ja zoomauksen säätelyä.
class Cl_Kamera:
    def __init__(self):
        self.focus = 'maa'
        self.Wx = 1.0e+9
        self.Wy = self.Wx
        self.Wx0 = 0.0
        self.Wy0 = 0.0
# Lasketaan mitä pikseliä näytöllä vastaa pelimaailman piste.
    def xy_naytolla(self, xy):
        scale = Wxnaytto/self.Wx
        (x, y) = xy
        xpikseli = int(Wxnaytto/2 + (x-self.Wx0)*scale)
        ypikseli = int(Wynaytto/2-(y-self.Wy0)*scale)
        return (xpikseli, ypikseli)
    def xy_skaalaus(self, w, h):
        scale = Wxnaytto/self.Wx
        xpikseli = int(w*scale)
        ypikseli = int(h*scale)
        return (xpikseli, ypikseli)
    def skaalaus(self, x):
        scale = Wxnaytto/self.Wx
        xpikseli = int(x*scale)
        return xpikseli
# Sidotaan näytön keskipiste joko Maahan tai Kuuhun
    def liiku(self):
        if self.focus == 'kuu':
            (self.Wx0, self.Wy0) = Kuu.paikka
        else:
            (self.Wx0, self.Wy0) = (0.0, 0.0)
    def zoom(self, z):
        self.Wx *= z
        self.Wy = self.Wx

# Maa. Käytetään todellisia fysikaalisia arvoja.
# Maa pysyy paikallaan pelimaailman keskipisteessä.
class Cl_Maa:
    def __init__(self):
        self.R = 6.37e+6
        self.M = 5.9737e+24
# Sininen ympyrä symboloi maata.
    def piirra(self):
        (xi, yi) = Kamera.xy_naytolla((0, 0))
        ri = Kamera.skaalaus(self.R)
        pygame.draw.circle(screen, Sin, (xi, yi), ri, 0)
# http://fi.wikipedia.org/wiki/Painovoima#Newtonin_painovoimalaki
    def vetovoima(self, xy, m):
        (x, y) = xy
        d = sqrt(x**2 + y**2)
        F = G*m*self.M/d**2
        Fx = -F*x/d
        Fy = -F*y/d
        return (Fx, Fy)
    def crash(self, pxy):
        return (dist(pxy, (0.0, 0.0)) < self.R)
# Kuu. Käytetään todellisia arvoja, paitsi massalle, jonka kasvatin
# moninkertaiseksi, että alus olisi helpompi ohjata Kuun kiertoradalle.
class Cl_Kuu:
    def __init__(self):
        self.R = 1.74e+6
#        self.M = 7.35e+22
        self.M = 18.0e+23  # moninkertainen massa
        self.distMaa = 3.844e+8
        self.kulma = 0.0  # Kuun paikka radallaan radiaaneina
        self.paikka = rw_xy(self.distMaa, self.kulma)
        self.w = 2*pi/(27.3*24.0*3600.0)  # kiertonopeus rad/s
# Kuuta symboloi keltainen ympyrä
    def piirra(self):
        (xi, yi) = Kamera.xy_naytolla(self.paikka)
        pygame.draw.circle(screen, Kelt, (xi, yi),
                           Kamera.skaalaus(self.R), 0)
# piirretään Kuun rata helpottamaan navigointia
        pygame.draw.circle(screen, Harmaa, Kamera.xy_naytolla((0, 0)),
                           Kamera.skaalaus(self.distMaa), 1)
# Kuu liikettä ei lasketa vetovoimalakien mukaan vaan se kiertää
# pakotettua ympyrärataa Maan ympäri.
    def liiku(self):
        self.kulma += self.w*Aika.Dt*Aika.Tscale
        self.paikka = rw_xy(self.distMaa, self.kulma)
    def vetovoima(self, xy, m):
        (x0, y0) = self.paikka
        (x1, y1) = xy
        dx = x1-x0
        dy = y1-y0
        d = sqrt(dx**2 + dy**2)
        F = G*m*self.M/d**2
        Fx = -F*dx/d
        Fy = -F*dy/d
        return (Fx, Fy)
    def crash(self, pxy):
        return (dist(pxy, self.paikka) < self.R)

# Kuualus
# Sijoitetaan Maan kiertoradalle ja lasketaan nopeus,
# jolla se pysyy kiertoradalla.
class Cl_Alus:
    def __init__(self):
        self.m = 10000.0
        self.F = (0.0, 0.0)  # ohjausrakettien aiheuttama voima
        self.paikka = (Maa.R + 10000.0e+3, 0.0)
        self.nopeus = (0.0, self.alkunopeus())

# Lasketaan sopiva nopeus yhtälöstä
# Keskipakoisvoima = Maan vetovoima
    def alkunopeus(self):
        (x, y) = self.paikka
        return sqrt(x*9.81*(Maa.R/x)**2)
# Piirretään alukseksi kaksivärinen jana,
# josta näkee aluksen asennon ja suunnan
# Huomaa, että näytöllä y kasvaa alaspäin.
    def piirra(self):
        (vx, vy) = self.nopeus
        v = sqrt(vx**2+vy**2)
        lx = int(vx/v*12.0)
        ly = int(vy/v*12.0)
        (xi, yi) = Kamera.xy_naytolla(self.paikka)
        pygame.draw.line(screen, Pera, (xi-lx, yi+ly), (xi, yi), 3)
        pygame.draw.line(screen, Keula, (xi, yi), (xi+lx, yi-ly), 3)

    def liiku(self):
        (x, y) = self.paikka
        (vx, vy) = self.nopeus
        for i in range(Aika.Tscale):
            [x, y, vx, vy] = rk([x, y, vx, vy], self.m, self.F)
        self.paikka = (x, y)
        self.nopeus = (vx, vy)
# Ohjaus tapahtuu näppäimistön nuolilla.
# z ja x näppäimillä boostattu ohjaus
# Ohjauksilla 'vasemmalle' ja 'oikealle' ei yleensä ole
# käyttöä
    def ohjaus(self, suunta):
        (vx, vy) = self.nopeus
        v = sqrt(vx**2+vy**2)
        F = 100.0
        if suunta == 'vas':  # Jarruta
            self.F = (-vx/v*F, -vy/v*F)
        if suunta == 'oik':  # Kiihdytä
            self.F = (vx/v*F, vy/v*F)
        if suunta == 'ylos':  # vasemmalle
            self.F = (-vy/v*F, vx/v*F)
        if suunta == 'alas':  # oikealle
            self.F = (vy/v*F, -vx/v*F)
        if suunta == 'z':  # Jarruta lujaa
            self.F = (-10.0*vx/v*F, -10.0*vy/v*F)
        if suunta == 'x':  # Kiihdytä lujaa
            self.F = (10.0*vx/v*F, 10.0*vy/v*F)
# Törmäys! Simulointi laskee ehkä väärin tämän tilanteen.
    def warning(self, a):
        print('Törmäys?')
        screen.fill(Pun)
        pygame.time.wait(10)

##= = = = = = = = = = = = = = = = = = = = = = =
#
# Pääohjelma alkaa tästä
# = = = = = = = = = = = = = = = = = = = = = = =
# peli-ikkunan leveys näytöllä pikseleinä
pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä
D_Info = pygame.display.Info()
Wynaytto = int(1.0*D_Info.current_h)
Wxnaytto = Wynaytto
screen = pygame.display.set_mode((Wxnaytto, Wynaytto))
pygame.display.set_caption(
    "Matka Kuuhun")
pygame.init()
clock = pygame.time.Clock()
random.seed()
Kamera = Cl_Kamera()
Maa = Cl_Maa()
Kuu = Cl_Kuu()
Aika = cl_Ajat()

Alus = Cl_Alus()

loppu = False
MuistaVanhat = False

while not loppu:

    Alus.F = (0.0, 0.0)

    if not MuistaVanhat:
        screen.fill(Musta)  # pyyhitään peli-ikkuna tyhjäksi
    for event in pygame.event.get():
        # Lopetetaan peli sulkemalla ikkuna tai painamalla ESC
        if event.type == pygame.QUIT:
            loppu = True
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_F1:
                MuistaVanhat = not MuistaVanhat

            if event.key == pygame.K_ESCAPE:
                loppu = True
            if event.key == pygame.K_KP_PLUS:
                Kamera.zoom(0.9)
            if event.key == pygame.K_KP_MINUS:
                Kamera.zoom(1.1)
            if event.key == pygame.K_m:
                Kamera.focus = 'maa'
            if event.key == pygame.K_k:
                Kamera.focus = 'kuu'
            if event.key == pygame.K_KP1:
                Aika.Nopeuta()
            if event.key == pygame.K_KP0:
                Aika.Hidasta()
            if event.key == pygame.K_KP_ENTER:
                Aika.Reset()

    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_RIGHT]:
        Alus.ohjaus('oik')
    if pressed[pygame.K_LEFT]:
        Alus.ohjaus('vas')
    if pressed[pygame.K_UP]:
        Alus.ohjaus('ylos')
    if pressed[pygame.K_DOWN]:
        Alus.ohjaus('alas')
    if pressed[pygame.K_z]:
        Alus.ohjaus('z')
    if pressed[pygame.K_x]:
        Alus.ohjaus('x')

    Maa.piirra()
    Kuu.piirra()

    Alus.piirra()

    Kuu.liiku()
    Kamera.liiku()

    Alus.liiku()
    if Maa.crash(Alus.paikka) or Kuu.crash(Alus.paikka):
        print('!!! Törmäys !!!')
        screen.fill(Pun)
        pygame.time.wait(10)
#        loppu = True

    pygame.display.flip()
    clock.tick(Aika.Nayttotaajuus)
pygame.quit()

 #  Kuun ja Maan veto­voima­ken­täs­sä liik­ku­van kap­pa­leen
 #  kiih­ty­vyys. Riippu kap­pa­leen pai­kas­ta, ra­ket­ti­moot­to­rin
 #  syn­nyt­tä­mäs­tä voi­mas­ta ja kap­pa­leen mas­sas­ta
def kiihtyvyys(paikka, F, m):
    (x, y) = paikka
    Fmaa = Maa.vetovoima((x, y), m)
    Fkuu = Kuu.vetovoima((x, y), m)
    return Newton(Fmaa, Fkuu, F, m)


 #  pai­kan (x, y) ja no­peu­den (vx, vy) de­ri­vaa­tat ajan suh­teen
 #  (f1, f2, f3, f4)
 #  Oh­jel­ma ei py­säh­dy, vaik­ka alus tör­mäi­si Maa­han tai Kuu­hun.
 #  "Kouk­kaus" lä­hel­tä Maan ydin­tä ai­heut­taa niin suu­ria kiih­ty­vyyk­siä,
 #  että si­mu­loin­ti saat­taa antaa epä­fy­si­kaa­li­sia tu­lok­sia.
 #  Siksi niis­tä va­roi­te­taan.
def dfdt(yy, F, m):
    [x, y, vx, vy] = yy
    (ax, ay) = kiihtyvyys((x, y), F, m)
    if ax**2 + ay**2 > 300.0:
            Alus.warning((ax, ay))
    f1 = vx
    f2 = vy
    f3 = ax
    f4 = ay
    return [f1, f2, f3, f4]


 #  Pai­kan ja no­peu­den muu­tok­set ajas­sa Dt
 #  las­ke­taan Runge-Kutta al­go­rit­mil­la
def rk(yy, m, F):
    yk1 = [0, 0, 0, 0]
    yk2 = [0, 0, 0, 0]
    yk3 = [0, 0, 0, 0]
    yy1 = [0, 0, 0, 0]
    kk1 = dfdt(yy, F, m)
    for i in range(4):
        yk1[i] = yy[i]+kk1[i]*Aika.Dt/2.0
    kk2 = dfdt(yk1, F, m)
    for i in range(4):
        yk2[i] = yy[i]+kk2[i]*Aika.Dt/2.0
    kk3 = dfdt(yk2, F, m)
    for i in range(4):
        yk3[i] = yy[i]+kk3[i]*Aika.Dt
    kk4 = dfdt(yk3, F, m)
    for i in range(4):
        yy1[i] = yy[i] + Aika.Dt/6.0*(kk1[i] +
                2.0*kk2[i] + 2.0*kk3[i] + kk4[i])
    return(yy1)

 #  Pelin ja si­mu­loin­nin ajoi­tus
 #  No­peu­tus: Mon­ta­ko ker­taa to­del­lis­ta no­peam­min pelin
 #  ha­lu­taan ete­ne­vän
 #  Tscalea käy­te­tään no­peu­tuk­sen so­vit­ta­mi­ses­sa oi­keak­si
class cl_Ajat:
    def __init__(self):
        self.Nopeutus = 2000.0
        self.Nayttotaajuus = 24
        self.Dt = 10.0
        self.Tscale = max(1, int(self.Nopeutus/self.Nayttotaajuus/self.Dt))

Alus = Cl_Alus()

    Alus.F = (0.0, 0.0)

    Alus.piirra()

    Alus.liiku()

    if Maa.crash(Alus.paikka) or Kuu.crash(Alus.paikka):
        print('!!! Törmäys !!!')
        screen.fill(Pun)
        pygame.time.wait(10)
 #         loppu = True

# -*- coding: utf-8 -*-
import pygame
import random
from math import pi, cos, sin, sqrt
Musta = (0, 0, 0)  # Mustassa ei ole mitään valoa
Sin = (0, 0, 255)  # vain sinistä
Pun = (255, 0, 0)
Vihr = (0, 255, 0)
Kelt = (255, 255, 0)
Valk = (255, 255, 255)  # valkoisessa on kaikenväristä valoa
Harmaa = (128, 128, 128)
Keula = (0, 128, 255)
Pera = (255, 200, 0)
# Gravitaatiovakio
G = 6.674e-11
# Etäisyydellä r suunnassa kulma olevan pisteen
# x- ja y-koordinaatit
def rw_xy(r, kulma):
    return (r*cos(kulma), r*sin(kulma))

# Kahden pisteen välinen etäisyys
def dist(p1, p2):
    (x1, y1) = p1
    (x2, y2) = p2
    return sqrt((x2-x1)**2 + (y2-y1)**2)
# kiihtyvyys = Voima/massa, xy-tasossa
def Newton(F1, F2, F3, m):
    (f1x, f1y) = F1
    (f2x, f2y) = F2
    (f3x, f3y) = F3
    ax = (f1x+f2x+f3x)/m
    ay = (f1y+f2y+f3y)/m
    return (ax, ay)

# Piirretään voiman suuntaa ja suuruutta kuvastava jana.
def nuoli(p0, Voima):
    (ix0, iy0) = p0
    (Fx, Fy) = Voima
    F = sqrt(Fx**2 + Fy**2)
# "ylipitkä" jana katkaistaan ja piirretään punaisella.
    if F > 600:
        color = Pun
        Fx = Fx/F*600.0
        Fy = Fy/F*600.0
    else:
        color = Vihr
    Fx = Fx*0.7
    Fy = Fy*0.7
# Huomaa, että näytöllä y kasvaa alaspäin, siksi -Fy.
    p1 = (ix0+Fx, iy0-Fy)
    pygame.draw.line(screen, color, p0, p1, 2)

# Kuun ja Maan vetovoimakentässä liikkuvan kappaleen
# kiihtyvyys. Riippu kappaleen paikasta, rakettimoottorin
# synnyttämästä voimasta ja kappaleen massasta
def kiihtyvyys(paikka, F, m):
    (x, y) = paikka
    Fmaa = Maa.vetovoima((x, y), m)
    Fkuu = Kuu.vetovoima((x, y), m)
    return Newton(Fmaa, Fkuu, F, m)
# paikan (x, y) ja nopeuden (vx, vy) derivaatat ajan suhteen
# (f1, f2, f3, f4)
# Ohjelma ei pysähdy, vaikka alus törmäisi Maahan tai Kuuhun.
# "Koukkaus" läheltä Maan ydintä aiheuttaa niin suuria kiihtyvyyksiä,
# että simulointi saattaa antaa epäfysikaalisia tuloksia.
# Siksi niistä varoitetaan.
def dfdt(yy, F, m):
    [x, y, vx, vy] = yy
    (ax, ay) = kiihtyvyys((x, y), F, m)
    if ax**2 + ay**2 > 300.0:
            Alus.warning((ax, ay))
    f1 = vx
    f2 = vy
    f3 = ax
    f4 = ay
    return [f1, f2, f3, f4]
# Paikan ja nopeuden muutokset ajassa Dt
# lasketaan Runge-Kutta algoritmilla
def rk(yy, m, F):
    yk1 = [0, 0, 0, 0]
    yk2 = [0, 0, 0, 0]
    yk3 = [0, 0, 0, 0]
    yy1 = [0, 0, 0, 0]
    kk1 = dfdt(yy, F, m)
    for i in range(4):
        yk1[i] = yy[i]+kk1[i]*Aika.Dt/2.0
    kk2 = dfdt(yk1, F, m)
    for i in range(4):
        yk2[i] = yy[i]+kk2[i]*Aika.Dt/2.0
    kk3 = dfdt(yk2, F, m)
    for i in range(4):
        yk3[i] = yy[i]+kk3[i]*Aika.Dt
    kk4 = dfdt(yk3, F, m)
    for i in range(4):
        yy1[i] = yy[i] + Aika.Dt/6.0*(kk1[i] +
                2.0*kk2[i] + 2.0*kk3[i] + kk4[i])
    return(yy1)

# Pelin ja simuloinnin ajoitus
# Nopeutus: Montako kertaa todellista nopeammin pelin
# halutaan etenevän
# Tscalea käytetään nopeutuksen sovittamisessa oikeaksi
class cl_Ajat:
    def __init__(self):
        self.Nopeutus = 2000.0
        self.Nayttotaajuus = 24
        self.Dt = 10.0
        self.Tscale = max(1, int(self.Nopeutus/self.Nayttotaajuus/self.Dt))

    def Hidasta(self):
        if self.Nopeutus > 4000:
            self.Nopeutus -= 4000
            self.Tscale = max(1, int(self.Nopeutus/self.Nayttotaajuus/self.Dt))
            self.aikaraportti(self.Tscale, self.Dt, self.Nayttotaajuus)
    def Nopeuta(self):
        self.Nopeutus += 4000
        self.Tscale = max(1, int(self.Nopeutus/self.Nayttotaajuus/self.Dt))
        self.aikaraportti(self.Tscale, self.Dt, self.Nayttotaajuus)
    def Reset(self):
        self.Nopeutus = 1
        self.Tscale = max(1, int(self.Nopeutus/self.Nayttotaajuus/self.Dt))
        self.aikaraportti(self.Tscale, self.Dt, self.Nayttotaajuus)
    def aikaraportti(self, Tsc, Dt, Nfrek):
        print('Aika kuluu ' + str(int(Tsc*Dt*Nfrek)) +
         ' kertaa todellista nopeammin')

# Pelimaailman kuvaaminen näytölle peli-ikkunaan.
# Kuvakulman ja zoomauksen säätelyä.
class Cl_Kamera:
    def __init__(self):
        self.focus = 'maa'
        self.Wx = 1.0e+9
        self.Wy = self.Wx
        self.Wx0 = 0.0
        self.Wy0 = 0.0
# Lasketaan mitä pikseliä näytöllä vastaa pelimaailman piste.
    def xy_naytolla(self, xy):
        scale = Wxnaytto/self.Wx
        (x, y) = xy
        xpikseli = int(Wxnaytto/2 + (x-self.Wx0)*scale)
        ypikseli = int(Wynaytto/2-(y-self.Wy0)*scale)
        return (xpikseli, ypikseli)
    def xy_skaalaus(self, w, h):
        scale = Wxnaytto/self.Wx
        xpikseli = int(w*scale)
        ypikseli = int(h*scale)
        return (xpikseli, ypikseli)
    def skaalaus(self, x):
        scale = Wxnaytto/self.Wx
        xpikseli = int(x*scale)
        return xpikseli
# Sidotaan näytön keskipiste joko Maahan tai Kuuhun
    def liiku(self):
        if self.focus == 'kuu':
            (self.Wx0, self.Wy0) = Kuu.paikka
        else:
            (self.Wx0, self.Wy0) = (0.0, 0.0)
    def zoom(self, z):
        self.Wx *= z
        self.Wy = self.Wx

# Kiintotahtiä taustaksi ja kiintopisteiksi
class cl_Tahdet:
    def __init__(self):
        self.tt = []
        for i in range(1000):
            self.tt.append((random.uniform(-8.0e+8, 8.0e+8),
                       random.uniform(-8.0e+8, 8.0e+8)))
    def piirra(self):
        for tahti in self.tt:
            p = Kamera.xy_naytolla(tahti)
            color = (random.randint(100, 255),
                     random.randint(100, 255),
                     random.randint(100, 255))
            # jana, jonka loppupiste ja alkupiste ovat samoja,
            # piirtyy näytölle pisteenä
            pygame.draw.line(screen, color, p, p, 1)

# Maa. Käytetään todellisia fysikaalisia arvoja.
# Maa pysyy paikallaan pelimaailman keskipisteessä.
class Cl_Maa:
    def __init__(self):
        self.R = 6.37e+6
        self.M = 5.9737e+24
# Sininen ympyrä symboloi maata.
    def piirra(self):
        (xi, yi) = Kamera.xy_naytolla((0, 0))
        ri = Kamera.skaalaus(self.R)
        pygame.draw.circle(screen, Sin, (xi, yi), ri, 0)
# http://fi.wikipedia.org/wiki/Painovoima#Newtonin_painovoimalaki
    def vetovoima(self, xy, m):
        (x, y) = xy
        d = sqrt(x**2 + y**2)
        F = G*m*self.M/d**2
        Fx = -F*x/d
        Fy = -F*y/d
        return (Fx, Fy)
    def crash(self, pxy):
        return (dist(pxy, (0.0, 0.0)) < self.R)
# Kuu. Käytetään todellisia arvoja, paitsi massalle, jonka kasvatin
# moninkertaiseksi, että alus olisi helpompi ohjata Kuun kiertoradalle.
class Cl_Kuu:
    def __init__(self):
        self.R = 1.74e+6
#        self.M = 7.35e+22
        self.M = 18.0e+23  # moninkertainen massa
        self.distMaa = 3.844e+8
        self.kulma = 0.0  # Kuun paikka radallaan radiaaneina
        self.paikka = rw_xy(self.distMaa, self.kulma)
        self.w = 2*pi/(27.3*24.0*3600.0)  # kiertonopeus rad/s
# Kuuta symboloi keltainen ympyrä
    def piirra(self):
        (xi, yi) = Kamera.xy_naytolla(self.paikka)
        pygame.draw.circle(screen, Kelt, (xi, yi),
                           Kamera.skaalaus(self.R), 0)
# piirretään Kuun rata helpottamaan navigointia
        pygame.draw.circle(screen, Harmaa, Kamera.xy_naytolla((0, 0)),
                           Kamera.skaalaus(self.distMaa), 1)
# Kuu liikettä ei lasketa vetovoimalakien mukaan vaan se kiertää
# pakotettua ympyrärataa Maan ympäri.
    def liiku(self):
        self.kulma += self.w*Aika.Dt*Aika.Tscale
        self.paikka = rw_xy(self.distMaa, self.kulma)
    def vetovoima(self, xy, m):
        (x0, y0) = self.paikka
        (x1, y1) = xy
        dx = x1-x0
        dy = y1-y0
        d = sqrt(dx**2 + dy**2)
        F = G*m*self.M/d**2
        Fx = -F*dx/d
        Fy = -F*dy/d
        return (Fx, Fy)
    def crash(self, pxy):
        return (dist(pxy, self.paikka) < self.R)

# Kuualus
# Sijoitetaan Maan kiertoradalle ja lasketaan nopeus,
# jolla se pysyy kiertoradalla.
class Cl_Alus:
    def __init__(self):
        self.m = 10000.0
        self.F = (0.0, 0.0)  # ohjausrakettien aiheuttama voima
        self.paikka = (Maa.R + 10000.0e+3, 0.0)
        self.nopeus = (0.0, self.alkunopeus())

        self.hanta = [self.paikka for i in range(201)]
        self.ptr = 0

# Lasketaan sopiva nopeus yhtälöstä
# Keskipakoisvoima = Maan vetovoima
    def alkunopeus(self):
        (x, y) = self.paikka
        return sqrt(x*9.81*(Maa.R/x)**2)
# Piirretään alukseksi kaksivärinen jana,
# josta näkee aluksen asennon ja suunnan
# Huomaa, että näytöllä y kasvaa alaspäin.
    def piirra(self):
        (vx, vy) = self.nopeus
        v = sqrt(vx**2+vy**2)
        lx = int(vx/v*12.0)
        ly = int(vy/v*12.0)
        (xi, yi) = Kamera.xy_naytolla(self.paikka)
        pygame.draw.line(screen, Pera, (xi-lx, yi+ly), (xi, yi), 3)
        pygame.draw.line(screen, Keula, (xi, yi), (xi+lx, yi-ly), 3)

# Ohjaamisen helpottamiseksi piirretään alukseen kohdistuvia voimia
# kuvaavat nuolet ja "häntä", joka auttaa hahmottamaan aluksen liikettä
        if not MuistaVanhat and PiirraVoimat:
            self.nuolet(self.paikka, self.F, self.m)
            self.piirraHanta()
    def nuolet(self, p0, F, m):
            Fmaa = Maa.vetovoima(p0, m)
            Fkuu = Kuu.vetovoima(p0, m)
            ip0 = Kamera.xy_naytolla(p0)
            nuoli(ip0, F)
            nuoli(ip0, Fmaa)
            nuoli(ip0, Fkuu)
# Hännän piirtämiseksi talletaan aluksen kulloinenkin paikka listaan
# ja piirretään piste kuhunkin listan pisteeseen.
    def piirraHanta(self):
        for p in self.hanta:
            ip = Kamera.xy_naytolla(p)
            pygame.draw.line(screen, Pera, ip, ip, 1)
        self.hanta[self.ptr] = self.paikka
        self.ptr += 1
        if self.ptr > 200:
            self.ptr = 0

    def liiku(self):
        (x, y) = self.paikka
        (vx, vy) = self.nopeus
        for i in range(Aika.Tscale):
            [x, y, vx, vy] = rk([x, y, vx, vy], self.m, self.F)
        self.paikka = (x, y)
        self.nopeus = (vx, vy)
# Ohjaus tapahtuu näppäimistön nuolilla.
# z ja x näppäimillä boostattu ohjaus
# Ohjauksilla 'vasemmalle' ja 'oikealle' ei yleensä ole
# käyttöä
    def ohjaus(self, suunta):
        (vx, vy) = self.nopeus
        v = sqrt(vx**2+vy**2)
        F = 100.0
        if suunta == 'vas':  # Jarruta
            self.F = (-vx/v*F, -vy/v*F)
        if suunta == 'oik':  # Kiihdytä
            self.F = (vx/v*F, vy/v*F)
        if suunta == 'ylos':  # vasemmalle
            self.F = (-vy/v*F, vx/v*F)
        if suunta == 'alas':  # oikealle
            self.F = (vy/v*F, -vx/v*F)
        if suunta == 'z':  # Jarruta lujaa
            self.F = (-10.0*vx/v*F, -10.0*vy/v*F)
        if suunta == 'x':  # Kiihdytä lujaa
            self.F = (10.0*vx/v*F, 10.0*vy/v*F)
# Törmäys! Simulointi laskee ehkä väärin tämän tilanteen.
    def warning(self, a):
        print('Törmäys?')
        screen.fill(Pun)
        pygame.time.wait(10)

##= = = = = = = = = = = = = = = = = = = = = = =
#
# Pääohjelma alkaa tästä
# = = = = = = = = = = = = = = = = = = = = = = =
# peli-ikkunan leveys näytöllä pikseleinä
pygame.display.init()
# Selvitetään peli-ikkunan koko näytöllä pikseleinä
D_Info = pygame.display.Info()
Wynaytto = int(1.0*D_Info.current_h)
Wxnaytto = Wynaytto
screen = pygame.display.set_mode((Wxnaytto, Wynaytto))
pygame.display.set_caption(
    "Matka Kuuhun")
pygame.init()
clock = pygame.time.Clock()
random.seed()
Kamera = Cl_Kamera()
Maa = Cl_Maa()
Kuu = Cl_Kuu()
Aika = cl_Ajat()

Alus = Cl_Alus()

tahdet = cl_Tahdet()

loppu = False
MuistaVanhat = False

PiirraVoimat = True

while not loppu:

    Alus.F = (0.0, 0.0)

    if not MuistaVanhat:
        screen.fill(Musta)  # pyyhitään peli-ikkuna tyhjäksi
    for event in pygame.event.get():
        # Lopetetaan peli sulkemalla ikkuna tai painamalla ESC
        if event.type == pygame.QUIT:
            loppu = True
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_F1:
                MuistaVanhat = not MuistaVanhat

            if event.key == pygame.K_F2:
                PiirraVoimat = not PiirraVoimat

            if event.key == pygame.K_ESCAPE:
                loppu = True
            if event.key == pygame.K_KP_PLUS:
                Kamera.zoom(0.9)
            if event.key == pygame.K_KP_MINUS:
                Kamera.zoom(1.1)
            if event.key == pygame.K_m:
                Kamera.focus = 'maa'
            if event.key == pygame.K_k:
                Kamera.focus = 'kuu'
            if event.key == pygame.K_KP1:
                Aika.Nopeuta()
            if event.key == pygame.K_KP0:
                Aika.Hidasta()
            if event.key == pygame.K_KP_ENTER:
                Aika.Reset()

    pressed = pygame.key.get_pressed()
    if pressed[pygame.K_RIGHT]:
        Alus.ohjaus('oik')
    if pressed[pygame.K_LEFT]:
        Alus.ohjaus('vas')
    if pressed[pygame.K_UP]:
        Alus.ohjaus('ylos')
    if pressed[pygame.K_DOWN]:
        Alus.ohjaus('alas')
    if pressed[pygame.K_z]:
        Alus.ohjaus('z')
    if pressed[pygame.K_x]:
        Alus.ohjaus('x')

    Maa.piirra()
    Kuu.piirra()

    Alus.piirra()

    tahdet.piirra()

    Kuu.liiku()
    Kamera.liiku()

    Alus.liiku()
    if Maa.crash(Alus.paikka) or Kuu.crash(Alus.paikka):
        print('!!! Törmäys !!!')
        screen.fill(Pun)
        pygame.time.wait(10)
#        loppu = True

    pygame.display.flip()
    clock.tick(Aika.Nayttotaajuus)
pygame.quit()

 #  Piir­re­tään voi­man suun­taa ja suu­ruut­ta ku­vas­ta­va jana.
def nuoli(p0, Voima):
    (ix0, iy0) = p0
    (Fx, Fy) = Voima
    F = sqrt(Fx**2 + Fy**2)
 #  "yli­pitkä" jana kat­kais­taan ja piir­re­tään pu­nai­sel­la.
    if F > 600:
        color = Pun
        Fx = Fx/F*600.0
        Fy = Fy/F*600.0
    else:
        color = Vihr
    Fx = Fx*0.7
    Fy = Fy*0.7
 #  Huo­maa, että näy­töl­lä y kas­vaa alas­päin, siksi -Fy.
    p1 = (ix0+Fx, iy0-Fy)
    pygame.draw.line(screen, color, p0, p1, 2)

 #  Kiintotahtiä taus­tak­si ja kiin­to­pis­teik­si
class cl_Tahdet:
    def __init__(self):
        self.tt = []
        for i in range(1000):
            self.tt.append((random.uniform(-8.0e+8, 8.0e+8),
                       random.uniform(-8.0e+8, 8.0e+8)))

    def piirra(self):
        for tahti in self.tt:
            p = Kamera.xy_naytolla(tahti)
            color = (random.randint(100, 255),
                     random.randint(100, 255),
                     random.randint(100, 255))
            #  jana, jonka loppu­piste ja alku­piste ovat sa­mo­ja,
            #  piir­tyy näy­töl­le pis­tee­nä
            pygame.draw.line(screen, color, p, p, 1)

        self.hanta = [self.paikka for i in range(201)]
        self.ptr = 0

tahdet = cl_Tahdet()

PiirraVoimat = True

            if event.key == pygame.K_F2:
                PiirraVoimat = not PiirraVoimat

    tahdet.piirra()

# -*- coding: utf-8 -*-
# = = = = = = = = = = = = = = = = = = = = = = = = = =
# import sys
# print "This is the name of the script: ", sys.argv[0]
# print "Number of arguments: ", len(sys.argv)
# print "The arguments are: " , str(sys.argv)
# = = = = = = = = = = = = = = = = = = = = = = = = = =

import re
import os
import sys
import ast
import time
import random
from pathlib import Path, PurePath
def tagline(tag, vari, vaihe, ln):
    if tag == 'shd':
        unique_id = projName + str(vaihe) + str(ln)
        tglin = '\n<section>\n<title id = "' + unique_id + '">'
    else:
        tglin = '\n<' + tag + ' mod = "' + vari + '">\n'
    return tglin
def tagline_s(tag, vari):
    tglin = '\n<' + tag + ' mod = "' + vari + '">\n'
    return tglin

def tarkistaVaihe_s(line, tag, vaihe):
    if not tag.group(1) == 'shd':
        attrs = re.findall(r"([0-9]*)-([0-9]*):([a-z])", line)
        for attr in attrs:
            if int(attr[0]) <= vaihe <= int(attr[1]):
                if attr[2] == 'z':
                    txt = False
                    code = True
                    vari = 'm'
                elif attr[2] == 'p':
                    txt = True
                    code = False
                    vari = 'p'
                else:
                    txt = True
                    code = True
                    vari = str(attr[2])
                tglin = tagline_s(tag.group(1), vari)
                return (txt, code, tglin)
    return (False, False, '')

def tarkistaVaihe_c(line, tag, vaihe, ln):
    if not tag.group(1) == 'txt':
        attrs = re.findall(r"([0-9]*)-([0-9]*):([a-z])", line)
        for attr in attrs:
            if int(attr[0]) <= vaihe <= int(attr[1]):
                if attr[2] == 'z':
                    code = True
                    vari = 'm'
                elif attr[2] == 'p':
                    code = True
                    vari = 'p'
                else:
                    code = True
                    vari = str(attr[2])
                tglin = tagline(tag.group(1), vari, vaihe, ln)
                return (code, tglin)
    return (False, '')

def tarkistaVaihe_py(line, tag, vaihe, ln):
    if tag.group(1) == 'cod':
        attrs = re.findall(r"([0-9]*)-([0-9]*):([a-z])", line)
        for attr in attrs:
            if int(attr[0]) <= vaihe <= int(attr[1]):
                if attr[2] == 'z':
                    code = True
                    vari = 'm'
                elif attr[2] == 'p':
                    code = False
                    vari = 'p'
                else:
                    code = True
                    vari = str(attr[2])
                tglin = tagline(tag.group(1), vari, vaihe, ln)
                return (code, tglin)
    return (False, '')

def endtag(tag, fout):
    if tag == 'shd':
        fout.write('\n</title>')
    elif not tag == '':
        fout.write('\n</' + tag + '>')
    return ''
def endtag_s(tag, fout):
    if not tag == '':
        fout.write('\n</' + tag + '>')
    return ''

def ilman_selityksia(fout, vaihe):
    with open(infil, 'r') as fin:
        ln = 0
        current = ''
        pr_cod = False
        for line in fin:
            ln = ln + 1
            tag = re.search(r"(?<=\# )(txt|cod|shd)", line)
            if tag:
                if pr_cod:
                    current = endtag(current, fout)
                (pr_cod, tagLine) = tarkistaVaihe_c(
                    line, tag, vaihe, ln)
                if pr_cod:
                    current = tag.group(1)
                    fout.write(tagLine)
            elif pr_cod:
                    fout.write(repl(line))
        current = endtag(current, fout)

def selitykset(fout, vaihe):
    with open(infil, 'r') as fin:
        ln = 0
        current = ''
        pr_txt = False
        for line in fin:
            ln = ln + 1
            tag = re.search(r"(?<=\# )(txt|cod|shd)", line)
            if tag:
                if pr_txt:
                    current = endtag_s(current, fout)
                (pr_txt, pr_cod, tagLine) = tarkistaVaihe_s(
                    line, tag, vaihe)
                if pr_txt:
                    current = tag.group(1)
                    fout.write(tagLine)
            elif pr_txt:
                    if current == 'txt':
                        fout.write(line)
                    elif current == 'cod':
                        alkuloppu = re.split(r"^#| #", line, maxsplit=1)
                        fout.write(repl(alkuloppu[0]))
                        if len(alkuloppu) > 1:
                            fout.write('<orange> # ' + repl(alkuloppu[1]) +
                                       '</orange>')
        current = endtag_s(current, fout)

def vain_koodi(progfil, vaihe):
    with open(infil, 'r') as fin:
        ln = 0
        pr_cod = False
        for line in fin:
            ln = ln + 1
            tag = re.search(r"(?<=\# )(txt|cod|shd)", line)
            if tag:
                (pr_cod, tagLine) = tarkistaVaihe_py(line, tag, vaihe, ln)
            elif pr_cod:
                    progfil.write(line)

def repl(line):
    return re.sub('<', '<', re.sub('>', '>', line))
def summary():
    with open(infil) as fd:
        file_contents = fd.read()
        module = ast.parse(file_contents)
        return ast.get_docstring(module)
def lisafileet(fout, curdir):
    narg = len(sys.argv)
    if narg > 3:
        fout.write(
            '\n<sp><iso>Lataa myös seuraavat, ellet ole vielä ladannut</iso></sp>')
        for i in range(3, narg):
            webref = PurePath('/webPy/', curdir, str(sys.argv[i]))
            fout.write(
                '\n<p><weblink id="l' + str(random.randint(100, 9999)) +
                '" webref="' + webref + ' type="downLoad">lisätiedosto: ' + str(sys.argv[i]) +
                '</weblink></p>')

def main():
    with open(xmlf, 'w') as fout:
        fout.write('<section>\n<title anchor="' + xmlf.as_posix() + '">' +
                   projName + '.py\n</title>\n')
        fout.write('\n<summary>')
        fout.write(summary())
        fout.write('\n<paivays>')
        fout.write(time.asctime(time.localtime(time.time())))
        fout.write('\n</paivays>')
        fout.write('\n</summary>')
        for vaihe in range(maxVaihe):
            ilman_selityksia(fout, vaihe)
            fout.write('<shd uid="h' + str(random.randint(100, 9999)) +
                       '">Selityksiä ylläolevaan</shd>')
            selitykset(fout, vaihe)
            pfname = projName+'_'+str(vaihe)+'.py'
            with open(pfname, 'w') as progfil:
                vain_koodi(progfil, vaihe)
            webroot = Path(os.path.expandvars("$WEBPY"))
            curdir = Path.cwd().relative_to(webroot)
            webref = PurePath('/webPy/', curdir, pfname).as_posix()
            fout.write(
                '<sp><iso><weblink  id="v' + str(random.randint(100, 9999)) +
                '" webref= "' + webref + '" type= "downLoad">Lataa tästä ohjelman tämän hetkinen versio: ' +
                pfname + '</weblink></iso></sp>')
            lisafileet(fout, curdir)
            fout.write('\n</section>\n')
        fout.write('\n</section >')

if len(sys.argv) > 1:
    projName = str(sys.argv[1])
    print(projName)
else:
    projName = 'ProjektiX'
if len(sys.argv) > 2:
    maxVaihe = int(sys.argv[2])
else:
    maxVaihe = 6
xmlf = PurePath(projName + '_code.xml')
infil = Path(projName + '.py')
summary()
if __name__ == "__main__":
    main()

<orange> #  -*- coding: utf-8 -*-
</orange>
<orange> #  = = = = = = = = = = = = = = = = = = = = = = = = = =
</orange><orange> #  import sys
</orange><orange> #  print "This is the name of the script: ", sys.argv[0]
</orange><orange> #  print "Number of arguments: ", len(sys.argv)
</orange><orange> #  print "The arguments are: " , str(sys.argv)
</orange><orange> #  = = = = = = = = = = = = = = = = = = = = = = = = = =
</orange>

import re
import os
import sys
import ast
import time
import random
from pathlib import Path, PurePath
def tagline(tag, vari, vaihe, ln):
    if tag == 'shd':
        unique_id = projName + str(vaihe) + str(ln)
        tglin = '\n<section>\n<title id = "' + unique_id + '">'
    else:
        tglin = '\n<' + tag + ' mod = "' + vari + '">\n'
    return tglin


def tagline_s(tag, vari):
    tglin = '\n<' + tag + ' mod = "' + vari + '">\n'
    return tglin

def tarkistaVaihe_s(line, tag, vaihe):
    if not tag.group(1) == 'shd':
        attrs = re.findall(r"([0-9]*)-([0-9]*):([a-z])", line)
        for attr in attrs:
            if int(attr[0]) <= vaihe <= int(attr[1]):
                if attr[2] == 'z':
                    txt = False
                    code = True
                    vari = 'm'
                elif attr[2] == 'p':
                    txt = True
                    code = False
                    vari = 'p'
                else:
                    txt = True
                    code = True
                    vari = str(attr[2])
                tglin = tagline_s(tag.group(1), vari)
                return (txt, code, tglin)
    return (False, False, '')

def tarkistaVaihe_c(line, tag, vaihe, ln):
    if not tag.group(1) == 'txt':
        attrs = re.findall(r"([0-9]*)-([0-9]*):([a-z])", line)
        for attr in attrs:
            if int(attr[0]) <= vaihe <= int(attr[1]):
                if attr[2] == 'z':
                    code = True
                    vari = 'm'
                elif attr[2] == 'p':
                    code = True
                    vari = 'p'
                else:
                    code = True
                    vari = str(attr[2])
                tglin = tagline(tag.group(1), vari, vaihe, ln)
                return (code, tglin)
    return (False, '')

def tarkistaVaihe_py(line, tag, vaihe, ln):
    if tag.group(1) == 'cod':
        attrs = re.findall(r"([0-9]*)-([0-9]*):([a-z])", line)
        for attr in attrs:
            if int(attr[0]) <= vaihe <= int(attr[1]):
                if attr[2] == 'z':
                    code = True
                    vari = 'm'
                elif attr[2] == 'p':
                    code = False
                    vari = 'p'
                else:
                    code = True
                    vari = str(attr[2])
                tglin = tagline(tag.group(1), vari, vaihe, ln)
                return (code, tglin)
    return (False, '')

def endtag(tag, fout):
    if tag == 'shd':
        fout.write('\n</title>')
    elif not tag == '':
        fout.write('\n</' + tag + '>')
    return ''


def endtag_s(tag, fout):
    if not tag == '':
        fout.write('\n</' + tag + '>')
    return ''

def ilman_selityksia(fout, vaihe):
    with open(infil, 'r') as fin:
        ln = 0
        current = ''
        pr_cod = False
        for line in fin:
            ln = ln + 1
            tag = re.search(r"(?<=\# )(txt|cod|shd)", line)
            if tag:
                if pr_cod:
                    current = endtag(current, fout)
                (pr_cod, tagLine) = tarkistaVaihe_c(
                    line, tag, vaihe, ln)
                if pr_cod:
                    current = tag.group(1)
                    fout.write(tagLine)
            elif pr_cod:
                    fout.write(repl(line))
        current = endtag(current, fout)

def selitykset(fout, vaihe):
    with open(infil, 'r') as fin:
        ln = 0
        current = ''
        pr_txt = False
        for line in fin:
            ln = ln + 1
            tag = re.search(r"(?<=\# )(txt|cod|shd)", line)
            if tag:
                if pr_txt:
                    current = endtag_s(current, fout)
                (pr_txt, pr_cod, tagLine) = tarkistaVaihe_s(
                    line, tag, vaihe)
                if pr_txt:
                    current = tag.group(1)
                    fout.write(tagLine)
            elif pr_txt:
                    if current == 'txt':
                        fout.write(line)
                    elif current == 'cod':
                        alkuloppu = re.split(r"^#|<orange> # ", line, maxsplit=1)
</orange>                        fout.write(repl(alkuloppu[0]))
                        if len(alkuloppu) > 1:
                            fout.write('<orange><orange> #  ' + repl(alkuloppu[1]) +
</orange>                                       '</orange>')
        current = endtag_s(current, fout)

def vain_koodi(progfil, vaihe):
    with open(infil, 'r') as fin:
        ln = 0
        pr_cod = False
        for line in fin:
            ln = ln + 1
            tag = re.search(r"(?<=\# )(txt|cod|shd)", line)
            if tag:
                (pr_cod, tagLine) = tarkistaVaihe_py(line, tag, vaihe, ln)
            elif pr_cod:
                    progfil.write(line)

def repl(line):
    return re.sub('<', '<', re.sub('>', '>', line))


def summary():
    with open(infil) as fd:
        file_contents = fd.read()
        module = ast.parse(file_contents)
        return ast.get_docstring(module)


def lisafileet(fout, curdir):
    narg = len(sys.argv)
    if narg > 3:
        fout.write(
            '\n<sp><iso>Lataa myös seuraavat, ellet ole vielä ladannut</iso></sp>')
        for i in range(3, narg):
            webref = PurePath('/webPy/', curdir, str(sys.argv[i]))
            fout.write(
                '\n<p><weblink id="l' + str(random.randint(100, 9999)) +
                '" webref="' + webref + ' type="downLoad">lisätiedosto: ' + str(sys.argv[i]) +
                '</weblink></p>')

def main():
    with open(xmlf, 'w') as fout:
        fout.write('<section>\n<title anchor="' + xmlf.as_posix() + '">' +
                   projName + '.py\n</title>\n')
        fout.write('\n<summary>')
        fout.write(summary())
        fout.write('\n<paivays>')
        fout.write(time.asctime(time.localtime(time.time())))
        fout.write('\n</paivays>')
        fout.write('\n</summary>')
        for vaihe in range(maxVaihe):
            ilman_selityksia(fout, vaihe)
            fout.write('<shd uid="h' + str(random.randint(100, 9999)) +
                       '">Selityksiä ylläolevaan</shd>')
            selitykset(fout, vaihe)
            pfname = projName+'_'+str(vaihe)+'.py'
            with open(pfname, 'w') as progfil:
                vain_koodi(progfil, vaihe)

            webroot = Path(os.path.expandvars("$WEBPY"))
            curdir = Path.cwd().relative_to(webroot)
            webref = PurePath('/webPy/', curdir, pfname).as_posix()
            fout.write(
                '<sp><iso><weblink  id="v' + str(random.randint(100, 9999)) +
                '" webref= "' + webref + '" type= "downLoad">Lataa tästä ohjelman tämän hetkinen versio: ' +
                pfname + '</weblink></iso></sp>')
            lisafileet(fout, curdir)
            fout.write('\n</section>\n')
        fout.write('\n</section >')

if len(sys.argv) > 1:
    projName = str(sys.argv[1])
    print(projName)
else:
    projName = 'ProjektiX'

if len(sys.argv) > 2:
    maxVaihe = int(sys.argv[2])
else:
    maxVaihe = 6

xmlf = PurePath(projName + '_code.xml')
infil = Path(projName + '.py')

summary()

if __name__ == "__main__":
    main()