source: 2013/23/Jon-ErikK/magnetaa.cs @ 3993

using System;
using System.Collections.Generic;
using Jypeli;
using Jypeli.Assets;
using Jypeli.Controls;
using Jypeli.Effects;
using Jypeli.Widgets;

public class magnetaa : PhysicsGame
{
    bool peliPaalla;
    bool asd;
    
    Image punainenPaikallaan;
    Image sininenPaikallaan;
    Image sininenAmmus;
    Image punainenAmmus;
    
    IntMeter pelaaja1Elamat;
    IntMeter pelaaja2Elamat;

    Pelaaja pelaaja1;    
    Pelaaja pelaaja2;

    PhysicsObject ylaraja;
    PhysicsObject alaraja;
    PhysicsObject oikearaja;
    PhysicsObject vasenraja;
    PhysicsObject asdin;

    List<Ammus> ammukset;

    Vector ylos = new Vector(0, 190);
    Vector alas = new Vector(0, -190);
    Vector oikea = new Vector(190, 0);
    Vector vasen = new Vector(-190, 0);
    
    public override void Begin()
    {
        peliPaalla = false;
        asd = false;
  
        Level.BackgroundColor=Color.Black;
        
        MultiSelectWindow alkuvalikko = new MultiSelectWindow("Magneta", "Aloita peli", "Poistu pelistä");
        Add(alkuvalikko);

        alkuvalikko.BorderColor = Color.White;
        alkuvalikko.ActiveColor = Color.White;
        alkuvalikko.SelectionColor = Color.Silver;
        alkuvalikko.Color = Color.Gray;

        Label vihje = new Label();
        vihje.Text = "+X- -Y- O = EasterEgg";
        vihje.X = 200;
        vihje.Y = -300;
        vihje.TextColor = Color.Red;

        Add(vihje);

        alkuvalikko.AddItemHandler(0, valivaihe);
        alkuvalikko.AddItemHandler(1, Exit);

    }

    public void valivaihe()
    {
        ClearGameObjects();

        luoPeli();
    }

    public void luoPeli()
    {
        peliPaalla = true;
        
        ammukset = new List<Ammus>();

        alustaKuvat();
        luoKentta(-300, 0, 300, 0, new Vector(0, 1), new Vector(0, 1));
        asetaNappaimet();
    }

    public void uudelleenkaynnistaPeli()
    {
        asd = false;
        asdin = null;
        ClearAll();
        Begin();
    }

    public void seuraavaPeli()
    {
        ClearGameObjects();
        luoPeli();
    }

    //pelikentän säätäminen alkaa

    public void luoKentta(double pelaaja1x, double pelaaja1y, double pelaaja2x, double pelaaja2y, Vector alkusuunta1, Vector alkusuunta2) {

        luoKentanOsat();
        
        pelaaja1 = luoPelaaja(pelaaja1x, pelaaja1y, alkusuunta1, 1);
        pelaaja2 = luoPelaaja(pelaaja2x, pelaaja2y, alkusuunta2, 2);

    }

    public void luoKentanOsat()
    {
        Level.BackgroundColor = Color.Black;

        luoTausta();
        luoKentanReunat();
        luoLaskurit();

    }

    public void luoKentanReunat()
    {
        alaraja = Level.CreateBottomBorder();
        alaraja.Color = Color.Charcoal;

        ylaraja = Level.CreateTopBorder();
        ylaraja.Color = Color.Charcoal;

        oikearaja = Level.CreateRightBorder();
        oikearaja.Color = Color.Charcoal;

        vasenraja = Level.CreateLeftBorder();
        vasenraja.Color = Color.Charcoal;


    }

    public void luoTausta()
    {
        GameObject sivusuorakulmio1 = new GameObject(300, Screen.Height);
        sivusuorakulmio1.Color = Color.Charcoal;
        sivusuorakulmio1.X = -650;
        sivusuorakulmio1.Y = 0;

        GameObject sivusuorakulmio2 = new GameObject(300, Screen.Height);
        sivusuorakulmio2.Color = Color.Charcoal;
        sivusuorakulmio2.X = 650;
        sivusuorakulmio2.Y = 0;

        Add(sivusuorakulmio1);
        Add(sivusuorakulmio2);

        GameObject tasoOikea = new GameObject(300, Level.Height);
        tasoOikea.Shape = Shape.Rectangle;
        tasoOikea.X =Level.Right-150;
        tasoOikea.Y = 0;
        tasoOikea.Color = Color.Silver;

        GameObject tasoVasen = new GameObject(300, Level.Height);
        tasoVasen.Shape = Shape.Rectangle;
        tasoVasen.X = Level.Left+150;
        tasoVasen.Y = 0;
        tasoVasen.Color = Color.Silver;

        Add(tasoOikea,-3);
        Add(tasoVasen,-3);
    }

