/// <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();
}
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;
}
/// <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);
}
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);
}
}
/// <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++;
}
}
/// <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();
}
/// <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();
}
public void AttackPlayer()
{
if (!Attacking)
{
Attacking = true;
int attackAnimID = RandomGen.NextInt(1, 3);
ChangeAnimationTo(Animations.BasicEnemy["attack0" + attackAnimID], false);
Animation.Played += new Action(StopAttacking);
}
}
/// <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);
}
/// <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();
}
}
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);
}
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);
}
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();
}
/// <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);
}
/// <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;
}
/// <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];
}
/// <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);
}
}
//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);
}
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();
}
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;
}
/// <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;
}
}
/// <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);
}
/// <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();
}
/// <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();
}
}
/// <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);
}
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
}
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);
}
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;
}
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);
}
