public static Knot generateInvalidKnot()
{
Edge[] edgeList = new Edge[] {
Edge.Up, Edge.Up, Edge.Up, Edge.Up
};
KnotMetaData metaData = new KnotMetaData ("Invalid", edgeList.Count<Edge>, null, null);
Knot invalidKnot = new Knot (metaData, edgeList);
return invalidKnot;
}
public static Knot generateComplexKnot(string name)
{
Edge[] edgeList = new Edge[] {
Edge.Up, Edge.Backward, Edge.Right, Edge.Forward, Edge.Down, Edge.Left
};
KnotMetaData metaData = new KnotMetaData (name, edgeList.Count<Edge>, null, null);
Knot complexKnot = new Knot (metaData, edgeList);
return complexKnot;
}
public static Knot coloredKnot(string name)
{
string content = "\nY#FF0000FF#\nZ#FF0000FF#\ny#FF0000FF#\nz#FF0000FF#";
content = name + content;
KnotStringIO stringIO = new KnotStringIO (content);
KnotMetaData metaData = new KnotMetaData (name, stringIO.Edges.ToList ().Count<Edge>, null, null);
Knot coloredKnot = new Knot (metaData, stringIO.Edges.ToList ());
return coloredKnot;
}
/// <summary>
/// Erstellt ein Challenge-Metadaten-Objekt mit einem gegebenen Namen und den Metadaten des Ausgangs- und Referenzknotens.
/// </summary>
public ChallengeMetaData(string name, KnotMetaData start, KnotMetaData target,
string filename, IChallengeIO format,
IEnumerable<KeyValuePair<string, int>> highscore)
{
Name = name;
Start = start;
Target = target;
Format = format ?? Format;
Filename = filename ?? Filename;
this.highscore = new List<KeyValuePair<string, int>> ();
if (highscore != null) {
foreach (KeyValuePair<string, int> entry in highscore) {
this.highscore.Add (entry);
}
}
}
// TODO (jemand): Wir brauchen hier noch eine bessere Lösung / Überladungen / Umgang mit "FakeKnots"
public static Knot generateSquareKnot(int EdgeLength, string name)
{
Edge[] edgeList = new Edge [EdgeLength * 4];
for (int i = 0; i < EdgeLength; i++) {
edgeList [i] = Edge.Up;
}
for (int i = EdgeLength; i < EdgeLength*2; i++) {
edgeList [i] = Edge.Right;
}
for (int i = EdgeLength *2; i < EdgeLength*3; i++) {
edgeList [i] = Edge.Down;
}
for (int i = EdgeLength *3; i < EdgeLength*4; i++) {
edgeList [i] = Edge.Left;
}
KnotMetaData metaData = new KnotMetaData (name, edgeList.Count<Edge>, null, null);
Knot squareKnot = new Knot (metaData, edgeList);
return squareKnot;
}
private void AddSavegameToList(string filename, KnotMetaData meta)
{
Log.Debug ("SavegameLoader_Tests: filename: ", filename, ", meta:", meta);
}
/// <summary>
/// Diese Methode wird für jede gefundene Spielstanddatei aufgerufen
/// </summary>
private void AddSavegameToList(string filename, KnotMetaData meta)
{
// Finde den Namen des Knotens
string name = meta.Name.Length > 0 ? meta.Name : filename;
// Erstelle eine Lamdafunktion, die beim Auswählen des Menüeintrags ausgeführt wird
Action<GameTime> preview = (time) => {
if (previewKnotMetaData != meta) {
RemoveGameComponents (time, knotInfo);
knotInfo.Clear ();
previewRenderer.RenderKnot (loader.FileFormat.Load (filename));
previewWorld.Camera.ResetCamera ();
previewKnotMetaData = meta;
startButton.IsVisible = true;
MenuEntry countEntry = new MenuEntry (
screen: this,
drawOrder: DisplayLayer.ScreenUI + DisplayLayer.MenuItem,
name: Localizer.Localize ("Edge Count: ") + previewKnotMetaData.CountEdges,
onClick: (t) => {}
);
countEntry.Enabled = false;
knotInfo.Add (countEntry);
if (filename.Contains (SystemInfo.SavegameDirectory)) {
MenuEntry deleteEntry = new MenuEntry (
screen: this,
drawOrder: DisplayLayer.ScreenUI + DisplayLayer.MenuItem,
name: "Delete",
onClick: (t) => deleteSavegame (filename, t)
);
deleteEntry.AddKey (Keys.Delete);
knotInfo.Add (deleteEntry);
}
AddGameComponents (time, knotInfo);
}
};
// Erstelle den Menüeintrag
MenuEntry button = new MenuEntry (
screen: this,
drawOrder: DisplayLayer.ScreenUI + DisplayLayer.MenuItem,
name: name,
onClick: preview
);
button.IsSelectable = true;
button.IsLocalized = false;
savegameMenu.Add (button);
}
/// <summary>
/// Diese Methode wird für jede gefundene Spielstanddatei aufgerufen
/// </summary>
private void AddSavegameToList(string filename, KnotMetaData meta)
{
// Finde den Namen des Knotens
string name = meta.Name.Length > 0 ? meta.Name : filename;
// Erstelle die Lamdafunktionen, die beim Auswählen des Menüeintrags ausgeführt werden
Action<GameTime> SelectStartKnot = (time) => {
selectedStartKnot = loader.FileFormat.Load (filename);
TryConstructChallenge ();
};
// Erstelle die Lamdafunktionen, die beim Auswählen des Menüeintrags ausgeführt werden
Action<GameTime> SelectTargetKnot = (time) => {
selectedTargetKnot = loader.FileFormat.Load (filename);
TryConstructChallenge ();
};
// Erstelle die Menüeinträge
MenuEntry buttonStart = new MenuEntry (
screen: this,
drawOrder: DisplayLayer.ScreenUI + DisplayLayer.MenuItem,
name: name,
onClick: SelectStartKnot
);
MenuEntry buttonTarget = new MenuEntry (
screen: this,
drawOrder: DisplayLayer.ScreenUI + DisplayLayer.MenuItem,
name: name,
onClick: SelectTargetKnot
);
buttonStart.IsSelectable = true;
buttonTarget.IsSelectable = true;
buttonStart.IsLocalized = false;
buttonTarget.IsLocalized = false;
startKnotMenu.Add (buttonStart);
targetKnotMenu.Add (buttonTarget);
}
/// <summary>
/// Lädt die Metadaten eines Knotens aus einer angegebenen Datei.
/// </summary>
public KnotMetaData LoadMetaData(string filename)
{
if (KnotMetaDataCache.ContainsKey (filename)) {
return KnotMetaDataCache [filename];
}
else {
KnotStringIO parser = new KnotStringIO (content: string.Join ("\n", FileUtility.ReadFrom (filename)));
return KnotMetaDataCache [filename] = new KnotMetaData (
name: parser.Name,
countEdges: () => parser.CountEdges,
format: this,
filename: filename
);
}
}
/// <summary>
/// Lädt die Metadaten einer Challenge aus einer angegebenen Datei.
/// </summary>
public ChallengeMetaData LoadMetaData(string filename)
{
string name = null;
KnotMetaData start = null;
KnotMetaData target = null;
IEnumerable<KeyValuePair<string, int>> highscore = null;
using (ZipFile zip = ZipFile.Read (filename)) {
foreach (ZipEntry entry in zip) {
string content = entry.ReadContent ();
// für die Datei mit dem Startknoten
if (entry.FileName.ToLower ().Contains ("start")) {
KnotStringIO parser = new KnotStringIO (content: content);
start = new KnotMetaData (parser.Name, () => parser.CountEdges, null, null);
}
// für die Datei mit dem Zielknoten
else if (entry.FileName.ToLower ().Contains ("target")) {
KnotStringIO parser = new KnotStringIO (content: content);
target = new KnotMetaData (parser.Name, () => parser.CountEdges, null, null);
}
// für die Datei mit dem Namen
else if (entry.FileName.ToLower ().Contains ("name")) {
name = content.Trim ();
}
// für die Datei mit den Highscores
else if (entry.FileName.ToLower ().Contains ("highscore")) {
highscore = parseHighscore (content.Split (new char[] {'\r','\n'}, StringSplitOptions.RemoveEmptyEntries));
}
}
}
if (name != null && start != null && target != null) {
Log.Debug ("Load challenge file: ", filename, " (name=", name, ",start=", start, ",target=", target, ",highscore=", highscore);
return new ChallengeMetaData (
name: name,
start: start,
target: target,
filename: filename,
format: this,
highscore: highscore
);
}
else {
throw new IOException (
"Error! Invalid challenge file: " + filename
+ " (name=" + name + ",start=" + start + ",target=" + target + ",highscore=" + highscore + ")"
);
}
}
public void Knot_Construct_Test()
{
Edge[] edges = new Edge[] {
Edge.Up, Edge.Left, Edge.Down, Edge.Right
};
string name = "test";
KnotMetaData metaData = new KnotMetaData (name: name, countEdges: () => edges.Length);
Knot knot = new Knot (metaData, edges);
Assert.AreEqual (knot.Count (), edges.Length, "Knotenlänge #1");
Assert.AreEqual (knot.MetaData.CountEdges, edges.Length, "Knotenlänge #2");
Assert.AreEqual (knot.Name, name, "Knotenname #1");
Assert.AreEqual (knot.MetaData.Name, name, "Knotenname #2");
Assert.Catch (() => {
KnotGenerator.generateInvalidKnot ();
}, "invalid Knot construction");
}
public void Knot_Move_Test()
{
Edge[] edges = new Edge[] {
Edge.Up, Edge.Left, Edge.Down, Edge.Right
};
string name = "test";
KnotMetaData metaData = new KnotMetaData (name: name, countEdges: () => edges.Length);
Knot knot = new Knot (metaData, edges);
knot.AddToSelection (edges [1]); // Edge.Left
Log.Debug ("Selected: ", knot.SelectedEdges);
bool success;
success = knot.IsValidDirection (direction: Direction.Left);
Assert.IsFalse (success);
success = knot.IsValidDirection (direction: Direction.Right);
Assert.IsFalse (success);
success = knot.IsValidDirection (direction: Direction.Up);
Assert.IsTrue (success);
success = knot.IsValidDirection (direction: Direction.Down);
Assert.IsTrue (success);
success = knot.IsValidDirection (direction: Direction.Forward);
Assert.IsTrue (success);
success = knot.IsValidDirection (direction: Direction.Backward);
Assert.IsTrue (success);
success = knot.Move (direction: Direction.Down, distance: 1);
Assert.IsFalse (success, "Nicht möglich! Knoten würde zu zwei Kanten zusammenfallen!");
success = knot.Move (direction: Direction.Left, distance: 1);
Assert.IsFalse (success, "Ungültige Richtung!");
success = knot.Move (direction: Direction.Right, distance: 1);
Assert.IsFalse (success, "Ungültige Richtung!");
// nach oben schieben (1x)
success = knot.Move (direction: Direction.Up, distance: 1);
Assert.IsTrue (success, "Gültige Richtung!");
Assert.AreEqual (knot.Count (), edges.Length + 2, "Knotenlänge nach Verschiebung #1");
// noch mal nach oben schieben (2x)
success = knot.Move (direction: Direction.Up, distance: 2);
Assert.AreEqual (knot.Count (), edges.Length + 2 * 3, "Knotenlänge nach Verschiebung #2");
// wieder nach unten schieben (3x)
success = knot.Move (direction: Direction.Down, distance: 3);
Assert.IsTrue (success, "Gültige Richtung!");
Assert.AreEqual (knot.Count (), edges.Length, "Knotenlänge nach Verschiebung #3");
success = knot.Move (direction: Direction.Zero, distance: 3);
Assert.AreEqual (knot.Count (), edges.Length, "Null-Move");
success = knot.Move (direction: Direction.Left, distance: 0);
Assert.AreEqual (knot.Count (), edges.Length, "Null-Move");
success = knot.Move (direction: Direction.Zero, distance: 0);
Assert.AreEqual (knot.Count (), edges.Length, "Null-Move");
}
public void Knot_Equals_Test()
{
CircleEntry<Edge> start = new CircleEntry<Edge> (new Edge[] {
Edge.Up,
Edge.Left,
Edge.Backward,
Edge.Down,
Edge.Right,
Edge.Forward
}
);
KnotMetaData metaData = new KnotMetaData (name: "test", countEdges: () => start.Count ());
Knot knot = new Knot (metaData, start);
for (int i = 0; i < 6; i++) {
Assert.IsTrue (knot.Equals (new Knot (metaData, start)));
start = start.Previous;
}
start.InsertBefore (Edge.Forward);
start.InsertAfter (Edge.Backward);
for (int i = 0; i < 6; i++) {
Assert.IsFalse (knot.Equals (new Knot (metaData, start)));
start = start.Previous;
}
}