    public void luoLaskurit()
    {
        pelaaja1Elamat = new IntMeter(5);
        Label pistenaytto1 = new Label();
        pistenaytto1.X = Screen.Left + 100;
        pistenaytto1.Y = Screen.Top - 130;
        pistenaytto1.Color = Color.Charcoal;
        pistenaytto1.TextColor = Color.White;

        pistenaytto1.BindTo(pelaaja1Elamat);

        pelaaja2Elamat = new IntMeter(5);
        Label pistenaytto2 = new Label();
        pistenaytto2.X = Screen.Right - 100;
        pistenaytto2.Y = Screen.Top - 130;
        pistenaytto2.Color = Color.Charcoal;
        pistenaytto2.TextColor = Color.White;

        pistenaytto2.BindTo(pelaaja2Elamat);

        Add(pistenaytto1);
        Add(pistenaytto2);

        Label pelaajan1 = luoTekstillinenLabel(Color.White, "Pelaajan 1 elamat");
        pelaajan1.X = Screen.Left + 110;
        pelaajan1.Y = Screen.Top - 100;

        Label pelaajan2 = luoTekstillinenLabel(Color.White, "Pelaajan 2 elamat");
        pelaajan2.X = Screen.Right - 110;
        pelaajan2.Y = Screen.Top - 100;

        Add(pelaajan1);
        Add(pelaajan2);

    }

    public Label luoTekstillinenLabel(Color tekstinVari, String teksti)
    {
        Label tekstikentta = new Label();
        tekstikentta.Text = teksti;
        tekstikentta.TextColor = tekstinVari;

        return tekstikentta;
    }

    public void alustaKuvat()
    {
        punainenAmmus = LoadImage("Panos_punainen");

        sininenAmmus = LoadImage("Panos_sininen");

        punainenPaikallaan = LoadImage("Peliukko_punainen_01");
        sininenPaikallaan = LoadImage("Peliukko_sininen_1");
    }

    public Pelaaja luoPelaaja(double x, double y, Vector alkusuunta, int numero) {

        Pelaaja pelaaja = new Pelaaja(x, y, alkusuunta, numero);
        pelaaja.Image = sininenPaikallaan;

        Add(pelaaja);

        return pelaaja;
    }

    //pelikentän säätö loppuu

    //Näppäimistön asetus
    
