예제 #1
0
 /// <summary>
 /// Aliohjelma lisää pisteitä laskuriin, kun pelaaja osuu pelimerkkiin.
 /// </summary>
 /// <param name="pelaaja">Pelaajan hahmo.</param>
 /// <param name="pelimerkki">Tippuva pelimerkki.</param>
 private void Merkinotto(PhysicsObject pelaaja, PhysicsObject pelimerkki)
 {
     player = pelaaja as PlatformCharacter;
     pelaajanPisteet.Value += RandomGen.NextInt(200);
     Remove(pelimerkki);
     raha.Play();
 }
예제 #2
0
    void VoimaMittariTaynna()
    {
        int luku = RandomGen.NextInt(1, 5);

        int pallojatulossa = 0;

        if (luku == 1)
        {
            pallojatulossa = generoi1();
        }

        if (luku == 2)
        {
            pallojatulossa = generoi2();
        }
        if (luku == 3)
        {
            pallojatulossa = generoi3();
        }

        if (luku == 4)
        {
            pallojatulossa = generoi4();
        }
        if (luku == 5)
        {
            pallojatulossa = generoi5();
        }

        voimaMittari.Value    = 0.0;
        voimaMittari.MaxValue = pallojatulossa;
    }
예제 #3
0
    /// <summary>
    /// Palauttaa humalakertoimen avulla kerrotun arvon. Arvo voi kasvaa,
    /// pienentya, tai pysya ennallaan.
    /// </summary>
    /// <returns>Muutettu arvo.</returns>
    /// <param name="arvo">Arvo jota muututaan.</param>
    public static double HumalaKerroin(double arvo, DoubleMeter taso)
    {
        int    mitenMuuttuu = RandomGen.NextInt(-1, 1);
        double muutettuArvo = arvo + taso.Value * mitenMuuttuu * arvo;

        return(muutettuArvo);
    }
예제 #4
0
        public void TakeDamage(float damage)
        {
            Health = Utilities.Clamp(Health - damage, 0f, MaxHealth);
            if (Health == 0)
            {
                int deathAnimID = RandomGen.NextInt(1, 2);
                ChangeAnimationTo(Animations.BasicEnemy["death0" + deathAnimID], false);
                Animation.StopOnLastFrame = true;
                Animation.Played         += new Action(StopAttacking);

                //Create a shower of blood

                //int bloodAnimID = RandomGen.NextInt(1, 2);
                GameObject bloodSplash = new GameObject(128.0, 128.0);
                bloodSplash.Position = Position;
                //bloodSplash.Animation = Animations.Blood["Blood0" + bloodAnimID];
                bloodSplash.Animation = Animations.Blood["Blood01"];
                CurrentPlayer.CurrentGame.Add(bloodSplash);
                bloodSplash.Animation.Start(1);
                bloodSplash.Animation.StopOnLastFrame = true;

                //Create an expanding pool of blood

                int       bloodPoolID = RandomGen.NextInt(1, 2);
                BloodPool blood       = new BloodPool(1.0, 1.0);
                blood.Position = Position + MoveTarget * 48.0;
                blood.Angle    = RandomGen.NextAngle();
                blood.Image    = Game.LoadImage("Textures/Blood/blood0" + bloodPoolID);
                CurrentPlayer.CurrentGame.BloodPools.Add(blood);
                CurrentPlayer.CurrentGame.Add(blood, 0);

                Died(damage, MaxHealth);
            }
        }
