/// <summary>
/// Call this to initialize a Behaviour with data supplied in a file.
/// </summary>
/// <param name="fileName">The file to load from.</param>
public override void LoadContent(String fileName)
{
OgmoRenderDefinition def = GameObjectManager.pInstance.pContentManager.Load <OgmoRenderDefinition>(fileName);
// Load the actual level file.
OgmoLevel level = GameObjectManager.pInstance.pContentManager.Load <OgmoLevel>(def.mOgmoLevel);
// Get the loaded grid data and use it for a collision layer.
mCollisionGrid = level.GetLayer <OgmoGridLayer>(def.mGridLayer).RawData;
// Loop through all the layers and add them to the tiles array. Multiple layers get added to the same
// List because they have no impact on each other; it's just a list of things to draw.
for (Int32 i = 0; i < def.mTileLayers.Count; i++)
{
// Cache this stuff ahead of time to simplify code.
Int32 count = level.GetLayer <OgmoTileLayer>(def.mTileLayers[i].mName).Tiles.Count <OgmoTile>();
OgmoTile[] tiles = level.GetLayer <OgmoTileLayer>(def.mTileLayers[i].mName).Tiles;
Boolean useIndex = def.mTileLayers[i].mUsesTextureIndex;
for (Int32 j = 0; j < count; j++)
{
mTiles.Add(new Tile(tiles[j], useIndex));
}
}
base.LoadContent(fileName);
}
/// <summary>
/// Loads all levels for the game and project data.
/// </summary>
/// <returns>The generated starting scene.</returns>
public Node2D Load(out Node2D player, out Vector2 levelBoundsX, out Vector2 levelBoundsY)
{
string pathToProjectFile = "res://ogmo/project.ogmo";
string pathToLevelsDir = "res://ogmo/levels";
project = JsonConvert.DeserializeObject <OgmoProject>(ObtainFileString(pathToProjectFile));
Levels = new Dictionary <string, OgmoLevel>();
var levelDir = new Directory();
levelDir.Open(pathToLevelsDir);
levelDir.ListDirBegin(true, true);
string levelPath;
OgmoLevel startLevel = null;
while ((levelPath = levelDir.GetNext()) != string.Empty)
{
if (!levelPath.EndsWith(".json"))
{
continue;
}
Levels.Add(levelPath.Replace(".json", string.Empty), JsonConvert.DeserializeObject <OgmoLevel>(ObtainFileString(pathToLevelsDir + "/" + levelPath)));
if (levelPath.StartsWith("start", StringComparison.InvariantCultureIgnoreCase))
{
startLevel = Levels.Last().Value;
}
}
levelBoundsX = new Vector2(0, startLevel.width);
levelBoundsY = new Vector2(0, startLevel.height);
return(GenerateScene(project, startLevel, out player));
}
internal OgmoGridLayer(ContentReader reader, OgmoLevel level)
: base(reader)
{
OgmoGridLayerSettings settings = level.Project.GetLayerSettings<OgmoGridLayerSettings>(this.Name);
if (settings.ExportAsObjects)
{
rectData = new List<Rectangle>();
int objectCount = reader.ReadInt32();
if (objectCount > 0)
{
for (int i = 0; i < objectCount; i++)
{
Rectangle rect = Rectangle.Empty;
rect.X = reader.ReadInt32();
rect.Y = reader.ReadInt32();
rect.Width = reader.ReadInt32();
rect.Height = reader.ReadInt32();
rectData.Add(rect);
}
}
}
else
{
byte[] data = Convert.FromBase64String(reader.ReadString());
string stringData = System.Text.Encoding.UTF8.GetString(data, 0, data.Length);
int tx = level.Width / settings.GridSize;
int ty = level.Height / settings.GridSize;
rawData = new int[tx, ty];
for (int y = 0; y < ty; y++)
for (int x = 0; x < tx; x++)
rawData[x, y] = int.Parse(stringData[y * tx + x].ToString(), CultureInfo.InvariantCulture);
}
}
protected override void LoadContent()
{
base.LoadContent();
_ogmoProject = Content.Load <OgmoProject>(@"ogmo\testproject");
_level = _ogmoProject.GetLevel("testlevel");
}
public Level(OgmoLevel level)
{
// Get the loaded grid data and use it for a collision layer.
collisionGrid = level.GetLayer<OgmoGridLayer>("floors").RawData;
// Create tiles from some tile layer data.
foreach (OgmoTile tile in level.GetLayer<OgmoTileLayer>("tiles_bg").Tiles)
tiles.Add(new Tile(tile, false));
// Create more tiles from some more tile layer data.
foreach (OgmoTile tile in level.GetLayer<OgmoTileLayer>("tiles_floors").Tiles)
tiles.Add(new Tile(tile, true));
// Create our objects from the object layer data.
foreach (OgmoObject obj in level.GetLayer<OgmoObjectLayer>("objects").Objects)
{
if (obj.Name.Equals("ogmo"))
{
Ogmo ogmo = new Ogmo(obj, this);
ogmo.Destroy += new EventHandler(ogmo_Destroy);
allObjects.Add(ogmo);
this.ogmo = ogmo;
}
if (obj.Name.Equals("chest"))
{
Chest chest = new Chest(obj, this);
chest.Destroy += new EventHandler(DoDestroy);
allObjects.Add(chest);
}
if (obj.Name.Equals("moving_platform"))
allObjects.Add(new MovingPlatform(obj, this));
if (obj.Name.StartsWith("spike"))
allObjects.Add(new Spike(obj, this));
}
}
internal OgmoTileLayer(ContentReader reader, OgmoLevel level)
: base(reader)
{
this.TileHeight = reader.ReadInt32();
this.TileWidth = reader.ReadInt32();
int tilesetCount = reader.ReadInt32();
if (tilesetCount > 0)
{
for (int i = 0; i < tilesetCount; i++)
{
string tilesetName = reader.ReadString();
OgmoTileset tileset = level.Project.GetTileset(tilesetName);
tilesets.Add(tileset.Name, tileset);
}
}
int tileCount = reader.ReadInt32();
if (tileCount > 0)
{
for (int i = 0; i < tileCount; i++)
{
tiles.Add(new OgmoTile(reader, this));
}
}
}
internal OgmoObjectLayer(ContentReader reader, OgmoLevel level)
: base(reader)
{
int objectCount = reader.ReadInt32();
if (objectCount > 0)
{
for (int i = 0; i < objectCount; i++)
{
OgmoObject obj = new OgmoObject(reader);
if (obj != null)
{
if (objects.ContainsKey(obj.Name))
{
objects[obj.Name].Add(obj);
}
else
{
objects.Add(obj.Name, new List <OgmoObject>()
{
obj
});
}
}
allObjects.Add(obj);
}
}
}
public static void Load( )
{
levels = new List <OgmoLevel>();
var files = Directory.GetFiles("Levels/Maps/");
foreach (var f in files)
{
Debug.Log("loading level: " + f);
var data = new OgmoLevel(File.ReadAllText(f));
data.title = f;
levels.Add(data);
}
}
public static List <Room> readRooms(string levelFile, string projectFile,
int roomToRoomWidth, int roomToRoomHeight, int roomWidth, int roomHeight)
{
List <Room> rooms = new List <Room>();
OgmoLevel level = new OgmoLevel(levelFile);
LevelStructure structure = new LevelStructure(projectFile);
int cornerX = level.layers["Background"].entities[0].x;
int cornerY = level.layers["Background"].entities[0].y;
if (level.layers.ContainsKey("RoomMarker"))
{
if (level.layers["RoomMarker"].entities.Count > 0)
{
cornerX = level.layers["RoomMarker"].entities[0].x;
cornerY = level.layers["RoomMarker"].entities[0].y;
}
}
for (int ii = cornerX / 16 + (roomToRoomWidth - roomWidth) / 2; ii < level.width / 16 - roomToRoomWidth; ii += roomToRoomWidth)
{
for (int jj = cornerY / 16 + (roomToRoomHeight - roomHeight) / 2; jj < level.height / 16 - roomToRoomHeight; jj += roomToRoomHeight)
{
Room room = new Room(roomWidth, roomHeight);
for (int xx = 0; xx < roomWidth; xx++)
{
for (int yy = 0; yy < roomHeight; yy++)
{
room.objects["blocks"][xx, yy] = level.layers["Blocks"].tiles[xx + ii, yy + jj];
room.objects["enemies"][xx, yy] = level.layers["Enemies"].tiles[xx + ii, yy + jj];
room.objects["keys"][xx, yy] = level.layers["Key"].tiles[xx + ii, yy + jj];
room.objects["keyItems"][xx, yy] = level.layers["KeyItem"].tiles[xx + ii, yy + jj];
room.objects["items"][xx, yy] = level.layers["Items"].tiles[xx + ii, yy + jj];
room.objects["traps"][xx, yy] = level.layers["Traps"].tiles[xx + ii, yy + jj];
room.objects["puzzles"][xx, yy] = level.layers["Puzzles"].tiles[xx + ii, yy + jj];
room.objects["water"][xx, yy] = level.layers["Water"].tiles[xx + ii, yy + jj];
if (level.layers.ContainsKey("Teleporter"))
{
room.objects["teleporters"][xx, yy] = level.layers["Teleporter"].tiles[xx + ii, yy + jj];
}
}
}
if (!room.isAllZero())
{
rooms.Add(room);
}
}
}
return(rooms);
}
/// <param name="level">The level intended to be rendered. Get this by calling <c>.LoadLevel(string)</c> on an <c>OgmoProject</c></param>
public OgmoRenderer(OgmoLevel level)
{
RenderedLayers = new List <OgmoTileLayer>();
TilesetLookup = new Dictionary <string, OgmoTileset>();
TargetLevel = level;
for (int i = 0; i < TargetLevel.Layers.Length; i++)
{
if (TargetLevel.Layers[i] is OgmoTileLayer tileLayer)
{
RenderedLayers.Add(tileLayer);
}
}
_areBoundsDirty = true;
}
internal OgmoObjectLayer(ContentReader reader, OgmoLevel level)
: base(reader)
{
int objectCount = reader.ReadInt32();
if (objectCount > 0)
{
for (int i = 0; i < objectCount; i++)
{
OgmoObject obj = new OgmoObject(reader);
if(obj != null)
if (objects.ContainsKey(obj.Name))
objects[obj.Name].Add(obj);
else
objects.Add(obj.Name, new List<OgmoObject>() { obj });
allObjects.Add(obj);
}
}
}
internal static OgmoLayer Read(ContentReader reader, OgmoLevel level)
{
OgmoLayer layer = null;
string type = reader.ReadString();
switch (type)
{
case "g":
layer = new OgmoGridLayer(reader, level);
break;
case "t":
layer = new OgmoTileLayer(reader, level);
break;
case "o":
layer = new OgmoObjectLayer(reader, level);
break;
}
return layer;
}
internal static OgmoLayer Read(ContentReader reader, OgmoLevel level)
{
OgmoLayer layer = null;
string type = reader.ReadString();
switch (type)
{
case "g":
layer = new OgmoGridLayer(reader, level);
break;
case "t":
layer = new OgmoTileLayer(reader, level);
break;
case "o":
layer = new OgmoObjectLayer(reader, level);
break;
}
return(layer);
}
public Level(OgmoLevel level)
{
// Get the loaded grid data and use it for a collision layer.
collisionGrid = level.GetLayer <OgmoGridLayer>("floors").RawData;
// Create tiles from some tile layer data.
foreach (OgmoTile tile in level.GetLayer <OgmoTileLayer>("tiles_bg").Tiles)
{
tiles.Add(new Tile(tile, false));
}
// Create more tiles from some more tile layer data.
foreach (OgmoTile tile in level.GetLayer <OgmoTileLayer>("tiles_floors").Tiles)
{
tiles.Add(new Tile(tile, true));
}
// Create our objects from the object layer data.
foreach (OgmoObject obj in level.GetLayer <OgmoObjectLayer>("objects").Objects)
{
if (obj.Name.Equals("ogmo"))
{
Ogmo ogmo = new Ogmo(obj, this);
ogmo.Destroy += new EventHandler(ogmo_Destroy);
allObjects.Add(ogmo);
this.ogmo = ogmo;
}
if (obj.Name.Equals("chest"))
{
Chest chest = new Chest(obj, this);
chest.Destroy += new EventHandler(DoDestroy);
allObjects.Add(chest);
}
if (obj.Name.Equals("moving_platform"))
{
allObjects.Add(new MovingPlatform(obj, this));
}
if (obj.Name.StartsWith("spike"))
{
allObjects.Add(new Spike(obj, this));
}
}
}
internal OgmoTileLayer(ContentReader reader, OgmoLevel level)
: base(reader)
{
this.TileHeight = reader.ReadInt32();
this.TileWidth = reader.ReadInt32();
int tilesetCount = reader.ReadInt32();
if (tilesetCount > 0)
{
for (int i = 0; i < tilesetCount; i++)
{
string tilesetName = reader.ReadString();
OgmoTileset tileset = level.Project.GetTileset(tilesetName);
tilesets.Add(tileset.Name, tileset);
}
}
int tileCount = reader.ReadInt32();
if (tileCount > 0)
{
for (int i = 0; i < tileCount; i++)
tiles.Add(new OgmoTile(reader, this));
}
}
internal OgmoGridLayer(ContentReader reader, OgmoLevel level)
: base(reader)
{
OgmoGridLayerSettings settings = level.Project.GetLayerSettings <OgmoGridLayerSettings>(this.Name);
if (settings.ExportAsObjects)
{
rectData = new List <Rectangle>();
int objectCount = reader.ReadInt32();
if (objectCount > 0)
{
for (int i = 0; i < objectCount; i++)
{
Rectangle rect = Rectangle.Empty;
rect.X = reader.ReadInt32();
rect.Y = reader.ReadInt32();
rect.Width = reader.ReadInt32();
rect.Height = reader.ReadInt32();
rectData.Add(rect);
}
}
}
else
{
byte[] data = Convert.FromBase64String(reader.ReadString());
string stringData = System.Text.Encoding.UTF8.GetString(data, 0, data.Length);
int tx = level.Width / settings.GridSize;
int ty = level.Height / settings.GridSize;
rawData = new int[tx, ty];
for (int y = 0; y < ty; y++)
{
for (int x = 0; x < tx; x++)
{
rawData[x, y] = int.Parse(stringData[y * tx + x].ToString(), CultureInfo.InvariantCulture);
}
}
}
}
private GameObject LoadLevel(int index, Vector3 pos)
{
levelIndex = Mathf.Clamp (index, 0, levels.Length - 1);
var level = new OgmoLevel (levels [levelIndex]);
lvl = new GameObject ("TheLevelStuff");
lvl.transform.position = pos;
foreach (var layer in level.layers.Values) {
LoadLayer (layer);
}
return lvl;
}
private Node2D GenerateScene(OgmoProject project, OgmoLevel level, out Node2D player)
{
nodes = new List <Node2D>();
player = null;
var tileMap = (TileMap)((PackedScene)ResourceLoader.Load("res://prefab/TileMap.tscn")).Instance();
tileMap.Name = "TileMap";
Node2D ultimateParent = new Node2D();
ultimateParent.Name = "Level";
ultimateParent.AddChild(tileMap);
//Load set tiles in
var tileData = level.layers.First(x => x.name == "Tiles").data2D;
for (int y = 0; y < tileData.Count; y++)
{
for (int x = 0; x < tileData[y].Count; x++)
{
tileMap.SetCell(x, y, tileData[y][x]);
if (y == 0)
{
tileMap.SetCell(x, -1, 0);
}
if (x == 0)
{
tileMap.SetCell(-1, y, 0);
}
if (x == tileData.Count - 1)
{
tileMap.SetCell(tileData.Count, y, 0);
}
if (y == tileData[y].Count - 1)
{
tileMap.SetCell(x, tileData[y].Count, 0);
}
}
}
var playerScene = (PackedScene)ResourceLoader.Load("res://prefab/PlayerOwl.tscn");
var bugScene = ((PackedScene)ResourceLoader.Load("res://prefab/Enemies/Bug.tscn"));
var beeScene = ((PackedScene)ResourceLoader.Load("res://prefab/Enemies/Beee.tscn"));
var carnosaurScene = ((PackedScene)ResourceLoader.Load("res://prefab/Enemies/Carnosaur.tscn"));
var carnosaurusRexScene = ((PackedScene)ResourceLoader.Load("res://prefab/Enemies/CarnosaurusRex.tscn"));
var playerEntity = level.layers.First(x => x.name == "Entity").entities.First(x => x.name == "LevelSpawn");
player = (Node2D)playerScene.Instance();
player.Name = "Player_" + playerEntity._eid;
player.Position = new Vector2(playerEntity.x, playerEntity.y);
foreach (var entity in level.layers.First(x => x.name == "Entity").entities)
{
Node2D childInstance = null;
switch (entity.name)
{
case "Walker":
childInstance = (Node2D)bugScene.Instance();
childInstance.Name = "Walker_" + entity._eid;
break;
case "TargetFlyer":
childInstance = (Node2D)carnosaurScene.Instance();
childInstance.Name = "Flyer_" + entity._eid;
break;
case "Bee":
childInstance = (Node2D)beeScene.Instance();
childInstance.Name = "Bee_" + entity._eid;
break;
case "Boss":
childInstance = (Node2D)carnosaurusRexScene.Instance();
childInstance.Name = "Boss_" + entity._eid;
break;
}
if (childInstance != null)
{
childInstance.AddToGroup("enemy", true);
nodes.Add(childInstance);
ultimateParent.AddChild(childInstance);
childInstance.Position = new Vector2(entity.x, entity.y);
}
}
return(ultimateParent);
}
/// <summary>
/// Convert an OgmoLevel in a usable level
/// </summary>
/// <param name="context"></param>
/// <param name="ogmoLevel"></param>
/// <returns></returns>
private static LevelPart Convert(OgmoLevel ogmoLevel)
{
// Get level dimensions
Vector2 dimensions = new Vector2(ogmoLevel.Width, ogmoLevel.Height);
// Get level infos
int id = ogmoLevel.GetValue<OgmoIntegerValue>("id").Value;
int maxRepeat = ogmoLevel.GetValue<OgmoIntegerValue>("max_repeat").Value;
int input = -1;
int output = -1;
int inputY = -1;
int outputY = -1;
bool isStart = false;
bool isEnd = false;
LevelPart levelPart = new LevelPart(id, maxRepeat, dimensions);
// Add gfx resources
foreach (OgmoTileset tileSet in ogmoLevel.Project.Tilesets)
{
Application.MagicContentManager.AddTexture(tileSet.Name, tileSet.Texture);
}
foreach (OgmoObjectTemplate objTemplate in ogmoLevel.Project.ObjectTemplates)
{
Application.MagicContentManager.AddTexture(System.IO.Path.GetFileNameWithoutExtension(objTemplate.TextureFile), objTemplate.Texture);
}
//Layers
for (int i = 0; i < ogmoLevel.Layers.Length; i++)
{
var olayer = ogmoLevel.Layers[i];
var olayersettings = ogmoLevel.Project.LayerSettings.Where(ls => ls.Name == olayer.Name).First();
// Background tiles
if (olayer.Name == "background")
{
ExtractTileLayer(levelPart.BackgroundLayer, olayer, olayersettings);
}
// Background objects
else if (olayer.Name == "background_objects")
{
ExtractObjectLayer(levelPart.BackgroundLayer, olayer, olayersettings);
}
//Collisions
else if (olayer.Name == "collision")
{
levelPart.CollisionsMask = ExtractGridRectLayer(olayer, olayersettings);
}
// Middleground tiles
else if (olayer.Name == "floor")
{
ExtractTileLayer(levelPart.MiddleGroundLayer, olayer, olayersettings);
}
// Game objects (static)
else if (olayer.Name == "static_objects")
{
ExtractObjectLayer(levelPart.MiddleGroundLayer, olayer, olayersettings);
}
// Game objects
else if (olayer.Name == "objects")
{
ExtractObjectLayer(levelPart.MiddleGroundLayer, olayer, olayersettings);
}
// Middleground tiles
else if (olayer.Name == "foreground")
{
ExtractTileLayer(levelPart.ForegroundLayer, olayer, olayersettings);
}
}
// Get input, output, start & end objects
foreach (OgmoObjectEntity oent in levelPart.MiddleGroundLayer.Entities)
{
if (oent is OInput)
{
input = ((OInput)oent).Id;
inputY = (int)((OInput)oent).Location.Y;
}
else if (oent is OOutput)
{
output = ((OOutput)oent).Id;
outputY = (int)((OOutput)oent).Location.Y;
}
else if (oent is OShip)
{
isEnd = true;
}
else if (oent is OSpawn)
{
isStart = true;
}
}
if (input == -1) throw new ArgumentException("Missing input door!");
if (output == -1) throw new ArgumentException("Missing output door!");
levelPart.InputId = input;
levelPart.InputYLoc = inputY;
levelPart.OutputId = output;
levelPart.OutputYLoc = outputY;
levelPart.IsStart = isStart;
levelPart.IsEnd = isEnd;
return levelPart;
}