    public void asetaNappaimet() {
 
        Keyboard.Listen(Key.W, ButtonState.Down, asetaPelaajanSuuntaJaNopeus, null, pelaaja1, ylos);
        Keyboard.Listen(Key.W, ButtonState.Released, asetaPelaajanSuuntaJaNopeus, null, pelaaja1, Vector.Zero);
        Keyboard.Listen(Key.S, ButtonState.Down, asetaPelaajanSuuntaJaNopeus, null, pelaaja1, alas);
        Keyboard.Listen(Key.S, ButtonState.Released, asetaPelaajanSuuntaJaNopeus, null, pelaaja1, Vector.Zero);
        Keyboard.Listen(Key.A, ButtonState.Down, asetaPelaajanSuuntaJaNopeus, null, pelaaja1, vasen);
        Keyboard.Listen(Key.A, ButtonState.Released, asetaPelaajanSuuntaJaNopeus, null, pelaaja1, Vector.Zero);
        Keyboard.Listen(Key.D, ButtonState.Down, asetaPelaajanSuuntaJaNopeus, null, pelaaja1, oikea);
        Keyboard.Listen(Key.D, ButtonState.Released, asetaPelaajanSuuntaJaNopeus, null, pelaaja1, Vector.Zero);

        Keyboard.Listen(Key.C, ButtonState.Pressed, ammu, null, pelaaja1);
        Keyboard.Listen(Key.V, ButtonState.Pressed, vaihdaMagneettisuus, null, pelaaja1);
        Keyboard.Listen(Key.B, ButtonState.Pressed, luoTorni, null, pelaaja1);
        
        Keyboard.Listen(Key.Up, ButtonState.Down, asetaPelaajanSuuntaJaNopeus, null, pelaaja2, ylos);
        Keyboard.Listen(Key.Up, ButtonState.Released, asetaPelaajanSuuntaJaNopeus, null, pelaaja2, Vector.Zero);
        Keyboard.Listen(Key.Down, ButtonState.Down, asetaPelaajanSuuntaJaNopeus, null, pelaaja2, alas);
        Keyboard.Listen(Key.Down, ButtonState.Released, asetaPelaajanSuuntaJaNopeus, null, pelaaja2, Vector.Zero);
        Keyboard.Listen(Key.Left, ButtonState.Down, asetaPelaajanSuuntaJaNopeus, null, pelaaja2, vasen);
        Keyboard.Listen(Key.Left, ButtonState.Released, asetaPelaajanSuuntaJaNopeus, null, pelaaja2, Vector.Zero);
        Keyboard.Listen(Key.Right, ButtonState.Down, asetaPelaajanSuuntaJaNopeus, null, pelaaja2, oikea);
        Keyboard.Listen(Key.Right, ButtonState.Released, asetaPelaajanSuuntaJaNopeus, null, pelaaja2, Vector.Zero);

        Keyboard.Listen(Key.Period, ButtonState.Pressed, ammu, null, pelaaja2);
        Keyboard.Listen(Key.Comma, ButtonState.Pressed, vaihdaMagneettisuus, null, pelaaja2);
        Keyboard.Listen(Key.M, ButtonState.Pressed, luoTorni, null, pelaaja2);

        Keyboard.Listen(Key.O, ButtonState.Pressed, asding, null);



        Keyboard.Listen(Key.Escape, ButtonState.Pressed, ConfirmExit, "Lopeta peli");

    }

    //Näppäimistön asetus loppuu

    //Pelaajan ja ammuksen nopeuksien asettaminen

    public void asetaPelaajanSuuntaJaNopeus(Pelaaja pelaaja, Vector nopeus)
    {
        if (nopeus != Vector.Zero)
        {
            Vector apuyksikkovektori = new Vector(nopeus.X, nopeus.Y);
            apuyksikkovektori = apuyksikkovektori.Normalize();

            pelaaja.Animation.Start();

            pelaaja.Angle = apuyksikkovektori.Angle + Angle.FromDegrees(-90);

            maaritaPelaajanAmmuksenSuunta(apuyksikkovektori, pelaaja);
        }

        pelaaja.Velocity = nopeus;
    }

    public void maaritaPelaajanAmmuksenSuunta(Vector yksikkovektori, Pelaaja pelaaja)
    {
        if (yksikkovektori.X != 0 || yksikkovektori.Y != 0)
        {
            pelaaja.ammustenSuunta = yksikkovektori;
        }
    }

    //Pelaajan ja ammuksen nopeuden asetus loppuu

    //Ammuksen syntymä ja kuolema

    public void ammu(Pelaaja pelaaja)
    {  
        double apuX=pelaaja.ammustenSuunta.X * 40;
        double apuY=pelaaja.ammustenSuunta.Y * 40;

        luoUusiAmmus(pelaaja.X+apuX, pelaaja.Y+apuY, pelaaja.magneetinVari, pelaaja.ammustenSuunta);      
    }

    public void luoUusiAmmus(double x, double y, bool onkoMagneettinen, Vector suunta)
    {
        Ammus uusiAmmus = new Ammus(onkoMagneettinen, x, y);

        uusiAmmus.Velocity=suunta*250;
        uusiAmmus.X = x;
        uusiAmmus.Y = y;
        uusiAmmus.Angle += Angle.FromDegrees(-90);
        if (uusiAmmus.Magneettisuus)
        {
            uusiAmmus.Image = punainenAmmus;
        }
        else
        {
            uusiAmmus.Image = sininenAmmus;
        }
        
        AddCollisionHandler(uusiAmmus, osumaAmmuksella);        
        
        Add(uusiAmmus);

        ammukset.Add(uusiAmmus);

    }