예제 #5
0
    /// <summary>
    /// Luo meteoriitin ajastimen mukaan, ja arpoo sen y-koordinaatin.
    /// </summary>
    public void LuoMeteoriitti()
    {
        int luku = RandomGen.NextInt(1, 4);

        PhysicsObject meteoriitti = new PhysicsObject(50, 50);

        meteoriitti.Shape = Shape.Circle;
        meteoriitti.Image = LoadImage("Meteoriitti");
        meteoriitti.X     = pelaaja1.X + 310;

        if (luku == 1)
        {
            meteoriitti.Y = -35;
        }
        if (luku == 2)
        {
            meteoriitti.Y = 15;
        }
        if (luku == 3)
        {
            meteoriitti.Y = 70;                          // Y: Alin -35, Keskimmäinen n. 15, Ylin n. 70. X: P.X + 300
        }
        meteoriitti.IgnoresGravity = true;
        meteoriitti.Mass           = 100;
        meteoriitti.Tag            = "meteoriitti";
        meteoriitti.LifetimeLeft   = TimeSpan.FromSeconds(4.0);

        Vector vauhti = new Vector(-210.0, 0.0);

        meteoriitti.Move(vauhti);
        if (meteoriitti.X < 2220)
        {
            Add(meteoriitti);                          //Estää sen, että meteoriitti spawnaisi raketin taakse.
        }
    }
    /// <summary>
    /// Luodaan aliohjelma KaikkiKeratty, joka luo kultahippusateen laskurin saavuttaessa maksimiarvonsa.
    /// </summary>
    private void KaikkiKeratty()
    {
        ClearAll();

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

        Level.Background.CreateGradient(Color.White, Color.Gold);

        MessageDisplay.Add("Onnistuit keräämään kaikki lantit jäämättä kiinni verokarhulle! Paina Esc poistuaksesi.");

        Gravity = new Vector(0, -500);
        int i     = 0;
        int maara = 2000;

        while (i < maara)
        {
            int           sade  = RandomGen.NextInt(20, 20);
            double        x     = RandomGen.NextDouble(Level.Left + sade, Level.Right - sade);
            double        y     = RandomGen.NextDouble(Level.Bottom + sade, Level.Top - sade);
            Color         vari  = Color.Gold;
            PhysicsObject hippu = LuoHippu(x, y, vari, sade);
            Add(hippu, 1);
            i++;
        }
    }
예제 #7
0
    /// <summary>
    /// Luo ajastimen, joka tietyin aikavälin luo meteoriitteja.
    /// </summary>
    public void MeteoriittiAjastin()
    {
        meteoriAjastin          = new Timer();
        meteoriAjastin.Interval = 1.5;
        int luku = RandomGen.NextInt(1, 3);

        meteoriAjastin.Timeout += LuoMeteoriitti;
        meteoriAjastin.Start();
    }
예제 #8
0
    /// <summary>
    /// kutsutaan LuoPollo aliohjelmaa ja lisätään
    /// pöllö kentälle tietyin väliajoin
    /// </summary>
    void LisaaPollo()
    {
        int aika = RandomGen.NextInt(1, 3);

        lisaaPollo          = new Timer();
        lisaaPollo.Interval = aika;
        lisaaPollo.Timeout += PolloKutsu;
        lisaaPollo.Start();
    }
예제 #9
0
 public void AttackPlayer()
 {
     if (!Attacking)
     {
         Attacking = true;
         int attackAnimID = RandomGen.NextInt(1, 3);
         ChangeAnimationTo(Animations.BasicEnemy["attack0" + attackAnimID], false);
         Animation.Played += new Action(StopAttacking);
     }
 }
예제 #10
0
        /// <summary>
        /// Creates a new enemy with the given started animation
        /// </summary>
        /// <param name="player">Player instance</param>
        /// <param name="anim">Sprite to be given to the enemy</param>
        /// <returns></returns>
        public static Enemy FromAnimation(Player player, Animation anim)
        {
            Enemy e = new Enemy();

            e.Animation     = anim;
            e.CurrentPlayer = player;
            e.Animation.Start();
            e.Animation.Step(RandomGen.NextInt(1, 30));
            return(e);
        }
