public Map()
{
Layer = (int)Global.LayerPriority.Map;
Tilemap = new Tilemap(Resources.Sprites.TILE_IMG, Global.WIDTH, Global.HEIGHT, 32, 32);
Tilemap.CenterOrigin();
AddGraphic(Tilemap);
//Graphic.CenterOrigin();
Tilemap.SetTile(0, 0, 0);
Tilemap.SetTile(1, 0, 0);
Tilemap.SetTile(2, 0, 0);
Tilemap.SetTile(0, 4, 1);
Tilemap.SetTile(2, 12, 3);
}
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 collision data from a Tilemap.
/// </summary>
/// <param name="source">The source Tilemap.</param>
/// <param name="layerName">The layer of tiles to use to mark collisions.</param>
public void LoadTilemap(Tilemap source, Enum layerName)
{
LoadTilemap(source, source.LayerDepth(layerName));
}
/// <summary>
/// Load collision data from a Tilemap.
/// </summary>
/// <param name="source">The source Tilemap.</param>
/// <param name="layerDepth">The layer of tiles to use to mark collisions.</param>
public void LoadTilemap(Tilemap source, int layerDepth)
{
if (source.Width != Width) throw new ArgumentException("Tilemap size and tile size must match grid size and tile size.");
if (source.Height != Height) throw new ArgumentException("Tilemap size and tile size must match grid size and tile size.");
if (source.TileWidth != TileWidth) throw new ArgumentException("Tilemap size and tile size must match grid size and tile size.");
if (source.TileWidth != TileWidth) throw new ArgumentException("Tilemap size and tile size must match grid size and tile size.");
foreach(var t in source.GetTiles(layerDepth)) {
SetTile(t.X / TileWidth, t.Y / TileHeight, 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>
/// Returns the index of the tile on the source Texture of a Tilemap.
/// </summary>
/// <param name="tilemap">The Tilemap that uses the Texture to be tested against.</param>
/// <returns>The index of the tile on the Tilemap's Texture.</returns>
public int GetIndex(Tilemap tilemap) {
return Util.OneDee(tilemap.Texture.Width / Width, TX / Width, TY / Height);
}
/// <summary>
/// Merges another tilemap into this one.
/// </summary>
/// <param name="other">The tilemap to merge into this one.</param>
/// <param name="above">True if the other tilemap's base layer should be above this one's base layer.</param>
public void MergeTilemap(Tilemap other, string layerPrefix = "", int layerOffset = -1) {
foreach (var layer in other.TileLayers) {
AddLayer(layerPrefix + other.LayerName(layer.Key), layer.Key + layerOffset);
TileLayers[layer.Key + layerOffset] = new List<TileInfo>(other.TileLayers[layer.Key]);
}
}
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 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(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(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 collision data from a Tilemap.
/// </summary>
/// <param name="source">The source Tilemap.</param>
/// <param name="layerName">The layer of tiles to use to mark collisions.</param>
public void LoadTilemap(Tilemap source, Enum layerName)
{
LoadTilemap(source, source.LayerDepth(layerName));
}
/// <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;
}
}