    public void osumaAmmuksella(PhysicsObject ammus, PhysicsObject osuja)
    {
        Ammus ammus2 = (Ammus) ammus;

        for(int i=0;i<ammukset.Count;i++){
            if (ammukset[i] == osuja)
            {
                osuja.Destroy();
                Add(luoRajahdys(ammus.X, ammus.Y, 30));
                Add(luoRajahdys(osuja.X, osuja.Y, 30));
                ammus.Destroy();

                Ammus osuja2 = (Ammus)osuja;
                ammukset.Remove(ammus2);
                ammukset.Remove(osuja2);

                return;
            }
        }

        if (osuja == pelaaja2 || osuja == pelaaja1) {

            Pelaaja pelaaja = (Pelaaja)osuja;

            if (pelaaja == pelaaja1)
            {
                pelaaja1Elamat.Value -= 1;
                if (pelaaja1Elamat < 1)
                {
                    pelinLoppu(pelaaja);
                }
            }
            if(pelaaja == pelaaja2)
            {
                pelaaja2Elamat.Value -= 1;
                if (pelaaja2Elamat < 1)
                {
                    pelinLoppu(pelaaja);
                }
            }
            
            
            ammus.Destroy();
            Add(luoRajahdys(ammus.X, ammus.Y, 30));
            ammukset.Remove(ammus2);

            return;

        }

        if (osuukoReunaan(ammus2,osuja))
        {
            return;
        }

        for (int i = 0; i < pelaaja1.tornit.Count; i++)
        {
            if (pelaaja1.tornit[i] == osuja)
            {
                ammus.Destroy();
                Add(luoRajahdys(ammus.X, ammus.Y, 30));

                ammukset.Remove(ammus2);

                pelaaja1.tornit[i].elamat.Value -= 1;

                if (pelaaja1.tornit[i].elamat <= 0)
                {
                    osuja.Destroy();
                    Add(luoRajahdys(pelaaja1.tornit[i].X, pelaaja1.tornit[i].Y, 60));
                    pelaaja1.tornit.Remove(pelaaja1.tornit[i]);
                }

                return;
            }
        }

        for (int i = 0; i < pelaaja2.tornit.Count; i++)
        {
            if (pelaaja2.tornit[i] == osuja)
            {
                ammus.Destroy();

                Add(luoRajahdys(ammus.X, ammus.Y, 30));

                ammukset.Remove(ammus2);

                pelaaja2.tornit[i].elamat.Value -= 1;

                if (pelaaja2.tornit[i].elamat <= 0)
                {
                    Add(luoRajahdys(pelaaja2.tornit[i].X, pelaaja2.tornit[i].Y, 60));
                    
                    osuja.Destroy();
                    pelaaja2.tornit.Remove(pelaaja2.tornit[i]); 
                }

                return;
            }
        }

        if (osuja == asdin)
        {
            for (int i = 0; i < 10; i++)
            {
                bool randomtrue = RandomGen.NextBool();
                double randomX = RandomGen.NextDouble(Level.Left, Level.Right);
                double randomY = RandomGen.NextDouble(Level.Bottom, Level.Top);
                Vector vektori = RandomGen.NextVector(0,0);

                luoUusiAmmus(randomX, randomY, randomtrue, vektori);
            } 
        }

        
    }

    public Explosion luoRajahdys(double x, double y, double sade)
    {
        Explosion rajahdys = new Explosion(sade);
        rajahdys.X = x;
        rajahdys.Y = y;
        rajahdys.Force = 0;

        return rajahdys;
    }

    public bool osuukoReunaan(Ammus ammus, PhysicsObject osuja)
    {
        
        if (osuja == ylaraja)
        {
            ammus.Y = -ammus.Y + 11;
            Vector nopeus = ammus.Velocity;
            Timer.SingleShot(0.01, delegate { ammus.Velocity = nopeus; });

            return true;

        }

        if (osuja == alaraja)
        {
            ammus.Y = -ammus.Y - 11;
            Vector nopeus = ammus.Velocity;
            Timer.SingleShot(0.01, delegate { ammus.Velocity = nopeus; });

            return true;
        }

        if (osuja == oikearaja)
        {
            ammus.Destroy();
            ammukset.Remove(ammus);

            return true;

        }

        if (osuja == vasenraja)
        {
            ammus.Destroy();
            ammukset.Remove(ammus);

            return true;
        }

        return false;
    }

    //Ammuksen käsittely loppuu

    //Magneettisuuden vaihto alkaa

    public void vaihdaMagneettisuus(Pelaaja pelaaja)
    {
        if (pelaaja.magneetinVari)
            {
                pelaaja.magneetinVari = false;
                pelaaja.Image = LoadImage("Peliukko_sininen_1");
            }
        else
            {
                pelaaja.magneetinVari = true;
                pelaaja.Image = LoadImage("Peliukko_punainen_01");
            }


    }