예제 #11
0
    /// <summary>
    /// Luo oikealle puolelle kenttää satunnaisesti alieneita nollasta neljään kappaletta
    /// </summary>
    private void LisaaVihuja()
    {
        int vihuMin = 0;
        int vihuMax = 5;

        for (int i = RandomGen.NextInt(vihuMin, vihuMax); i < 5; i++)
        {
            LuoVihu();
        }
    }
예제 #12
0
    public void LuoPyorailijat()
    {
        int    rndPyorat1 = RandomGen.NextInt(0, 15);
        int    rndPyorat2 = RandomGen.NextInt(0, 15);
        double rndY1      = RandomGen.NextDouble(-160, -190);
        double rndY2      = RandomGen.NextDouble(-200, -250);

        Pyorailija(pyorailijatKuva[rndPyorat1], -450, rndY1, 40, 20, new Vector(70, 0));
        Pyorailija(Image.Mirror(pyorailijatKuva[rndPyorat2]), 450, rndY2, 40, 20, new Vector(-50, 0));
        AddCollisionHandler(pyorailija, ObjektiOsuuSeinaan);
    }
예제 #13
0
    void luoulospaasy(Vector paikka, double leveys, double korkeus)
    {
        int           luku  = RandomGen.NextInt(4);
        PhysicsObject sulku = PhysicsObject.CreateStaticObject(50, 50);

        Add(sulku);
        sulku.Position = paikka;
        sulku.Color    = Color.Black;
        sulku.Tag      = "sulku" + luku;
        Lista.Add(4);
    }
예제 #14
0
        public Hullu(Image sprite) : base(sprite)
        {
            MaxHitpoints = RandomGen.NextInt(10) + 30;
            Vahinko      = 50;
            PisteArvo    = 3;

            Liikkumisnopeus = 200;
            Mass            = 350.0;

            Animation     = new Animation(Spritet);
            Animation.FPS = Animation.FPS / 3;
            Animation.Start();
        }
예제 #15
0
    /// <summary>
    /// Luodaan lumihiutale kentän ylälaitaan, valitaan kuva satunnaisesti taulukosta.
    /// </summary>
    private void LuoLumihiutale()
    {
        PhysicsObject hiutale = new PhysicsObject(2 * 10.0, 2 * 10.0, Shape.Circle);

        hiutale.Image     = hiutaleet[RandomGen.NextInt(0, hiutaleet.Length - 1)];
        hiutale.Y         = Level.Top - hiutale.Height / 2;
        hiutale.X         = RandomGen.NextDouble(Level.Left + hiutale.Width / 2, Level.Right - hiutale.Width / 2);
        hiutale.CanRotate = false;
        hiutale.Tag       = "hiutale";
        AddCollisionHandler(hiutale, alareuna, HiutalePutosiMaahan);
        AddCollisionHandler(hiutale, "vihollinen", HiutalePutosiMaahan);
        Add(hiutale);
    }
예제 #16
0
    /// <summary>
    /// Aliohjelma lisää peliin putoavan laatan.
    /// </summary>
    /// <param name="peli"></param>
    /// <param name="x">Laatan sijainti x-akselilla.</param>
    /// <param name="y">Laatan sijainti y-akselilla.</param>
    /// <param name="z">Laatan leveys.</param>
    private void PiirraSuorakulmio(PhysicsGame peli, double x, double y, double z)
    {
        suorakulmio          = new PhysicsObject(z, 15, Shape.Rectangle);
        suorakulmio.Position = new Vector(x, y);
        int kuva = RandomGen.NextInt(laatat.Length);

        suorakulmio.Image         = laatat[kuva];
        suorakulmio.LinearDamping = 0.75;
        suorakulmio.Mass          = 100000;
        peli.Add(suorakulmio);

        suorakulmio.Tag       = "laatta";
        suorakulmio.CanRotate = false;
    }
