/// <summary>
/// Punkte Hinzufügen
/// </summary>
/// <param name="obj">Punkteobjekt</param>
public void AddScore(JumpAndRun.Item.Object obj)
{
scores.Add(obj);
}
/// <summary>
/// Ladet das Level, erstellt die Spielfigur
/// </summary>
/// <param name="levelXmlPath">XML Pfad des gewünschten Levels</param>
/// <param name="difficulty">Schwierigkeitsgrad</param>
/// <returns>Prüfung ob das Level geladen werden konnte</returns>
public bool Load(string levelXmlPath = "data/levels/jungle/level.xml", JumpAndRun.Difficulty difficulty = JumpAndRun.Difficulty.Normal)
{
if (String.IsNullOrEmpty(levelXmlPath))
{
return false;
}
GameStatus = GameStatus.Loading;
//string dir = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
//dir = dir + LevelXmlPath;
// Level Objekt deserialisieren und laden
FileStream stream;
//stream = new FileStream(dir, FileMode.Open);
stream = new FileStream(levelXmlPath, FileMode.Open);
XmlSerializer serializer = new XmlSerializer(typeof(Level));
level = (Level)serializer.Deserialize(stream);
stream.Close();
level.Deserialize();
if (!level.Load(difficulty))
{
return false;
}
level.Visibility(false);
// Spieler
Player.Scale = 0.7f;
Player.Attach = true;
Player.Gains = 0;
Player.Penalties = 0;
Sound.Sound sound = new Sound.Sound("data/sound/menu/Bing.mp3");
sound.Play();
// Levelende abfangen
level.LevelFinishedEvent += new Level.LevelFinished(LevelHasFinished);
GameStatus = GameStatus.LoadingComplete;
return true;
}
/// <summary>
/// Hinternis hinzufügen
/// </summary>
/// <param name="obj">Hinternisobjekt</param>
public void AddObstacle(JumpAndRun.Item.Object obj)
{
obstacles.Add(obj);
}
/// <summary>
/// Neutrales Objekt hinzufügen
/// </summary>
/// <param name="obj">Neutrales Objekt</param>
public void AddObject(JumpAndRun.Item.Object obj)
{
objects.Add(obj);
}
/// <summary>
/// Überprüft, ob das Objekt mit der Spielfigur Kollidiert
/// </summary>
/// <param name="player">Spielfigur</param>
/// <param name="dispose">Modell soll nach der Kollision versteckt werden</param>
/// <returns>Kollidiert Ja/Nein</returns>
public bool Collision(JumpAndRun.GameLogic.Player player, bool dispose)
{
// COLLISION DETECTION
System.Collections.Generic.Dictionary<uint, System.Collections.Generic.List<uint>> collisionList = new System.Collections.Generic.Dictionary<uint, System.Collections.Generic.List<uint>>();
uint length = View.Model.CollisionsTextLength();
System.Text.StringBuilder str = new System.Text.StringBuilder((int)length + 1);
View.Model.CollisionsText(str, str.Capacity); // Daten aus DLL holen
// str: 3;2 => 3 und 2 sind kollidiert
String collisionsString = str.ToString(); // Daten parsen
string[] models = collisionsString.Split(';');
foreach (string model in models)
{
if (model.Length == 0) return false;
string[] parts = model.Split(':');
if (model == Model.Id.ToString())
{
if (!player.Colided.Contains(Model.Id))
{
player.Colided.Add(Model.Id);
PlaySound();
if (dispose) this.Dispose();
else
{
// hervorheben
this.Model.Highlight(1f, 0, 0, 1f);
}
Model.CollisionGroup(0);
return true;
}
}
}
return false;
}
/// <summary>
/// Wählt aus allen zur Verfügung stehenden Segmenten zufällige aus. Dabei wird der Schwierigkeitsgrad sowie die gewünschte Mindestlänge berücksichtigt.
/// </summary>
/// <param name="difficulty">Schwierigkeitsgrad</param>
/// <param name="lengthInSeconds">Mindestlänge in Sekunden</param>
/// <param name="speed">Geschwindigkeit in m/s</param>
/// <returns>Liste der ausgewählten Segemente</returns>
private List<LevelSegment> ChooseRandomSegments(JumpAndRun.Difficulty difficulty, int lengthInSeconds, double speed)
{
double currentLength = 0; // in meter
int minDifficulty = AllAvailableSegments.Min(e => e.Severity); // einfachste vorhandene Schwierigkeit
int maxDifficulty = AllAvailableSegments.Max(e => e.Severity); // schwerste vorhandene Schwierigkeit
double nDifficulty = 0; // schwierigkeit auf einer Skala von min - max
switch (difficulty)
{
case JumpAndRun.Difficulty.Easy: nDifficulty = Math.Round((double)(maxDifficulty - minDifficulty) / 4.0) + minDifficulty; break; // 25%
case JumpAndRun.Difficulty.Normal: nDifficulty = Math.Round((double)(maxDifficulty - minDifficulty) / 2.0) + minDifficulty; break; // 50%
case JumpAndRun.Difficulty.Difficult: nDifficulty = Math.Round((double)(maxDifficulty - minDifficulty) / 4.0 * 3) + minDifficulty; break; // 75%
default: nDifficulty = Math.Round((double)(maxDifficulty - minDifficulty) / 2) + minDifficulty; break;
}
double standardDeviation = (maxDifficulty - minDifficulty) * 0.3; // Standardabweichung
// bei nur einem segment...
if (standardDeviation <= 0)
{
standardDeviation = 1;
}
List<LevelSegment> segmentList = new List<LevelSegment>();
while(true)
{
// Zufallszahl nach Gaussscher Normalverteilung mit nDifficulty als Durchschnitt
double d = (int)Math.Round(RandomNumberGenerator.GetNormal(nDifficulty, standardDeviation));
// min und max kontrollieren
if (d < minDifficulty) d = minDifficulty;
else if (d > maxDifficulty) d = maxDifficulty;
// Segment welches dieser Schwierigkeit am ehesten entspricht
LevelSegment segment = DeserializeSegment(GetSegmentWithDifficulty(d).FilePath);
segment.Deserialize();
segmentList.Add(segment);
// so lange Segmente hinzufügen, bis die gewünschte Länge erreicht wird.
if ((currentLength + segment.Length) / speed < lengthInSeconds)
{
currentLength += segment.Length;
}
else
{
break;
}
}
/*
List<double> l1 = new List<double>();
List<double> l2 = new List<double>();
List<double> l3 = new List<double>();
for (int i = 0; i < 100; i++)
{
double d = RandomNumberGenerator.GetNormal(3, 0.6);
if (d < 1.5)
{
l1.Add(d);
}
else if (d > 2.5)
{
l3.Add(d);
}
else
{
l2.Add(d);
}
}
log.Debug("l1: " + l1.Count);
log.Debug("l2: " + l2.Count);
log.Debug("l3: " + l3.Count);
*/
// Debug Log
log.Debug("****************************************************");
log.Debug("Level wird zufaellig erstellt.");
log.Debug(" Schwierigkeitsgrad: " + difficulty.ToString());
log.Debug(" Laenge: " + lengthInSeconds + "s");
log.Debug(" Geschwindigkeit: " + speed + "m/s \n");
log.Debug(" leichtester Abschnitt: " + minDifficulty);
log.Debug(" schwerster Abschnitt: " + maxDifficulty);
log.Debug(" angestrebter Durchschnittswert: " + nDifficulty + " Standardabweichung: " + standardDeviation);
log.Debug(" Durchschnittliche Schwierigkeit: " + (double)(segmentList.Sum(e => e.Severity) / (double)segmentList.Count));
log.Debug("****************************************************");
return segmentList;
}
/// <summary>
/// Level in der Anzeige erzeugen/laden
/// </summary>
/// <param name="severity">Schwierigkeitsgrad</param>
/// <returns>Prüfung ob die Operation durchgeführt werden konnte</returns>
public bool Load(JumpAndRun.Difficulty difficulty)
{
log.Info("Load Level: " + this.Name);
// min. 1 Segment muss vorhanden sein
if (AllAvailableSegments.Count < 1 || SegmentsStartEnd.Count < 2)
{
log.Warn("Keine Segment gefunden");
return false;
}
this.difficulty = difficulty;
// Event bei Start und Ende
SegmentsStartEnd[0].EnteredEvent += new LevelSegment.Entered(SegmentExited);
SegmentsStartEnd[1].EnteredEvent += new LevelSegment.Entered(SegmentExited);
SegmentsStartEnd[0].Visibility(true);
// Zufällig Segmente anhand der Schwierigkeit auswählen
RandomlyChosenSegments = ChooseRandomSegments(difficulty, LevelDuration, Speed);
// ausgewählte Segemente zufällig aneinanderreihen
RandomlyChosenSegments = ShuffleSegments(SegmentsStartEnd[0], SegmentsStartEnd[1], RandomlyChosenSegments);
// Segmente ins Spiel laden
foreach (LevelSegment segment in RandomlyChosenSegments)
{
if (!LoadNextSegment(segment))
{
return false;
}
}
return true;
}