    //Magneettisuuden vaihto loppuu

    //Tornilogiikka alkaa

    public void luoTorni(PhysicsObject pelaaja)
    {
        if (pelaaja == pelaaja1)
        {
            if (pelaaja1.tornit.Count < 5)
            {
                Add(pelaaja1.lisaaMagneettitorni());
            }
        }
        else
        {
            if (pelaaja2.tornit.Count < 5)
            {
                Add(pelaaja2.lisaaMagneettitorni());
            }
        }
    }

    //Tornilogiikka loppuu

    //Peli päivitys alkaa

    protected override void Update(Time time)
    {
        base.Update(time);
        if (peliPaalla)
        {
            tarkistaMagneetit();
            pelaajienTarkistus();
        }
        
    }

    public void tarkistaMagneetit()
    {
        
        for (int i = 0; i < ammukset.Count-1; i++)
        {
            for (int j = 1 + i; j < ammukset.Count; j++)
            {
                Vector voima = luoMagneettivektori(ammukset[i], ammukset[j]);
                Vector vastavoima = voima * -1;

                ammukset[i].Velocity = ammukset[i].Velocity + voima;
                ammukset[j].Velocity = ammukset[j].Velocity + vastavoima;

                ammukset[i].Angle = ammukset[i].Velocity.Angle + Angle.FromDegrees(-90);
                ammukset[j].Angle = ammukset[j].Velocity.Angle + Angle.FromDegrees(-90);
            }
        }

        for (int i = 0; i < pelaaja1.tornit.Count; i++)
        {
            for (int j = 0; j < ammukset.Count; j++)
            {
                Ammus ammus = ammukset[j];
                
                Vector voima = luoMagneettivektori(ammukset[j],pelaaja1.tornit[i]);

                ammus.Velocity = ammus.Velocity + voima;
            }
        }

        for (int i = 0; i < pelaaja2.tornit.Count; i++)
        {
            for (int j = 0; j < ammukset.Count; j++)
            {
                Vector voima = luoMagneettivektori(ammukset[j], pelaaja2.tornit[i]);

                ammukset[j].Velocity = ammukset[j].Velocity + voima;
            }
        }
    }

    public Vector luoMagneettivektori(Magneettisuus kohde1, Magneettisuus kohde2)
    {
        Vector palautettava = new Vector(kohde1.GetX()-kohde2.GetX(), kohde1.GetY()-kohde2.GetY());
        palautettava=palautettava.Normalize();

        double etaisyys = Math.Sqrt((kohde1.GetX() - kohde2.GetX())*(kohde1.GetX() - kohde2.GetX())+(kohde1.GetY() - kohde2.GetY())*(kohde1.GetY() - kohde2.GetY()));

        palautettava = (palautettava * kohde1.MagneetinVahvuus*kohde2.MagneetinVahvuus) / (etaisyys*etaisyys);

        if (!((kohde1.Magneettisuus && kohde2.Magneettisuus) || (!kohde1.Magneettisuus && !kohde2.Magneettisuus)))
        {
            palautettava = palautettava * -1;
        }

        return palautettava;
    }

    public void pelaajienTarkistus()
    {
        tarkistaPelaaja(pelaaja2);
        tarkistaPelaaja(pelaaja1);
    }

    public void tarkistaPelaaja(Pelaaja pelaaja)
    {
        if (pelaaja.X < Level.Left + 25)
        {
            pelaaja.X = Level.Left + 25;
            asetaPelaajanSuuntaJaNopeus(pelaaja, Vector.Zero);
        }
        else if(pelaaja.X>Level.Right - 25)
        {
            pelaaja.X = Level.Right - 25;
            asetaPelaajanSuuntaJaNopeus(pelaaja, Vector.Zero);
        }

        if (pelaaja.Y > Level.Top - 25)
        {
            pelaaja.Y = Level.Top - 25;
            asetaPelaajanSuuntaJaNopeus(pelaaja, Vector.Zero);
        }
        else if (pelaaja.Y < Level.Bottom + 25)
        {
            pelaaja.Y = Level.Bottom + 25;
            asetaPelaajanSuuntaJaNopeus(pelaaja, Vector.Zero);
        }

        if (pelaaja.X < 225 && pelaaja.X > -225)
        {
            if (pelaaja.X < 0)
            {
                pelaaja.X = -225;
                asetaPelaajanSuuntaJaNopeus(pelaaja, Vector.Zero);
            }
            else
            {
                pelaaja.X = 225;
                asetaPelaajanSuuntaJaNopeus(pelaaja, Vector.Zero);
            }
        }

        if (pelaaja.Y < -350 && pelaaja.X > 400 || pelaaja.X < -400) 
        {
            asd = true;
        }
    }