예제 #17
0
    /// <summary>
    /// Aliohjelma palauttaa pelimerkin taulukosta.
    /// </summary>
    /// <param name="peli"></param>
    /// <param name="x">Pelimerkin sijainti x-akselilla.</param>
    /// <param name="y">Pelimerkin sijainti y-akselilla.</param>
    private void Pelimerkit(PhysicsGame peli, double x, double y)
    {
        PhysicsObject pelimerkki = new PhysicsObject(35, 25, Shape.Rectangle);

        pelimerkki.Position = new Vector(x, y);
        pelimerkki.IgnoresCollisionResponse = true;
        peli.Add(pelimerkki);

        pelimerkki.LinearDamping = 0.9;
        pelimerkki.Tag           = "pelimerkki";
        int kuva = RandomGen.NextInt(pelimerkit.Length);

        pelimerkki.Image = pelimerkit[kuva];
    }
예제 #18
0
    /// <summary>
    /// Silmukka arpoo montako kappaletta hedelmiä kentälle luodaan yhtäaikaa. Hedelmiä arvotaan 1-3 kpl.
    /// </summary>
    /// <param name="kuva">banaanin tai hedelmän kuva</param>
    private void LuoHedelma(Image kuva)
    {
        PhysicsObject hedelma;

        for (int i = 0; i < RandomGen.NextInt(MIN_HEDELMIEN_MAARA, MAX_HEDELMIEN_MAARA); i++)
        {
            hedelma       = new PhysicsObject(POHJAKOKO, POHJAKOKO);
            hedelma.Image = kuva;
            hedelma.X     = RandomGen.NextDouble(Level.Left, Level.Right);
            hedelma.Y     = Level.Top;
            AddCollisionHandler(hedelma, KasitteleHedelmanTormays);
            AddCollisionHandler(hedelma, "alareuna", KasitteleHedelmanAlaReunanTormays);
            Add(hedelma);
        }
    }
예제 #19
0
    //Ajastin1 kutsuu tätä aliohjelmaa tietyin väliajoin ja tiputtaa meteorin
    void TiputaMeteori1()
    {
        int koko = RandomGen.NextInt(20, 50);

        meteori1 = new PhysicsObject(koko, koko, Shape.Circle);
        //GameObject meteori1 = new GameObject(koko, koko, Shape.Circle);
        //PlatformCharacter meteori1 = new PlatformCharacter(koko, koko, Shape.Circle);
        //Tank meteori1 = new Tank(koko, koko);
        meteori1.X   = RandomGen.NextDouble(Level.Left, Level.Right);
        meteori1.Y   = Level.Top;
        meteori1.Tag = "meteori1";
        meteori1.IgnoresExplosions        = true;
        meteori1.IgnoresCollisionResponse = true;
        Add(meteori1);
    }
예제 #20
0
        public Käärme(Image sprite) : base(sprite)
        {
            MaxHitpoints = RandomGen.NextInt(4) + 2;
            PisteArvo    = 1;
            Vahinko      = 25;

            Liikkumisnopeus = 350;
            Mass            = 40.0;

            Debug.WriteLine("Vihulainen: " + X);

            Animation     = new Animation(Spritet);
            Animation.FPS = Animation.FPS / 3;
            Animation.Start();
        }
예제 #21
0
        public Koura(Image sprite) : base(sprite)
        {
            MaxHitpoints = RandomGen.NextInt(1) + 5;
            Vahinko      = 5;
            PisteArvo    = 1;

            CanRotate      = false;
            IgnoresGravity = true;

            Mass  = double.PositiveInfinity;
            Shape = Shape.Rectangle;

            //Y = Game.Level.Bottom - Height / 2;

            OnKuolema += VapautaPelaaja;
        }
