Esempio n. 1
0
        IEnumerable <int> poruszaj_losowo()
        {
            float kierunek = losowe.następny_float(0, MathHelper.TwoPi);

            while (true)
            {
                kierunek += losowe.następny_float(-0.1f, 0.1f);
                kierunek  = MathHelper.WrapAngle(kierunek);

                for (int i = 0; i < 6; i++)
                {
                    Prędkość   += Prędkość_math.z_krzywej(kierunek, 0.4f);
                    orientacja -= 0.05f;

                    var bounds = Start.rzutnia.Bounds;
                    bounds.Inflate(-obraz.Width, -obraz.Height);

                    if (!bounds.Contains(pozycja.do_punktu()))
                    {
                        kierunek = (Start.rozmiar_ekranu / 2 - pozycja).do_kąta() + losowe.następny_float(-MathHelper.PiOver2, MathHelper.PiOver2);
                    }

                    yield return(0);
                }
            }
        }
Esempio n. 2
0
        public void czy_zestrzelony()
        {
            punkty_uderzenia--;
            if (punkty_uderzenia <= 0)
            {
                czy_brak = true; 
            }

            const int liczba_cząstek = 150;
            float odcień = (float)((3 * Start.czas.TotalGameTime.TotalSeconds) % 6);
            float start = losowo.następny_float(0, MathHelper.TwoPi / liczba_cząstek); 
            Color kolor = Kolor_zmiana.zmiana_do_koloru(odcień, 0.25f, 1);

            for (int i = 0; i < liczba_cząstek; i++)
            {
                Vector2 pręd = Prędkość_math.z_krzywej(MathHelper.TwoPi * i / liczba_cząstek + start, losowo.następny_float(8, 16));
                Vector2 poz = pozycja + 2f * pręd;
                var state = new Cząstki_stan()
                {
                    Prędkość = pręd,
                    Mnożnik_długość = 1,
                    Typ = cząstki_typ.Zignoruj_grawitacje
                };

                Start.Cząstki_menadżer.stwórz_cząstkę(Tekstury.laser, poz, kolor, 90, 1.5f, state);
            }
        }
Esempio n. 3
0
        public override void Update() 
        {
            var jednostki = Jednostka_menadżer.pobierz_jednostki(pozycja, 250);

            foreach (var Jednostki in jednostki)
            {
                if (Jednostki is Przeciwnik && !(Jednostki as Przeciwnik).czy_aktywny)
                {
                    Jednostki.Prędkość += (Jednostki.pozycja - pozycja).skaluj_do(0.3f);
                }
                else
                {
                    var Poz = pozycja - Jednostki.pozycja;
                    var długość = Poz.Length();

                    Jednostki.Prędkość += Poz.skaluj_do(MathHelper.Lerp(2, 0, długość / 250f));
                }
            }

            if ((Start.czas.TotalGameTime.Milliseconds / 250) % 2 == 0)
            {
                Vector2 pręd = Prędkość_math.z_krzywej(kąt, losowo.następny_float(12, 15));
                Color kolor = Kolor_zmiana.zmiana_do_koloru(5, 0.5f, 0.8f); 
                Vector2 poz = pozycja + 2f * new Vector2(pręd.Y, -pręd.X) + losowo.następny_wektor(4, 8);
                var stan = new Cząstki_stan()
                {
                    Prędkość = pręd,
                    Mnożnik_długość = 1,
                    Typ = cząstki_typ.Przeciwnik
                };

                Start.Cząstki_menadżer.stwórz_cząstkę(Tekstury.laser, poz, kolor, 190, 1.5f, stan);
            }

            kąt -= MathHelper.TwoPi / 50f;
        }
Esempio n. 4
0
        public override void Update()
        {
            if (czy_nie_żyje)
            {
                if (Gracz_status.życia == 0)
                {
                    if (Keyboard.GetState().IsKeyDown(Keys.T))
                    {
                        klatek_do_pojawienia_się = 120;
                        Gracz_status.Reset();
                        pozycja = Start.rozmiar_ekranu / 2;
                    }
                    else if (Keyboard.GetState().IsKeyDown(Keys.N))
                    {
                        gra.wyjdź();
                    }
                }
                else
                {
                    --klatek_do_pojawienia_się;
                }

                return;
            }
            const float szybkość = 8;

            Prędkość = szybkość * Sterowanie.pobierz_ruch();
            pozycja += Prędkość;
            pozycja  = Vector2.Clamp(pozycja, rozmiar / 2, Start.rozmiar_ekranu - rozmiar / 2);

            if (Prędkość.LengthSquared() > 0)
            {
                orientacja = Dodatki.do_kąta(Prędkość);
            }

            var cel = Sterowanie.pobierz_celownik();

            if (cel.LengthSquared() > 0 && klatki_pozostało <= 0)
            {
                klatki_pozostało = klatki_czas;
                float      cel_kąt  = Dodatki.do_kąta(cel);
                Quaternion cel_quat = Quaternion.CreateFromYawPitchRoll(0, 0, cel_kąt);

                float   losowy_spread = Dodatki.następny_float(losowo, -0.04f, 0.04f) + Dodatki.następny_float(losowo, -0.04f, 0.04f);
                Vector2 prędkość_p    = Prędkość_math.z_krzywej(cel_kąt + losowy_spread, 11f);

                Vector2 pęd = Vector2.Transform(new Vector2(25, -8), cel_quat);
                Jednostka_menadżer.dodaj(new Pocisk(pozycja + pęd, prędkość_p));

                pęd = Vector2.Transform(new Vector2(25, 8), cel_quat);
                Jednostka_menadżer.dodaj(new Pocisk(pozycja + pęd, prędkość_p));
                Zawartość.Dźwięk.Strzał.Play(0.2f, losowo.następny_float(-0.2f, 0.2f), 0);
            }

            if (klatki_pozostało > 0)
            {
                klatki_pozostało--;
            }
            strzał_powtarzalny();
            Prędkość = Vector2.Zero;
        }