    public void asding()
    {
        if (asd&&asdin==null&&(pelaaja1.Y<-350||pelaaja2.Y<-350))
        {
            PhysicsObject asding = new PhysicsObject(100, 100);
            asding.Velocity = pelaaja1.Velocity;
            asding.Image = LoadImage("Peliukko(variton)_1");
            Add(asding);

            this.asdin = asding;
        }
    }

    //Päivitys loppuu

    //Pelin lopetus

    public void pelinLoppu(Pelaaja pelaaja)
    {

        Pelaaja ilmoitettava;
        
        if(pelaaja==pelaaja1)
        {
            ilmoitettava=pelaaja2;
        }
        else
        {
            ilmoitettava=pelaaja1;
        }

        ClearAll();

        Level.BackgroundColor = Color.Blue;
        
        Label voittajanilmoitus = luoTekstillinenLabel(Color.White,"Pelaaja "+ilmoitettava.pelaajanNumero+" voitti pelin!");
        voittajanilmoitus.X = 0;
        voittajanilmoitus.Y = 0;

        Add(voittajanilmoitus);

        Timer.SingleShot(2, delegate { uudelleenkaynnistaPeli(); });


    }

}

public interface Magneettisuus
{
    bool Magneettisuus { get; }
    double MagneetinVahvuus { get; }
    double GetX();
    double GetY();
}

public class Ammus : PhysicsObject, Magneettisuus
{
    
    private bool magneettisuus;
    public bool Magneettisuus { get { return magneettisuus; } }

    private double magneetinVahvuus;
    public double MagneetinVahvuus { get { return magneetinVahvuus; } }

    public Ammus(bool magneettisuus, double x, double y)
    :base(20,20)
    {
        this.magneettisuus = magneettisuus;
        this.magneetinVahvuus = 200;

        if (magneettisuus == true)
        {
            base.Color = Color.Red;
        }
        else
        {
            base.Color = Color.Blue;
        }

        base.Shape = Shape.Circle;
        base.X = x;
        base.Y = y;

       }

    public double GetY()
    {
        return base.Y;
    }

    public double GetX()
    {
        return base.X;
    }
}

public class Magneettitorni:PhysicsObject, Magneettisuus
{
    public IntMeter elamat;
    
    private bool magneettisuus;
    public bool Magneettisuus{get{return magneettisuus;}}

    private double magneetinVahvuus;
    public double MagneetinVahvuus{get{return magneetinVahvuus;}}

    public Magneettitorni(bool magneettisuus, double x, double y)
        :base(30,30)
    {
        this.magneettisuus = magneettisuus;
        this.magneetinVahvuus = 300;

        base.IgnoresPhysicsLogics = true;
        base.IgnoresCollisionResponse = true;
        base.Shape = Shape.Circle;
        base.X = x;
        base.Y = y;

        if (magneettisuus)
        {
            base.Color = Color.Red;
        }
        else
        {
            base.Color = Color.Blue;
        }

        elamat = new IntMeter(3);
    }

    public double GetX()
    {
        return base.X;
    }

    public double GetY()
    {
        return base.Y;
    }

}

public class Pelaaja : PhysicsObject
{
    public bool magneetinVari;
    public Vector ammustenSuunta;
    public int pelaajanNumero;

    public List<Magneettitorni> tornit;
    
    public Pelaaja(double x, double y, Vector ammustenSuunta, int pelaaja)
        :base(50,50)
    {
        magneetinVari = false;
        this.ammustenSuunta = ammustenSuunta;
        pelaajanNumero = pelaaja;

        tornit = new List<Magneettitorni>();

        base.X = x;
        base.Y = y;
        base.Color = Color.White;
        base.Shape = Shape.Circle;
        base.IgnoresCollisionResponse = true;
        base.IgnoresPhysicsLogics = true;
    }

    public Magneettitorni lisaaMagneettitorni()
    {
        Magneettitorni torni = new Magneettitorni(magneetinVari, base.X, base.Y);

        tornit.Add(torni);

        return torni;
    }
}