예제 #22
0
    /// <summary>
    /// Aliohjelma generoi satunnaisia pilviä kenttään.
    /// </summary>
    public void LuoPilvia()
    {
        for (int i = 0; i < 4; i++)
        {
            PhysicsObject pilvi = new PhysicsObject(100, 40);

            pilvi.Y = pelaaja1.Y + 100;
            pilvi.X = RandomGen.NextInt(0, 2000);

            Add(pilvi);
            liikutettavat.Add(pilvi);

            pilvi.Image          = pilviKuva;
            pilvi.IgnoresGravity = true;
        }
    }
예제 #23
0
        /// <summary>
        /// Metodi vastaa vihollisen ampumisesta. Saa paramentrinaan tähtäämiseen käytetyn ajan, joka vaikuttaa vihollisen osumatarkkuuteen.
        /// Vihollisen osuessa saa aikaan VihollinenOsui-tapahtuman, jota peli-instanssi kuuntelee
        /// </summary>
        /// <param name="tahtaysAika">Tähtäämiseen käytetty aika sekunteina (ilman tason vaikeutuessa nousevan kertoimen vaikutusta)</param>
        private void Ammu(double tahtaysAika)
        {
            //Yritys keskeytetään jos kyseinen vihollinen on kuollut tai peli on päättynyt tähtäämisen aikana
            Console.WriteLine(this.Id + " yrittää ampua");
            if (!OnkoHengissa || !peli.OnkoKelloKaynnissa)
            {
                Console.WriteLine(Id + " ei ampunut; OnkoHengissä: " + OnkoHengissa + " OnkoKelloKäynnissä : " + peli.OnkoKelloKaynnissa);
                return;
            }
            //Ammutaan kohti pelaajaa
            Image = vihuKuvat[3];

            //Arvotaan osuuko vihollinen. Osumatarkkuus heikkenee jos tähtäykseen käytetty aika oli lyhyt.
            //Parametrina saatu tahtaysAika kertoo ainoastaan tähtäyksen keston randomoidun osuuden. Pelin vaikeutuminen ei vaikuta vihollisten osumatarkkuuteen.
            double osumatarkkuus = 1.0;

            if (tahtaysAika < 2.5 && tahtaysAika >= 2.0)
            {
                osumatarkkuus = 0.8;
            }
            if (tahtaysAika < 2)
            {
                osumatarkkuus = 0.5;
            }

            double random = RandomGen.NextDouble(0, 1.0);

            bool osuu = random < osumatarkkuus;

            if (osuu)
            {
                int laukausAani = RandomGen.NextInt(3) + 1;
                laukausAanet[laukausAani].Play();

                //Luo tapahtuman, jota peli-instanssi kuuntelee ja käsittelee tapahtuman
                VihollinenOsui();
                Console.WriteLine(Id + " osui pelaajaan. tahtays: " + tahtaysAika + "tarkkuus: " + osumatarkkuus + " random: " + random);
            }
            else
            {
                laukausAanet[0].Play();
                Console.WriteLine(Id + " ampui kohti pelaajaa, ei osunut. tahtays: " + tahtaysAika + "tarkkuus: " + osumatarkkuus + " random: " + random);
            }

            Timer.SingleShot(0.2, Piilota);
        }
예제 #24
0
    /// <summary>
    /// Määrittelee tapahtumat kun auringonkukansiemen koskettaa maalialuetta.
    /// Todennäköisyyksiä: arvotaan RandomGenillä numero. Jos saadaan tietty numero niin
    /// kutsutaan LuoSydan-aliohjelmaa.
    /// kutsutaan myös LuoSiemen ja Viestit-aliohjelmia.
    /// Lisätään bonusaikaa alaspainLaskuriin (eli peliaikalaskuriin)
    /// Soitetaan voittoisa ääni.
    /// Vähennetään montakoKoskettaa-attribuutista -1 (eli arvoksi tulee 0), jotta seuraavakin siemen voidaan poimia kyytiin.
    /// Siemen-olio tuhotaan.
    /// </summary>
    /// <param name="hahmo">Törmääjä (ruoka)</param>
    /// <param name="kohde">Törmättävä (maalialue)</param>
    private void RuokaTuodaanMaaliin(PhysicsObject hahmo, PhysicsObject kohde)
    {
        int numero;

        numero = RandomGen.NextInt(0, 4);
        if ((numero == 1) || (numero == 2))
        {
            LuoSydan();
        }
        LuoSiemen();
        Viestit(0);
        alaspainLaskuri.Value += pelinAsetuksia[1];
        Ruokalaskuri.Value++;
        loydaAarre.Play();
        koskettaakoSiementa = true;
        kohde.Destroy();
    }
