/// <summary>
/// Load tiles in from a GridCollider.
/// </summary>
/// <param name="grid">The GridCollider to reference.</param>
/// <param name="color">The color to set tiles that are collidable on the grid.</param>
/// <param name="layer">The layer to place the tiles on.</param>
public void LoadGrid(GridCollider grid, Color color, string layer = "")
{
for (var i = 0; i < grid.TileColumns; i++)
{
for (var j = 0; j < grid.TileRows; j++)
{
if (grid.GetTile(i, j))
{
SetTile(i, j, color, layer);
}
}
}
}
public Floor()
{
floorMap = new Tilemap(Assets.GFX_FLOORTILES, 256 * 64, 64);
floorCol = new GridCollider(256 * 64, 256 * 64, 64, 64, (int)Global.ColliderTags.FLOOR);
wallMap = new Tilemap(Assets.GFX_WALLTILES, 256 * 64, 64);
wallCol = new GridCollider(256 * 64, 256 * 64, 64, 64, (int)Global.ColliderTags.WALL);
myGasManager.relatedFloor = this;
GenerateMap();
AddGraphic(floorMap);
AddCollider(floorCol);
AddGraphic(wallMap);
AddCollider(wallCol);
}
public override void Added()
{
base.Added();
// Create the grid collider based off of the scene's dimensions.
GridCollider = new GridCollider(Scene.Width, Scene.Height, GridSize, GridSize);
// Create the tilemap based off of the scene's dimensions.
Tilemap = new Tilemap("tiles.png", Scene.Width, Scene.Height, GridSize, GridSize);
// Add the tilemap graphic.
AddGraphic(Tilemap);
// Add the grid collider.
AddCollider(GridCollider);
}
// we need text-reveal mode or sth. edit richtext?
public PlayState()
{
//Load shader
VHSShader = new Shader(ShaderType.Fragment, Assets.VHS_SHADER);
VHSShader2 = new Shader(ShaderType.Fragment, Assets.VHS_SHADER2);
Global.theGame.Surface.AddShader(VHSShader);
Global.theGame.Surface.AddShader(VHSShader2);
// Create starfield.
starFieldFar = new Image(Assets.GFX_STARFIELD);
starFieldFar.Repeat = true;
starFieldFar.Scroll = 0.3f;
starFieldMid = new Image(Assets.GFX_STARFIELD);
starFieldMid.Repeat = true;
starFieldMid.Scroll = 0.6f;
starFieldMid.Scale = 1.5f;
starFieldClose = new Image(Assets.GFX_STARFIELD);
starFieldClose.Repeat = true;
starFieldClose.Scroll = 1.3f;
starFieldClose.Scale = 3.0f;
starFieldClose.Alpha = 0.5f;
AddGraphic(starFieldFar);
AddGraphic(starFieldMid);
AddGraphic(starFieldClose);
// Load map
floorTiles = mapProject.CreateTilemap((TiledTileLayer)mapProject.Layers[0]);
wallTiles = mapProject.CreateTilemap((TiledTileLayer)mapProject.Layers[1], mapProject.TileSets[1]);
// Make sure walls have the correct tiles
wallCollision = mapProject.CreateGridCollider((TiledTileLayer)mapProject.Layers[1], 3);
floorCollision = mapProject.CreateGridCollider((TiledTileLayer)mapProject.Layers[0], 8);
// Move camera to start point
TiledObjectGroup mapObjects = (TiledObjectGroup)mapProject.Layers[2];
TiledObject strt = mapObjects.Objects[0];
// Make machines
CameraX = strt.X - 320;
CameraY = strt.Y - 240;
// Add player
thePlayer = new Player(strt.X, strt.Y);
thePlayer.Layer = 20;
// Add station & player to scene
AddGraphic(floorTiles);
Add(thePlayer);
// Make items / machines
for (int i = 0; i < mapObjects.Objects.Count; i++)
{
TiledObject curObj = mapObjects.Objects[i];
if (curObj.Name == "Wrench")
{
Item newWrench = new Item(curObj.X, curObj.Y, 4);
Add(newWrench);
}
if (curObj.Name == "Crisps")
{
Item newWrench = new Item(curObj.X, curObj.Y, 7);
Add(newWrench);
}
if (curObj.Name == "Donut")
{
Item newWrench = new Item(curObj.X, curObj.Y, 6);
Add(newWrench);
}
if (curObj.Name == "VendingMachine")
{
Machine newMachine = new Machine(curObj.X, curObj.Y, "Vending Machine", "Full of delicious snacks.", "Looks like it's busted.", "It's rebooting.", 300, Assets.GFX_MACHINETOP, Assets.GFX_VENDING);
Add(newMachine);
}
if (curObj.Name == "Computer")
{
Machine newMachine = new Machine(curObj.X, curObj.Y, "Computer", "The communications terminal... me.", "ERROR: HHHH\nhelp\n \n{color:ff0000}ERRCODE#391293EFF3{color:ffffff}", "It was just a screensaver.\nYou idiot.", 600, Assets.GFX_PC_TOP, Assets.GFX_PC_FRONT);
Add(newMachine);
}
if (curObj.Type == "AirlockVert")
{
Airlock newAirlock = new Airlock(curObj.X, curObj.Y, true);
Add(newAirlock);
}
if (curObj.Type == "AirlockHoriz")
{
Airlock newAirlock = new Airlock(curObj.X, curObj.Y, false);
Add(newAirlock);
}
}
AddGraphic(wallTiles);
Add(thePlayer.crossHair);
wallTest = new Entity(0, 0, null, wallCollision);
Add(wallTest);
floorTest = new Entity(0, 0, null, floorCollision);
Add(floorTest);
// Add hud
msgBox = new Image(Assets.GFX_HUD);
msgBox.Scroll = 0;
msgBox.CenterOrigin();
msgBox.X = 320;
msgBox.Y = 255 + msgBox.Height + 16;
Entity hud1 = new Entity();
hud1.AddGraphic(msgBox);
hud1.Layer = 10;
Add(hud1);
msgText = new RichText("", Assets.FONT_MSG, 8, 270, 50);
msgText.DefaultShakeX = 0.4f;
msgText.DefaultShakeY = 0.4f;
msgText.X = 325 - msgBox.HalfWidth;
msgText.Y = 255 + msgBox.Height - 8;
msgText.Scroll = 0;
msgText.String = "";
Entity hud2 = new Entity();
hud2.AddGraphic(msgText);
hud2.Layer = 5;
Add(hud2);
}
/// <summary>
/// Load level data from a string into a Scene.
/// </summary>
/// <param name="data">The level data to load.</param>
/// <param name="scene">The Scene to load into.</param>
public void LoadLevel(string data, Scene scene)
{
Entities.Clear();
CurrentLevel = data;
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(data);
var xmlLevel = xmlDoc["level"];
scene.Width = int.Parse(xmlDoc["level"].Attributes["width"].Value);
scene.Height = int.Parse(xmlDoc["level"].Attributes["height"].Value);
int i = 0;
foreach (var layer in Layers.Values)
{
if (layer.Type == "GridLayerDefinition")
{
var Entity = new Entity();
var grid = new GridCollider(scene.Width, scene.Height, layer.GridWidth, layer.GridHeight);
grid.LoadString(xmlLevel[layer.Name].InnerText);
if (ColliderTags.ContainsKey(layer.Name))
{
grid.AddTag(ColliderTags[layer.Name]);
}
if (DisplayGrids)
{
var tilemap = new Tilemap(scene.Width, scene.Height, layer.GridWidth, layer.GridHeight);
tilemap.LoadString(xmlLevel[layer.Name].InnerText, layer.Color);
Entity.AddGraphic(tilemap);
}
Entity.AddCollider(grid);
scene.Add(ref Entity);
Entities.Add(layer.Name, Entity);
}
if (layer.Type == "TileLayerDefinition")
{
var Entity = new Entity();
var xmlTiles = xmlLevel[layer.Name];
var tileset = xmlTiles.Attributes["tileset"].Value;
var tilepath = ImagePath + TileMaps[tileset];
foreach (var kv in assetMappings)
{
var find = kv.Key;
var replace = kv.Value;
if (tilepath.EndsWith(find))
{
tilepath = replace;
break;
}
}
var tilemap = new Tilemap(tilepath, scene.Width, scene.Height, layer.GridWidth, layer.GridHeight);
var exportMode = xmlTiles.Attributes["exportMode"].Value;
switch (exportMode)
{
case "CSV":
tilemap.LoadCSV(xmlTiles.InnerText);
break;
case "XMLCoords":
foreach (XmlElement t in xmlTiles)
{
tilemap.SetTile(t);
}
break;
}
tilemap.Update();
Entity.AddGraphic(tilemap);
Entity.Layer = BaseTileDepth - i * TileDepthIncrement;
i++;
scene.Add(ref Entity);
Entities.Add(layer.Name, Entity);
}
if (layer.Type == "EntityLayerDefinition")
{
var xmlEntities = xmlLevel[layer.Name];
if (xmlEntities != null)
{
foreach (XmlElement e in xmlEntities)
{
CreateEntity(e, scene);
}
}
}
}
if (UseCameraBounds)
{
scene.CameraBounds = new Rectangle(0, 0, scene.Width, scene.Height);
scene.UseCameraBounds = true;
}
}
/// <summary>
/// Load data into a scene from a source .oel file.
/// </summary>
/// <param name="source">The oel to load.</param>
/// <param name="scene">The scene to load into.</param>
public void LoadLevel(string source, Scene scene)
{
Entities.Clear();
var xmlDoc = new XmlDocument();
xmlDoc.Load(source);
var xmlLevel = xmlDoc["level"];
scene.Width = int.Parse(xmlDoc["level"].Attributes["width"].Value);
scene.Height = int.Parse(xmlDoc["level"].Attributes["height"].Value);
int i = 0;
foreach (var layer in Layers.Values) {
if (layer.Type == "GridLayerDefinition") {
var Entity = new Entity();
var grid = new GridCollider(scene.Width, scene.Height, layer.GridWidth, layer.GridHeight);
grid.LoadString(xmlLevel[layer.Name].InnerText);
if (ColliderTags.ContainsKey(layer.Name)) {
grid.AddTag(ColliderTags[layer.Name]);
}
if (DisplayGrids) {
var tilemap = new Tilemap(scene.Width, scene.Height, layer.GridWidth, layer.GridHeight);
tilemap.LoadString(xmlLevel[layer.Name].InnerText, layer.Color);
Entity.AddGraphic(tilemap);
}
Entity.AddCollider(grid);
scene.Add(Entity);
Entities.Add(layer.Name, Entity);
}
if (layer.Type == "TileLayerDefinition") {
var Entity = new Entity();
var xmlTiles = xmlLevel[layer.Name];
var tileset = xmlTiles.Attributes["tileset"].Value;
var tilemap = new Tilemap(ImagePath + TileMaps[tileset], scene.Width, scene.Height, layer.GridWidth, layer.GridHeight);
foreach (XmlElement t in xmlTiles) {
tilemap.SetTile(t);
}
tilemap.Update();
Entity.AddGraphic(tilemap);
Entity.Layer = BaseTileDepth - i * TileDepthIncrement;
i++;
scene.Add(Entity);
Entities.Add(layer.Name, Entity);
}
if (layer.Type == "EntityLayerDefinition") {
var xmlEntities = xmlLevel[layer.Name];
foreach (XmlElement e in xmlEntities) {
CreateEntity(e, scene);
}
}
}
if (UseCameraBounds) {
scene.CameraBounds = new Rectangle(0, 0, scene.Width, scene.Height);
scene.UseCameraBounds = true;
}
}
/// <summary>
/// Load tiles in from a GridCollider.
/// </summary>
/// <param name="grid">The GridCollider to reference.</param>
/// <param name="color">The color to set tiles that are collidable on the grid.</param>
/// <param name="layer">The layer to place the tiles on.</param>
public void LoadGrid(GridCollider grid, Color color, Enum layer) {
LoadGrid(grid, color, Util.EnumValueToString(layer));
}
/// <summary>
/// Load tiles in from a GridCollider and choose tiles based on the shape of the grid.
/// </summary>
/// <param name="grid">The GridCollider to reference.</param>
/// <param name="layer">The layer to place the tiles on.</param>
public void LoadGridAutoTile(GridCollider grid, string layer = "") {
if (autoTileTable == null) {
SetAutoTileData(autoTileDefaultData);
}
for (var i = 0; i < grid.TileColumns; i++) {
for (var j = 0; j < grid.TileRows; j++) {
if (grid.GetTile(i, j)) {
int tileValue = 0;
/*
* auto tiling grid
*
* 128 001 016
* 008 ___ 002
* 064 004 032
*
*/
if (grid.GetTile(i - 1, j - 1)) {
tileValue += 128;
}
if (grid.GetTile(i, j - 1)) {
tileValue += 1;
}
if (grid.GetTile(i + 1, j - 1)) {
tileValue += 16;
}
if (grid.GetTile(i + 1, j)) {
tileValue += 2;
}
if (grid.GetTile(i + 1, j + 1)) {
tileValue += 32;
}
if (grid.GetTile(i, j + 1)) {
tileValue += 4;
}
if (grid.GetTile(i - 1, j + 1)) {
tileValue += 64;
}
if (grid.GetTile(i - 1, j)) {
tileValue += 8;
}
if (autoTileTable.ContainsKey(tileValue)) {
tileValue = Rand.ChooseElement<int>(autoTileTable[tileValue]);
}
SetTile(i, j, tileValue, layer);
}
}
}
}
/// <summary>
/// Load tiles in from a GridCollider.
/// </summary>
/// <param name="grid">The GridCollider to reference.</param>
/// <param name="color">The color to set tiles that are collidable on the grid.</param>
/// <param name="layer">The layer to place the tiles on.</param>
public void LoadGrid(GridCollider grid, Color color, string layer = "") {
for (var i = 0; i < grid.TileColumns; i++) {
for (var j = 0; j < grid.TileRows; j++) {
if (grid.GetTile(i, j)) {
SetTile(i, j, color, layer);
}
}
}
}
/// <summary>
/// Load tiles in from a GridCollider.
/// </summary>
/// <param name="grid">The GridCollider to reference.</param>
/// <param name="color">The color to set tiles that are collidable on the grid.</param>
/// <param name="layer">The layer to place the tiles on.</param>
public void LoadGrid(GridCollider grid, Color color, Enum layer)
{
LoadGrid(grid, color, Util.EnumValueToString(layer));
}
/// <summary>
/// Load tiles in from a GridCollider and choose tiles based on the shape of the grid.
/// </summary>
/// <param name="grid">The GridCollider to reference.</param>
/// <param name="layer">The layer to place the tiles on.</param>
public void LoadGridAutoTile(GridCollider grid, string layer = "")
{
if (autoTileTable == null)
{
SetAutoTileData(autoTileDefaultData);
}
for (var i = 0; i < grid.TileColumns; i++)
{
for (var j = 0; j < grid.TileRows; j++)
{
if (grid.GetTile(i, j))
{
int tileValue = 0;
/*
* auto tiling grid
*
* 128 001 016
* 008 ___ 002
* 064 004 032
*
*/
if (grid.GetTile(i - 1, j - 1))
{
tileValue += 128;
}
if (grid.GetTile(i, j - 1))
{
tileValue += 1;
}
if (grid.GetTile(i + 1, j - 1))
{
tileValue += 16;
}
if (grid.GetTile(i + 1, j))
{
tileValue += 2;
}
if (grid.GetTile(i + 1, j + 1))
{
tileValue += 32;
}
if (grid.GetTile(i, j + 1))
{
tileValue += 4;
}
if (grid.GetTile(i - 1, j + 1))
{
tileValue += 64;
}
if (grid.GetTile(i - 1, j))
{
tileValue += 8;
}
if (autoTileTable.ContainsKey(tileValue))
{
tileValue = Rand.ChooseElement <int>(autoTileTable[tileValue]);
}
SetTile(i, j, tileValue);
}
}
}
}
public void LoadLevel(String LevelToLoad)
{
Global.theGame.Color = new Color("9cd9e2");
CurrentLevel = LevelToLoad;
LoadedLevel = new TiledProject(LevelToLoad);
// Load Layers
BackgroundLayer = LoadedLevel.CreateTilemap((TiledTileLayer)LoadedLevel.Layers[0]);
SolidLayer = LoadedLevel.CreateTilemap((TiledTileLayer)LoadedLevel.Layers[1]);
DecorationLayer = LoadedLevel.CreateTilemap((TiledTileLayer)LoadedLevel.Layers[2]);
// Create collision layer
CollisionLayer = LoadedLevel.CreateGridCollider((TiledTileLayer)LoadedLevel.Layers[1], Tags.GROUND_SOLID_COLLISION);
Entity CollisionEnt = new Entity();
CollisionEnt.AddCollider(CollisionLayer);
Add(CollisionEnt);
// Add Graphics for lower layers
AddGraphic(BackgroundLayer);
AddGraphic(SolidLayer);
// Objects go between the solid and decoration layers
CreateLevelObjects();
// Set camera bounds based on map size.
UseCameraBounds = true;
ApplyCamera = true;
CameraBounds.X = 0;
CameraBounds.Y = 0;
CameraBounds.Width = LoadedLevel.PixelWidth;
CameraBounds.Height = LoadedLevel.PixelHeight;
// Finish up
Entity ForegroundEnt = new Entity();
ForegroundEnt.AddGraphic(DecorationLayer);
ForegroundEnt.Layer = Layers.FG;
Add(ForegroundEnt);
}
/// <summary>
/// Load data into a scene from a source .oel file.
/// </summary>
/// <param name="source">The oel to load.</param>
/// <param name="scene">The scene to load into.</param>
public void LoadLevel(string source, Scene scene)
{
Entities.Clear();
var xmlDoc = new XmlDocument();
xmlDoc.Load(source);
var xmlLevel = xmlDoc["level"];
scene.Width = int.Parse(xmlDoc["level"].Attributes["width"].Value);
scene.Height = int.Parse(xmlDoc["level"].Attributes["height"].Value);
int i = 0;
foreach (var layer in Layers.Values)
{
if (layer.Type == "GridLayerDefinition")
{
var Entity = new Entity();
var grid = new GridCollider(scene.Width, scene.Height, layer.GridWidth, layer.GridHeight);
grid.LoadString(xmlLevel[layer.Name].InnerText);
if (ColliderTags.ContainsKey(layer.Name))
{
grid.AddTag(ColliderTags[layer.Name]);
}
if (DisplayGrids)
{
var tilemap = new Tilemap(scene.Width, scene.Height, layer.GridWidth, layer.GridHeight);
tilemap.LoadString(xmlLevel[layer.Name].InnerText, layer.Color);
Entity.AddGraphic(tilemap);
}
Entity.AddCollider(grid);
scene.Add(Entity);
Entities.Add(layer.Name, Entity);
}
if (layer.Type == "TileLayerDefinition")
{
var Entity = new Entity();
var xmlTiles = xmlLevel[layer.Name];
var tileset = xmlTiles.Attributes["tileset"].Value;
var tilemap = new Tilemap(ImagePath + TileMaps[tileset], scene.Width, scene.Height, layer.GridWidth, layer.GridHeight);
foreach (XmlElement t in xmlTiles)
{
tilemap.SetTile(t);
}
tilemap.Update();
Entity.AddGraphic(tilemap);
Entity.Layer = BaseTileDepth - i * TileDepthIncrement;
i++;
scene.Add(Entity);
Entities.Add(layer.Name, Entity);
}
if (layer.Type == "EntityLayerDefinition")
{
var xmlEntities = xmlLevel[layer.Name];
if (xmlEntities != null)
{
foreach (XmlElement e in xmlEntities)
{
CreateEntity(e, scene);
}
}
}
}
if (UseCameraBounds)
{
scene.CameraBounds = new Rectangle(0, 0, scene.Width, scene.Height);
scene.UseCameraBounds = true;
}
}
