public void LoadSelectedLevel()
{
string dirPath = Path.Combine(Application.persistentDataPath, "Levels");
string file = Path.Combine(dirPath, fileToLoad + ".xml");
if (File.Exists(file))
{
LevelXml xml = new LevelXml();
xml.LoadFromXml(file, FindObjectOfType <Level>());
width = FindObjectOfType <Level>().width;
DisplayWidth();
height = FindObjectOfType <Level>().height;
DisplayHeight();
levelNameIF.text = FindObjectOfType <Level>().gameObject.name;
// Hide the menu and enable interaction on other UI objects
loadCanvas.enabled = false;
levelNameIF.interactable = true;
foreach (Button button in uiButtons)
{
button.interactable = true;
}
UpdatePreview();
}
}
public void GetConstraint_BuildWithQuery_ConstraintBuilt()
{
var sutXml = new MembersXml();
sutXml.ChildrenOf = "memberCaption";
var item = new LevelXml();
sutXml.Item = item;
item.ConnectionString = "connectionString";
item.Perspective = "perspective";
item.Dimension = "dimension";
item.Hierarchy = "hierarchy";
item.Caption = "level";
var ctrXml = new OrderedXml();
var query = new QueryXml();
query.InlineQuery = "select label from myTable order by sortOrder";
ctrXml.Query = query;
var builder = new MembersOrderedBuilder();
builder.Setup(sutXml, ctrXml);
builder.Build();
var ctr = builder.GetConstraint();
Assert.That(ctr, Is.InstanceOf <OrderedConstraint>());
}
public void LoadAllLevels()
{
string tempPath = Path.Combine(Application.persistentDataPath, "Levels");
if (!Directory.Exists(tempPath))
{
Directory.CreateDirectory(tempPath);
}
foreach (string file in Directory.GetFiles(tempPath))
{
if (file.EndsWith(".xml"))
{
GameObject newLevel = new GameObject();
newLevel.AddComponent <Level>();
LevelXml xml = new LevelXml();
xml.LoadFromXml(Path.Combine(tempPath, file), newLevel.GetComponent <Level>());
if (FindObjectOfType <DataManager>().transform.Find(newLevel.gameObject.name))
{
Destroy(FindObjectOfType <DataManager>().transform.Find(newLevel.gameObject.name));
}
newLevel.transform.parent = FindObjectOfType <DataManager>().transform;
FindObjectOfType <DataManager>().AddLevel(newLevel);
maxLevelNumber = FindObjectOfType <DataManager>().levels.Length;
}
}
}
public void SaveLevel()
{
//Debug.Log(Application.persistentDataPath);
string levelName = FindObjectOfType <Level>().gameObject.name = levelNameIF.text;
if (levelName.Equals(""))
{
// Display the pop-up warning and disable the interaction on other UI opject
warningCanvas.transform.Find("WarningText").GetComponent <Text>().text = "Warning!\nYou must put a level name to save the level.\n(The level was not saved)";
warningCanvas.enabled = true;
levelNameIF.interactable = false;
foreach (Button button in uiButtons)
{
button.interactable = false;
}
return;
}
string tempPath = Path.Combine(Application.persistentDataPath, "Levels");
if (File.Exists(Path.Combine(tempPath, levelNameIF.text + ".xml")))
{
StartCoroutine(WaitingToSave());
return;
}
else
{
if (!Directory.Exists(tempPath))
{
Directory.CreateDirectory(tempPath);
}
LevelXml xml = new LevelXml();
xml.SaveToXml(FindObjectOfType <Level>(), Path.Combine(tempPath, levelNameIF.text + ".xml"));
}
}
IEnumerator WaitingToSave()
{
// Display the pop-up and disable the interaction on other UI objects
replaceFileCanvas.enabled = true;
levelNameIF.interactable = false;
foreach (Button button in uiButtons)
{
button.interactable = false;
}
replaceFileToSave = false; // default, just to be sure
// Wait for user answer
while (replaceFileCanvas.enabled)
{
yield return(new WaitForSeconds(Time.deltaTime));
}
// Allow the interaction on other UY objects after the pop-up was hidden
levelNameIF.interactable = true;
foreach (Button button in uiButtons)
{
button.interactable = true;
}
// Save level if replaceFileToSave is true
if (replaceFileToSave)
{
string tempPath = Path.Combine(Application.persistentDataPath, "Levels");
LevelXml xml = new LevelXml();
xml.SaveToXml(FindObjectOfType <Level>(), Path.Combine(tempPath, levelNameIF.text + ".xml"));
}
}
public void LoadFromXml(string path, Level level)
{
LevelXml xml = new LevelXml();
var serializer = new XmlSerializer(typeof(LevelXml));
using (var stream = new FileStream(path, FileMode.Open))
{
xml = serializer.Deserialize(stream) as LevelXml;
}
level.gameObject.name = xml.Name;
level.width = xml.Width;
level.height = xml.Height;
level.blocksPositions = xml.Blocks;
level.pickUpPositions = xml.PickUpSpawns;
level.ufoPositions = xml.UFOSpawns;
}
public void Deserialize_SampleFile_MembersWithLevel()
{
int testNr = 0;
// Create an instance of the XmlSerializer specifying type and namespace.
TestSuiteXml ts = DeserializeSample();
// Check the properties of the object.
Assert.That(ts.Tests[testNr].Systems[0], Is.TypeOf <MembersXml>());
Assert.That(((MembersXml)ts.Tests[testNr].Systems[0]).Item, Is.TypeOf <LevelXml>());
LevelXml item = (LevelXml)((MembersXml)ts.Tests[testNr].Systems[0]).Item;
Assert.That(item.Dimension, Is.EqualTo("dimension"));
Assert.That(item.Hierarchy, Is.EqualTo("hierarchy"));
Assert.That(item.Caption, Is.EqualTo("level"));
Assert.That(item.Perspective, Is.EqualTo("Perspective"));
Assert.That(item.GetConnectionString(), Is.EqualTo("ConnectionString"));
}
public void GetSystemUnderTest_BuildWithLevel_CorrectCallToDiscoverFactory()
{
var sutXml = new MembersXml
{
ChildrenOf = "memberCaption"
};
var item = new LevelXml();
sutXml.Item = item;
item.ConnectionString = "connectionString";
item.Perspective = "perspective";
item.Dimension = "dimension";
item.Hierarchy = "hierarchy";
item.Caption = "level";
var ctrXml = new ContainXml();
ctrXml.Items.Add("caption 1");
ctrXml.Items.Add("caption 2");
var discoFactoMockFactory = new Mock <DiscoveryRequestFactory>();
discoFactoMockFactory.Setup(dfs =>
dfs.Build(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <List <string> >(),
It.IsAny <List <PatternValue> >(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>()))
.Returns(new MembersDiscoveryRequest());
var discoFactoMock = discoFactoMockFactory.Object;
var builder = new MembersContainBuilder(discoFactoMock);
builder.Setup(sutXml, ctrXml);
builder.Build();
var sut = builder.GetSystemUnderTest();
Assert.That(sut, Is.InstanceOf <MembersDiscoveryRequest>());
discoFactoMockFactory.Verify(dfm => dfm.Build("connectionString", "memberCaption", It.IsAny <List <string> >(), It.IsAny <List <PatternValue> >(), "perspective", "dimension", "hierarchy", "level"));
}
//--------------------------------------------------------------------------------------
// Methods:
//--------------------------------------------------------------------------------------
#region void Create(LevelXml)
/// <summary>
/// Create the level inside the current scene.
/// </summary>
/// <param name="descriptor">The level descriptor.</param>
public void Create(LevelXml descriptor)
{
// Set the loaded flag to false:
IsLoaded = false;
// And then try to load the data in the scene:
try {
// Set the size of the world:
Width = descriptor.World.Width;
Height = descriptor.World.Height;
// Check that the size of the world is correct:
var data = descriptor.World.Terrain;
if (data.Length != Width * Height)
{
throw new Exception("Invalid size inside the level descriptor for the world.");
}
// Load all the sprites from the selected tileset:
var sprites = CoreManager.Instance.LoadGameSprites(descriptor.Tileset);
// Get the world node inside the scene:
var worldObject = GameObject.Find(CoreManager.TERRAIN_GOBJ_NAME);
// This function creates a new tile game object in the scene:
Func <uint, GameObject> createTile = id => {
// Create the object and set the parent:
var victim = new GameObject(CoreManager.TILE_GOBJ_NAME);
SceneUtil.SetParent(victim, worldObject);
// Create the sprite renderer component:
var spriteRenderer = victim.AddComponent <SpriteRenderer>();
var sprite = sprites.Where(x => x.name == descriptor.Tileset + "_" + id)
.FirstOrDefault();
spriteRenderer.sprite = sprite;
// Return the object created:
return(victim);
};
// Set some data to calculate the position of the tiles:
int widthInPixels = Width * CoreManager.TILE_WIDTH;
int heightInPixels = Height * CoreManager.TILE_HEIGHT;
const int PIVOT_OFFSET = 8;
int startX = PIVOT_OFFSET - (widthInPixels / 2);
int startY = (heightInPixels / 2) - PIVOT_OFFSET;
// For each id inside the terrain array of the world inside the descriptor
// we're going to create a new tile and add it to the array of cells:
List <CellData> cellsList = new List <CellData>();
for (int i = 0, k = 0; i < Height; i++)
{
for (int j = 0; j < Width; j++, k++)
{
// Create the tile and change its position:
var tile = createTile(data[k]);
SceneUtil.SetPosition(
tile,
(startX + CoreManager.TILE_WIDTH * j) / 100.0f,
(startY - CoreManager.TILE_HEIGHT * i) / 100.0f,
0.0f
);
// Create the current cell data:
cellsList.Add(new CellData(i, j, tile, data[k]));
}
}
cells = cellsList.ToArray();
// Get the entities node inside the scene:
var entitiesObject = GameObject.Find(CoreManager.ENTITIES_GOBJ_NAME);
// Create all the entities inside the world:
foreach (var item in descriptor.Entities)
{
var created = PlayerController.Create(item, entitiesObject);
if (!created)
{
BoxController.Create(item, entitiesObject, descriptor.Tileset, sprites);
}
}
// Finishing the load level process:
IsLoaded = true;
} catch (Exception e) {
CoreManager.Instance.Log(e);
Width = 0;
Height = 0;
cells = null;
}
}
//--------------------------------------------------------------------------------------
// Methods:
//--------------------------------------------------------------------------------------
/// <summary>
/// Converts a TMX file to an XML level file.
/// </summary>
/// <param name="inputFileName">The input file name.</param>
/// <param name="outputFileName">The output file name.</param>
public static void Convert(string inputFileName, string outputFileName)
{
Shared.ShowTitle(inputFileName, outputFileName);
// Get the basic data of the level:
var level = new LevelXml();
var map = XmlFile.LoadXml <Tiled.Map>(inputFileName);
level.Name = findProperty(map, "Name", Shared.DEFAULT_NAME);
level.Description = findProperty(map, "Description", Shared.DEFAULT_DESCRIPTION);
level.Tileset = findTileset(map);
Console.WriteLine("Basic level data converted...");
// Get the terrain data of the level:
var layers = map.Items.Select(x => x as Tiled.Layer)
.Where(x => x != null).ToArray();
var terrainLayer = findTerrainLayer(layers);
level.World = new WorldXml();
level.World.Width = terrainLayer.Width;
level.World.Height = terrainLayer.Height;
level.World.Content = "\n";
int currentProgress = 0;
int totalProgress = level.World.Width * level.World.Height;
Console.Write("\rTerrain information into game level format... [" +
(currentProgress * 100 / totalProgress) + "%]");
for (int y = 0, k = 0; y < level.World.Height; y++)
{
for (int x = 0; x < level.World.Width; x++, k++)
{
var id = terrainLayer.Data.Tiles[k].Gid;
if (id > 0)
{
id--;
}
level.World.Content += id.ToString("0000");
level.World.Content += " ";
Console.Write("\rTerrain information into game level format... [" +
(currentProgress * 100 / totalProgress) + "%]");
}
level.World.Content += "\n";
}
Console.WriteLine("\rTerrain information into game level format... [100%]");
// Get the entities data of the level:
var entitiesLayer = findEntitiesLayer(layers);
var entities = new List <EntityXml>();
currentProgress = 0;
Console.Write("\rEntities information into game level format... [" +
(currentProgress * 100 / totalProgress) + "%]");
for (int y = 0, k = 0; y < entitiesLayer.Height; y++)
{
for (int x = 0; x < entitiesLayer.Width; x++, k++)
{
var id = entitiesLayer.Data.Tiles[k].Gid;
if (id > 0)
{
id--;
string type = "";
if (Shared.TERRAIN_ID_FIRST_BOX <= id && id <= Shared.TERRAIN_ID_LAST_BOX)
{
var boxId = id - Shared.TERRAIN_ID_FIRST_BOX;
type = EntityType.BOX;
if (boxId > 0)
{
type += boxId;
}
}
else if (Shared.TERRAIN_ID_FIRST_DBOX <= id && id <= Shared.TERRAIN_ID_LAST_DBOX)
{
var boxId = id - Shared.TERRAIN_ID_FIRST_DBOX;
type = EntityType.BOX;
if (boxId > 0)
{
type += boxId;
}
}
else if (Shared.TERRAIN_ID_LAST_DBOX < id)
{
type = EntityType.PLAYER;
}
if (!string.IsNullOrEmpty(type))
{
var victim = new EntityXml();
victim.Type = type;
victim.X = x; victim.Y = y;
entities.Add(victim);
}
}
Console.Write("\rEntities information into game level format... [" +
(currentProgress * 100 / totalProgress) + "%]");
}
}
level.Entities = entities.ToArray();
Console.WriteLine("\rEntities information into game level format... [100%]");
// Save the level data in a file:
XmlFile.Save(outputFileName, level);
Console.WriteLine(outputFileName + " generated & saved...\n");
Shared.ShowEnd();
}
/// <summary>
/// Converts a level xml descriptor into a TMX xml text.
/// </summary>
/// <param name="level">The level descriptor</param>
/// <returns>The TMX xml text.</returns>
public static string[] ConvertToTmxText(LevelXml level)
{
var lines = new List <string>();
int width = level.World.Width;
int height = level.World.Height;
// Set the root:
lines.Add("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
lines.Add("<map version=\"1.0\" orientation=\"orthogonal\" renderorder=\"right-down\" width=\"" +
width + "\" height=\"" + height + "\" tilewidth=\"16\" tileheight=\"16\">");
Console.WriteLine("TMX root set...");
// Set the properties:
lines.Add(" <properties>");
lines.Add(" <property name=\"Name\" value=\"" + level.Name + "\"/>");
lines.Add(" <property name=\"Description\" value=\"" + level.Description + "\"/>");
lines.Add(" </properties>");
Console.WriteLine("TMX properties set...");
// Set the tilesets:
lines.Add(" <tileset firstgid=\"1\" name=\"" + level.Tileset + "\" tilewidth=\"16\" tileheight=\"16\">");
lines.Add(" <image source=\"" + level.Tileset + ".png\" width=\"512\" height=\"512\"/>");
lines.Add(" </tileset>");
lines.Add(" <tileset firstgid=\"1025\" name=\"Charset\" tilewidth=\"16\" tileheight=\"16\">");
lines.Add(" <image source=\"Charset.png\" width=\"256\" height=\"256\"/>");
lines.Add(" </tileset>");
Console.WriteLine("TMX tilesets set...");
// Set the terrain layer:
lines.Add(" <layer name=\"Terrain\" width=\"" + width + "\" height=\"" + height + "\">");
lines.Add(" <data>");
int currentProgress = 0;
int totalProgress = level.World.Width * level.World.Height;
Console.Write("\rTerrain information into TMX level format... [" +
(currentProgress * 100 / totalProgress) + "%]");
var terrain = level.World.Terrain;
for (int i = 0, k = 0; i < height; i++)
{
for (int j = 0; j < width; j++, k++)
{
var gid = terrain[k] + 1;
lines.Add(" <tile gid=\"" + gid + "\"/>");
Console.Write("\rTerrain information into TMX level format... [" +
(currentProgress * 100 / totalProgress) + "%]");
}
}
Console.WriteLine("\rTerrain information into TMX level format... [100%]");
lines.Add(" </data>");
lines.Add(" </layer>");
// Set the entities layer:
lines.Add(" <layer name=\"Entities\" width=\"" + width + "\" height=\"" + height + "\">");
lines.Add(" <data>");
currentProgress = 0;
Console.Write("\rEntities information into TMX level format... [" +
(currentProgress * 100 / totalProgress) + "%]");
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
int gid = 0;
var entity = level.Entities.Where(v => v.X == j && v.Y == i).FirstOrDefault();
if (entity != null)
{
if (entity.Type == EntityType.BOX)
{
gid = TERRAIN_ID_FIRST_BOX + 1;
}
else if (entity.Type == EntityType.PLAYER)
{
gid = PLAYER_GID;
}
}
lines.Add(" <tile gid=\"" + gid + "\"/>");
Console.Write("\rEntities information into TMX level format... [" +
(currentProgress * 100 / totalProgress) + "%]");
}
}
lines.Add(" </data>");
lines.Add(" </layer>");
Console.WriteLine("\rEntities information into TMX level format... [100%]");
// Set the end:
lines.Add("</map>");
return(lines.ToArray());
}
//--------------------------------------------------------------------------------------
// Methods (Convert):
//--------------------------------------------------------------------------------------
/// <summary>
/// Converts a text map level into a level xml descriptor.
/// </summary>
/// <param name="mapLines">The text map.</param>
/// <returns>The converted map.</returns>
public static LevelXml ConvertFromTextMap(string[] mapLines)
{
// Validate the input data:
if (mapLines == null || mapLines.Length <= 0)
{
throw new Exception("No input map lines to convert!");
}
if (mapLines.Length > 1 && string.IsNullOrEmpty(mapLines[mapLines.Length - 1]))
{
var ml = new string[mapLines.Length - 1];
for (int i = 0; i < ml.Length; i++)
{
ml[i] = mapLines[i];
}
mapLines = ml;
}
if (mapLines.Select(l => string.IsNullOrEmpty(l)).Aggregate((cur, nxt) => cur || nxt))
{
throw new Exception("Some of the map lines are empty!");
}
// Transform the input data into something more cleaner:
ShowMessageInBox("Raw input map", '|', '-');
Console.WriteLine();
ShowTextMap(mapLines);
mapLines = transform(mapLines);
ShowMessageInBox("Final input map", '|', '-');
Console.WriteLine();
ShowTextMap(mapLines);
// Initialize the basic data of the level:
var level = new LevelXml();
level.Name = DEFAULT_NAME;
level.Description = DEFAULT_DESCRIPTION;
level.Tileset = DEFAULT_TILESET;
// Set the terrain & entities data of the level:
level.World = new WorldXml();
level.World.Width = mapLines[0].Length;
level.World.Height = mapLines.Length;
level.World.Content = "\n";
int x = 0, y = 0;
var entities = new List <EntityXml>();
Action <string> addEntity = (type) => {
var victim = new EntityXml();
victim.Type = type;
victim.X = x; victim.Y = y;
entities.Add(victim);
};
int currentProgress = 0;
int totalProgress = level.World.Width * level.World.Height;
Console.Write("\rText map into game level format... [" +
(currentProgress * 100 / totalProgress) + "%]");
foreach (var line in mapLines)
{
foreach (var c in line)
{
var id = TERRAIN_ID_EMPTY;
switch (c)
{
case WALL: id = TERRAIN_ID_FIRST_WALL; break;
case GOAL: id = TERRAIN_ID_FIRST_DFLOOR; break;
case FLOOR: id = TERRAIN_ID_FIRST_FLOOR; break;
case PLAYER_ON_GOAL:
id = TERRAIN_ID_FIRST_DFLOOR;
addEntity(EntityType.PLAYER);
break;
case BOX_ON_GOAL:
id = TERRAIN_ID_FIRST_DFLOOR;
addEntity(EntityType.BOX);
break;
case PLAYER:
id = TERRAIN_ID_FIRST_FLOOR;
addEntity(EntityType.PLAYER);
break;
case BOX:
id = TERRAIN_ID_FIRST_FLOOR;
addEntity(EntityType.BOX);
break;
}
level.World.Content += id.ToString("0000");
level.World.Content += " ";
++x;
Console.Write("\rText map into game level format... [" +
(currentProgress * 100 / totalProgress) + "%]");
}
level.World.Content += "\n";
x = 0;
++y;
}
Console.WriteLine("\rText map into game level format... [100%]");
level.Entities = entities.ToArray();
return(level);
}