예제 #25
0
        /// <summary>
        /// Arpoo pelaajalle mahdollisuuden saada bonus vihollisen kuoleman jälkeen. Vaatii refaktoroinnin.
        /// </summary>
        /// <param name="saadutPisteet">Viholliselta saadut pisteet, joista päätellään mihin kohtaan pelaaja osui. Bonuksen todennäköisyys kasvaa pääosuman jälkeen.</param>
        private void ArvoBonus(int saadutPisteet)
        {
            //Pelaaja voi saada pisteitä 50 tai 100, eli kerroin voi olla 1 tai 2. Kerroin on käänteinen, eli korkeampi kerroin pienentää mahdollisuuksia saada bonus.
            //Pääosuman jälkeen yksittäisen bonuksen todennäköisyys on 1:4, vartalo-osuman jälkeen 1:9.
            int kerroin = 100 / saadutPisteet;
            int bonus   = RandomGen.NextInt(5 * kerroin);

            if (bonus == 1 && Hitpoints < 5)
            {
                Hitpoints.Value += 1;
                Kayttoliittyma.NaytaViesti("Bonus: +1 HP", 1);
            }

            if (bonus == 2)
            {
                Ase.AktivoiBonus();
            }
        }
예제 #26
0
    /// <summary>
    /// Funktio luo ja palauttaa kooltaan annetulta kokoväliltä olevan asteroidin.
    /// </summary>
    /// <param name="kokoMin">Minimi koko</param>
    /// <param name="kokoMax">Maksimi koko</param>
    /// <returns>asteroidi</returns>
    private PhysicsObject LuoAsteroidit(int kokoMin, int kokoMax)
    {
        var asteroidi = new PhysicsObject(RandomGen.NextInt(kokoMin, kokoMax), RandomGen.NextInt(kokoMin, kokoMax));

        asteroidi.Position        = Level.GetRandomPosition();
        asteroidi.AngularVelocity = RandomGen.NextDouble(-0.05, 0.05);
        asteroidi.Hit(RandomGen.NextVector(-5, -5, 5, 5));
        asteroidi.Mass = 100;

        Image[] asteroidienKuvat = new Image[2] {
            asteroidi1, asteroidi2
        };
        int asteroidinKuva = RandomGen.NextInt(0, 2);

        asteroidi.Image = asteroidienKuvat[asteroidinKuva];
        Add(asteroidi);
        return(asteroidi);
    }
예제 #27
0
    void luoKentta(double leveys, double korkeus, int kentanNro)
    {
        Level.Width  = leveys;
        Level.Height = korkeus;

        Level.Background.Image = taustaKuva;
        Level.Background.FitToLevel();
        Gravity = new Vector(0, -1000.0);
        Mouse.IsCursorVisible = true;

        lattia                 = Level.CreateBottomBorder();
        lattia.Restitution     = 0.6;
        lattia.KineticFriction = 0.2;
        Level.CreateTopBorder();
        Level.CreateLeftBorder();
        Level.CreateRightBorder();

        luoPelaaja();
        luoPallo();
        luoKori();
        luoKenttaNaytto(kentanNro);
        luoVoimaMittari();

        if (kentanNro >= 2)
        {
            while (true)
            {
                korinSuunta = RandomGen.NextInt(-1, 2);
                if (korinSuunta != 0)
                {
                    break;
                }
            }
            korinSuunta = korinSuunta * kentanNro;
            liikkuvuusAjastin.Start();
        }

        Camera.ZoomToLevel();

#if WINDOWS_PHONE
        Camera.Follow(pallo);
        Camera.StayInLevel = true;
#endif
    }
예제 #28
0
    public void Luoautot()
    {
        int rndAuto1 = RandomGen.NextInt(0, 6);
        int rndAuto2 = RandomGen.NextInt(0, 6);
        int leveys   = 50;

        if (rndAuto1 == 0 || rndAuto1 == 3)
        {
            leveys = 100;
        }
        Auto(autotKuva [rndAuto1], -450, 45, leveys, 30, new Vector(110, 0));
        leveys = 50;
        if (rndAuto2 == 0 || rndAuto2 == 3)
        {
            leveys = 100;
        }
        Auto(Image.Mirror(autotKuva [rndAuto2]), 450, -50, leveys, 30, new Vector(-110, 0));
        AddCollisionHandler(auto, ObjektiOsuuSeinaan);
    }
예제 #29
0
        public void GetNextRandomPosition(out float3 position, out quaternion rotation, out float3 direction, out float speed,
                                          out int currentid, out float lerpPos, out float dir, out int lane)
        {
            currentid = RandomGen.NextInt(0, RoadSegments.Count);
            int fromid = RoadSegments[currentid].StartNodeId;
            int toid   = RoadSegments[currentid].EndNodeId;

            float laneWidth = RoadSegments[currentid].LaneWidth;
            int   laneCount = RoadSegments[currentid].LaneNumber;

            lane = RandomGen.NextInt(0, laneCount);

            Vector3 roadVec = RoadSegments[currentid].Direction;

            dir       = RoadSegments[currentid].IsOneWay == 1 ? 1.0f : (RandomGen.NextInt(0, 2) - 0.5f) * 2.0f;
            roadVec  *= dir;
            direction = roadVec.normalized;

            float3 offsetDir = math.cross(direction, new float3()
            {
                x = 0, y = 1, z = 0
            });
            float offset = (lane + 0.5f) * laneWidth;

            if (RoadSegments[currentid].IsOneWay == 1)
            {
                offset -= (laneCount / 2.0f) * laneWidth;
            }
            lerpPos  = RandomGen.NextFloat(0, 1);
            position = RoadNodes[toid].Position * lerpPos +
                       RoadNodes[fromid].Position * (1.0f - lerpPos);
            position += offsetDir * offset;

            Quaternion facing = Quaternion.LookRotation(roadVec, Vector3.up);

            rotation = facing;

            float2 speedRange = GetSpeedRange(RoadSegments[currentid].Level);

            speed  = RandomGen.NextFloat(speedRange.x, speedRange.y);
            speed /= 3.6f;//km/h to m/s;
        }
예제 #30
0
    public FollowerBrain Aivot2()
    {
        LabyrinthWandererBrain satunnaisAivot = new LabyrinthWandererBrain(40)
        {
            Speed            = RandomGen.NextDouble(80.0, 200.0),
            LabyrinthWallTag = "seina",
            TurnWhileMoving  = true
        };

        FollowerBrain lumikonAivotSeuraa = new FollowerBrain("myyra")
        {
            Speed               = RandomGen.NextInt(250, 350), // Millä nopeudella kohdetta seurataan
            DistanceFar         = RandomGen.NextInt(350, 550), // Etäisyys jolla aletaan seurata kohdetta
            DistanceClose       = 150,                         // Etäisyys jolloin ollaan lähellä kohdetta
            StopWhenTargetClose = false,                       // Pysähdytään kun ollaan lähellä kohdetta
            TurnWhileMoving     = true,
            FarBrain            = satunnaisAivot               // Käytetään satunnaisaivoja kun ollaan kaukana
        };

        return(lumikonAivotSeuraa);
    }