/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
SpriteBatch = new SpriteBatch(GraphicsDevice);
// TODO: use this.Content to load your game content here
player.Load(Content);
enemy.Load(Content);
var ViewportAdapter = new BoxingViewportAdapter(Window, GraphicsDevice, ScreenWidth, ScreenHeight);
Camera = new Camera2D(ViewportAdapter);
Camera.Position = new Vector2(0, ScreenHeight);
Map = Content.Load <TiledMap>("Level1");
foreach (TiledTileLayer Layer in Map.TileLayers)
{
if (Layer.Name == "Collisions")
{
CollisionLayer = Layer;
}
}
Arialfont = Content.Load <SpriteFont>("Arial");
Heart = Content.Load <Texture2D>("Heart");
AIE.StateManager.CreateState("Splash", new SplashState());
AIE.StateManager.CreateState("Game", new GameState());
AIE.StateManager.CreateState("GamerOver", new GameOverState());
AIE.StateManager.PushState("Splash");
foreach (TiledObjectGroup Group in Map.ObjectGroups)
{
if (Group.Name == "Enemies")
{
foreach (TiledObject Obj in Group.Objects)
{
Enemy enemy = new Enemy(this);
enemy.Load(Content);
enemy.Position = new Vector2(Obj.X, Obj.Y);
Enemies.Add(enemy);
}
}
if (Group.Name == "Goal")
{
TiledObject Obj = Group.Objects[0];
if (Obj != null)
{
AnimatedTexture Anim = new AnimatedTexture(Vector2.Zero, 0, 1, 1);
Anim.Load(Content, "Goal", 1, 1);
Goal = new Sprite();
Goal.Add(Anim, 0, 5);
Goal.position = new Vector2(Obj.X, Obj.Y);
}
}
}
GameMusic = Content.Load <Song>("SuperHero_original_no_Intro");
MediaPlayer.Play(GameMusic);
}
private Entity CreateLivingEntity(PlayerData aPlayersInfo, TiledTileLayer myCollisionLayer)
{
var myEntity = createEntity(aPlayersInfo.UserID);
myEntity.addComponent(new DirectionalSprite(aPlayersInfo.GetLastSpriteDirection()));
return(myEntity);
}
public EnemyController(TiledTileLayer collisionLayer) : base()
{
_grid = new WeightedGridGraph(collisionLayer);
this.collisionState = new TiledMapMover.CollisionState();
_dir = new Vector2();
maxVelocity = 1f;
}
public void LoadNextMap(ContentManager Content)
{
levelIndex++;
if (levelIndex == 1)
{
Debug.WriteToFile("Trying to load Level " + levelIndex, true, false);
map = Content.Load <TiledMap>("Level1");
playerSpawningPosition = new Vector2(96, 96);
map = Content.Load <TiledMap>("Level1");
Debug.WriteToFile("Level " + levelIndex + " has been loaded", true, false);
}
else if (levelIndex == 2)
{
Game1.theGame.gameStates.InitGame();
Game1.theGame.player.isVisible = true;
Game1.theGame.gameStates.isVisible = true;
Debug.WriteToFile("Trying to load Level " + levelIndex, true, false);
Game1.theGame.gameStates.isVisible = true;
playerSpawningPosition = new Vector2(576, 512);
map = Content.Load <TiledMap>("Level2");
Debug.WriteToFile("Level " + levelIndex + " has been loaded", true, false);
Game1.theGame.gameStates.isVisible = true;
}
Game1.theGame.player.sPosition = playerSpawningPosition;
foreach (TiledTileLayer layer in map.TileLayers)
{
if (layer.Name == "Collisions")
{
collisionLayer = layer;
}
}
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
// TODO: use this.Content to load your game content here
player.Load(Content);
arialFont = Content.Load <SpriteFont>("Arial");
heart = Content.Load <Texture2D>("heart");
var viewportAdapter = new BoxingViewportAdapter(Window, GraphicsDevice,
(int)(graphics.GraphicsDevice.Viewport.Width), (int)(graphics.GraphicsDevice.Viewport.Height));
camera = new Camera2D(viewportAdapter);
camera.Position = player.Position - new Vector2(ScreenWidth, ScreenHeight);
map = Content.Load <TiledMap>("Level1");
foreach (TiledTileLayer layer in map.TileLayers)
{
if (layer.Name == "Collisions")
{
collisionLayer = layer;
}
}
foreach (TiledObjectGroup group in map.ObjectGroups)
{
if (group.Name == "enemies")
{
foreach (TiledObject obj in group.Objects)
{
Enemy enemy = new Enemy(this);
enemy.Load(Content);
enemy.Position = new Vector2(obj.X, obj.Y);
enemies.Add(enemy);
}
}
if (group.Name == "goal")
{
TiledObject obj = group.Objects[0];
if (obj != null)
{
AnimatedTexture anim = new AnimatedTexture(
Vector2.Zero, 0, 1, 1);
anim.Load(Content, "chest", 1, 1);
goal = new Sprite();
goal.Add(anim, 0, 5);
goal.position = new Vector2(obj.X, obj.Y);
}
}
}
gameMusic = Content.Load <Song>("Superhero_Violin");
MediaPlayer.Play(gameMusic);
}
public TiledMapComponent(TiledMap tiledmap, string collisionLayerName = null)
{
this.tiledMap = tiledmap;
if (collisionLayerName != null)
{
collisionLayer = tiledmap.getLayer <TiledTileLayer>(collisionLayerName);
}
}
public TiledMapComponent(TiledMap tiledMap, string collisionLayerName = null, bool shouldCreateColliders = true)
{
this.tiledMap = tiledMap;
_shouldCreateColliders = shouldCreateColliders;
if (collisionLayerName != null)
{
collisionLayer = tiledMap.getLayer <TiledTileLayer>(collisionLayerName);
}
}
public Enemy(List <Subtexture> subtextures, TiledTileLayer collisionLayer, Effect flashEffect, EnemyType type = EnemyType.Patrol) : base("enemy")
{
var sprite = addComponent(new Sprite <Animations>(subtextures[32]));
sprite.renderLayer = (int)Constants.RenderLayers.Object;
material = new FlashWhiteMaterial(flashEffect);
sprite.material = material;
animationManager = new AnimationManager(sprite, subtextures);
addComponent(animationManager);
switch (type)
{
case EnemyType.Turret:
sprite.play(Animations.RobotTurret);
break;
case EnemyType.ArcTurret:
sprite.play(Animations.RobotArcTurret);
break;
default:
sprite.play(Animations.RobotIdle);
break;
}
var box = addComponent(new BoxCollider(16, 16));
box.name = Strings.MoveCollider;
box.physicsLayer = PhysicsLayers.move;
box.collidesWithLayers = PhysicsLayers.tiles;
addComponent(new TiledMapMover(collisionLayer));
var hurtBox = addComponent(new BoxCollider(16, 14));
hurtBox.name = Strings.HitCollider;
hurtBox.physicsLayer = PhysicsLayers.enemyHit;
hurtBox.collidesWithLayers = PhysicsLayers.playerBullet;
hurtBox.isTrigger = true;
var hitBox = addComponent(new BoxCollider(16, 12));
hitBox.name = Strings.AttackCollider;
hitBox.physicsLayer = PhysicsLayers.enemyBullet;
hitBox.collidesWithLayers = PhysicsLayers.playerHit;
hitBox.isTrigger = true;
var hp = new Health(3, onHit, onDeath);
addComponent(hp);
var controller = new EnemyController(type);
addComponent(controller);
}
public void CheckForCollision(TiledMap map)
{
// Collision with bottom of map
if (this.BoundingRect.Bottom > map.HeightInPixels)
{
this.position.Y = map.HeightInPixels - texture.Height;
this.velocity.Y = 0;
onGround = true;
}
// Collision with top of map
if (this.BoundingRect.Top < 0)
{
this.position.Y = 0;
this.velocity.Y = 0;
}
// Collision with top of map
if (this.BoundingRect.Left < 0)
{
this.position.X = 0;
this.velocity.X = 0;
}
// Collision with top of map
if (this.BoundingRect.Right > map.WidthInPixels)
{
this.position.X = map.WidthInPixels - texture.Width;
this.velocity.X = 0;
}
// Check for collision using collision layer
TiledTileLayer layer = (TiledTileLayer)map.GetLayer("Collision");
foreach (var tile in layer.Tiles)
{
if (
((tile.X * 32) > this.BoundingRect.Right) ||
((tile.Y * 32) > this.BoundingRect.Bottom) ||
(((tile.X * 32) + 32) < this.BoundingRect.Left) ||
(((tile.Y * 32) + 32) < this.BoundingRect.Top)
)
{
continue;
}
var region = map.GetTileRegion(tile.Id);
if (region != null && region.Texture.Name == "Tilesets/collision" &&
(region.X + region.Y == 35))
{
this.position.Y = (tile.Y * 32) - this.BoundingRect.Height;
this.velocity.Y = 0;
onGround = true;
}
}
}
public TiledMapComponent(TiledMap tiledmap, string collisionLayerName = null)
{
this.tiledmap = tiledmap;
if (collisionLayerName != null)
{
_collisionLayer = tiledmap.getLayer <TiledTileLayer>(collisionLayerName);
}
Debug.warnIf(tiledmap.renderOrder != TiledRenderOrder.RightDown, "The TiledMap render order is not RightDown. Bad things might happen because of that.");
}
public void Load(NezContentManager content, Vector2 ScreenVector)
{
myMap = new TiledMap(0, (int)ScreenVector.X, (int)ScreenVector.Y, TileData.TileSize, TileData.TileSize, TiledMapOrientation.Orthogonal);
//TODO: multilayer support
TiledTileLayer Floors = (TiledTileLayer)myMap.createTileLayer("Floors", (int)ScreenVector.X, (int)ScreenVector.Y);
Collidables = (TiledTileLayer)myMap.createTileLayer("Walls", (int)ScreenVector.X, (int)ScreenVector.Y);
int XOffset = (int)Mathf.ceil(0.5f * (ScreenVector.X / TileData.TileSize));
int YOffset = (int)Mathf.ceil(0.5f * (ScreenVector.Y / TileData.TileSize));
TiledTileset BaseMapTileset = myMap.createTileset(content.Load <Texture2D>(this.MapTextureAtlas), 0, 64, 64, true, 0, 0, this.TextureAtlasTileWidth, this.TextureAtlasTileHeight);
for (int x = 0; x < Mathf.ceil(ScreenVector.X / TileData.TileSize); x++)
{
for (int y = 0; y < Mathf.ceil(ScreenVector.X / TileData.TileSize); x++)
{
TileData myTileData;
TiledTile myTile;
Tuple <float, float, float> tuple = new Tuple <float, float, float>(x, y, (float)Math.Ceiling(TileData.MaxHeight * myNoise.GetNoise(x, y)));
if (myModifiedTiles.TryGetValue(tuple, out myTileData))
{
myTile = new TiledTile(myTileData.TileSetID);
myTile.tileset = myMap.createTileset(content.Load <Texture2D>(myTileData.TilesetName), 0, TileData.TileSize, TileData.TileSize, true, 0, 0, myTileData.TextureAtlasTileWidth, myTileData.TextureAtlasTileHeight);
if (myTileData.isWall)
{
Collidables.setTile(myTile);
}
else
{
Floors.setTile(myTile);
}
}
else
{
if (tuple.Item3 > 0)
{
myTile = new TiledTile(1);
myTile.tileset = BaseMapTileset;
Collidables.setTile(myTile);
}
else if (tuple.Item3 == 0)
{
myTile = new TiledTile(0);
myTile.tileset = BaseMapTileset;
Floors.setTile(myTile);
}
else
{
continue;
}
}
}
}
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
player.Load(Content);
var ViewportAdapter = new BoxingViewportAdapter(Window, GraphicsDevice, ScreenWidth, ScreenHeight);
camera = new Camera2D(ViewportAdapter);
camera.Position = new Vector2(0, ScreenHeight);
map = Content.Load <TiledMap>("Level1");
foreach (TiledTileLayer layer in map.TileLayers)
{
if (layer.Name == "Collisions")
{
collisionLayer = layer;
}
gameMusic = Content.Load <Song>("SuperHero_original_no_Intro");
MediaPlayer.Play(gameMusic);
}
foreach (TiledObjectGroup group in map.ObjectGroups)
{
if (group.Name == "Enemies")
{
foreach (TiledObject obj in group.Objects)
{
Enemy enemy = new Enemy(this);
enemy.Load(Content);
enemy.Position = new Vector2(obj.X, obj.Y);
enemies.Add(enemy);
}
}
Debug.WriteLine(group.Name);
if (group.Name == "Goal")
{
TiledObject obj = group.Objects[0];
if (obj != null)
{
AnimatedTexture anim = new AnimatedTexture(Vector2.Zero, 0, 1, 1);
anim.Load(Content, "chest", 1, 1);
goal = new Sprite();
goal.Add(anim, 0, 5);
goal.position = new Vector2(obj.X, obj.Y);
}
}
// TODO: use this.Content to load your game content here
}
}
private static void ReadCsvTileLayer(TiledTileLayer layer, XElement root)
{
var value = root.Value;
if (!String.IsNullOrEmpty(value))
{
var parsed = value.Split(',')
.Select(s => Int32.Parse(s, NumberStyles.Integer | NumberStyles.AllowTrailingWhite | NumberStyles.AllowLeadingWhite, CultureInfo.InvariantCulture))
.ToArray();
layer.SetTileData(parsed);
}
}
private static void InitializeTiledLayer(TiledTileLayer layer, int tilesCount)
{
if (layer.Tiles == null || layer.Tiles.Length != tilesCount)
{
layer.Tiles = new TiledTile[tilesCount];
}
for (var i = 0; i < tilesCount; i++)
{
layer.Tiles[i] = new TiledTile
{
Id = 70
};
}
}
public override void onStart()
{
myMapData.Load(content, ScreenVector);
myCollisionLayer = myMapData.GetCollisionLayer();
List <PlayerData> myPlayers = myMapData.GetAllPlayersData();
foreach (PlayerData A in myPlayers)
{
if (A != myPlayerInfo)
{
myActiveEntities.Add(CreateLivingEntity(A, myCollisionLayer));
}
}
base.onStart();
}
public Enemy(String inEntityType, int inTotalLife, TiledMap inMap, bool enemyHasGun, int ntargetPositionRange)
{
EntityType = inEntityType;
TileMap = inMap;
TotalLife = inTotalLife;
CurrentLife = TotalLife;
CollisionLayer = TileMap.getLayer <TiledTileLayer>("collisionLayer");
WeightedGraph = new WeightedGridGraph(CollisionLayer);
Start = new Point(1, 1);
End = new Point(10, 10);
WeightedSearchPath = WeightedGraph.search(Start, End);
EnemyCanShootGun = enemyHasGun;
TargetPositionRange = ntargetPositionRange;
PlayerRef = Player.PlayerRef;
}
/// <summary>
/// creates a WeightedGridGraph from a TiledTileLayer. Present tile are walls and empty tiles are passable.
/// </summary>
/// <param name="tiledLayer">Tiled layer.</param>
public AstarGridGraph(TiledTileLayer tiledLayer)
{
_width = tiledLayer.Width;
_height = tiledLayer.Height;
for (var y = 0; y < tiledLayer.TiledMap.Height; y++)
{
for (var x = 0; x < tiledLayer.TiledMap.Width; x++)
{
if (tiledLayer.GetTile(x, y) != null)
{
Walls.Add(new Point(x, y));
}
}
}
}
public UnweightedGridGraph(TiledTileLayer tiledLayer)
{
_width = tiledLayer.width;
_height = tiledLayer.height;
for (var y = 0; y < tiledLayer.tiledMap.height; y++)
{
for (var x = 0; x < tiledLayer.tiledMap.width; x++)
{
if (tiledLayer.getTile(x, y) != null)
{
walls.Add(new Point(x, y));
}
}
}
}
public override void initialize()
{
clearColor = Color.CornflowerBlue;
var renderer = addRenderer(new DefaultRenderer());
tiledMap = content.Load <TiledMap>("test");
var tiledEntity = this.createEntity("debugMap");
var tiledMapComponent = tiledEntity.addComponent(new TiledMapComponent(tiledMap, "collision"));
tiledMapComponent.setLayersToRender("collision");
collisionLayer = tiledMapComponent.collisionLayer;
var offscreenColliders = addEntity(new Entity());
offscreenColliders.addComponent(new BoxCollider(-32, 112, 32, 32));
offscreenColliders.addComponent(new BoxCollider(256, 112, 32, 32));
}
public int CellAtTileCoord(int tx, int ty, TiledTileLayer layer)
{
if (tx < 0 || tx >= map.Width || ty < 0)
{
return(1);
}
if (ty >= map.Height)
{
return(0);
}
TiledTile tile = layer.GetTile(tx, ty);
return(tile.Id);
}
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
// TODO: use this.Content to load your game content here
player.Load(Content);
LoadEmitter();
arialFont = Content.Load <SpriteFont>("Arial");
heart = Content.Load <Texture2D>("Heart");
var viewportAdapter = new BoxingViewportAdapter(GraphicsDevice, viewWidth, viewHeight);
camera = new Camera2D(viewportAdapter);
camera.Position = new Vector2(0, ScreenHeight / 2);
map = Content.Load <TiledMap>("PLS");
foreach (TiledTileLayer layer in map.TileLayers)
{
if (layer.Name == "Collisions")
{
collisionLayer = layer;
}
}
map = Content.Load <TiledMap>("PLS");
foreach (TiledTileLayer layer in map.TileLayers)
{
if (layer.Name == "KillTiles")
{
killLayer = layer;
}
}
// game music
gameMusic = Content.Load <Song>("SuperHero_violin_no_Intro");
MediaPlayer.Play(gameMusic);
//loading enemies
LoadAllEnemies();
//loading items
LoadAllCoins();
}
public Debris(TiledTileLayer collisionLayer, Vector2 position, List <Subtexture> subtextures, float xDir = 0f, float yDir = 0f) : base()
{
//get initial vel
float xSpeed = Nez.Random.range(-maxSpeedX, maxSpeedX);
float ySpeed = Nez.Random.range(-maxYSpeed, minYSpeed);
if (xDir > 0f)
{
xSpeed = Nez.Random.range(0f, 2f * maxSpeedX);
}
else if (xDir < 0f)
{
xSpeed = Nez.Random.range(-maxSpeedX, 0f);
}
if (yDir > 0f)
{
ySpeed = Nez.Random.range(0f, maxYSpeed);
}
else if (yDir < 0f)
{
ySpeed = Nez.Random.range(-maxYSpeed, 0f);
}
//sprite
int spriteNum = Nez.Random.range(144, 149);
var sprite = new Sprite(subtextures[spriteNum]);
sprite.renderLayer = (int)Constants.RenderLayers.Decorative;
//sprite.color = new Color(90, 83, 83);
addComponent(sprite);
//move collide box
var box = new BoxCollider(4, 4);
box.name = Constants.Strings.MoveCollider;
addComponent(box);
//tiled mover
var tiledMover = new TiledMapMover(collisionLayer);
addComponent(tiledMover);
//debris controller
var controller = new DebrisController();
controller.SetInitialy(new Vector2(xSpeed, ySpeed));
addComponent(controller);
this.position = position;
}
public UnweightedGridGraph(TiledTileLayer tiledLayer)
{
_width = tiledLayer.Width;
_height = tiledLayer.Height;
_dirs = CARDINAL_DIRS;
for (var y = 0; y < tiledLayer.TiledMap.Height; y++)
{
for (var x = 0; x < tiledLayer.TiledMap.Width; x++)
{
if (tiledLayer.GetTile(x, y) != null)
{
Walls.Add(new Point(x, y));
}
}
}
}
private static void ReadBase64TileLayer(TiledTileLayer layer, XElement root)
{
var compression = root.ReadAttribute("compression", string.Empty);
var content = root.Value;
using (var unencoded = new MemoryStream(Convert.FromBase64String(content), false))
using (var uncompressed = unencoded.GetDecompressor(compression))
using (var reader = new BinaryReader(uncompressed))
{
var tiles = new int[layer.Width * layer.Height];
for (var i = 0; i < layer.Width * layer.Height; i++)
{
tiles[i] = reader.ReadInt32();
}
layer.SetTileData(tiles);
}
}
public void LayerAccessTest()
{
var map = new TiledMap("test.tmx");
Assert.IsNotNull(map.Layers[0] as TiledTileLayer);
Assert.IsNotNull(map.Layers[1] as TiledObjectGroup);
Assert.IsNotNull(map.Layers[2] as TiledTileLayer);
Assert.IsNotNull(map["Background"] as TiledTileLayer);
Assert.IsNotNull(map["Middleground"] as TiledObjectGroup);
Assert.IsNotNull(map["Foreground"] as TiledTileLayer);
map["Middleground"] = new TiledTileLayer {
Name = "Middleground"
};
Assert.IsNotNull(map["Middleground"]);
}
private static void ReadBase64TileLayer(TiledTileLayer layer, XElement root)
{
string compression = root.ReadAttribute<string>("compression", string.Empty);
bool canCompress = new[] { "gzip", "zlib", string.Empty }.Contains(compression.ToLower());
string content = root.Value;
using (Stream unencoded = new MemoryStream(Convert.FromBase64String(content), false))
using (Stream uncompressed = unencoded.GetDecompressor(compression))
using (BinaryReader reader = new BinaryReader(uncompressed))
{
var tiles = new int[layer.Width * layer.Height];
for (int i = 0; i < layer.Width * layer.Height; i++)
{
tiles[i] = reader.ReadInt32();
}
layer.SetTileData(tiles);
}
}
private void Restart()
{
foreach (TiledTileLayer layer in map.TileLayers)
{
if (layer.Name == "Collisions")
{
collisionLayer = layer;
}
gameMusic = Content.Load <Song>("SuperHero_original_no_Intro");
MediaPlayer.Play(gameMusic);
}
foreach (TiledObjectGroup group in map.ObjectGroups)
{
if (group.Name == "Enemies")
{
foreach (TiledObject obj in group.Objects)
{
Enemy enemy = new Enemy(this);
enemy.Load(Content);
enemy.Position = new Vector2(obj.X, obj.Y);
enemies.Add(enemy);
}
}
Debug.WriteLine(group.Name);
if (group.Name == "Goal")
{
TiledObject obj = group.Objects[0];
if (obj != null)
{
AnimatedTexture anim = new AnimatedTexture(Vector2.Zero, 0, 1, 1);
anim.Load(Content, "chest", 1, 1);
goal = new Sprite();
goal.Add(anim, 0, 5);
goal.position = new Vector2(obj.X, obj.Y);
}
}
// TODO: use this.Content to load your game content here
}
}
/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Draw(GameTime gameTime)
{
// Draw background
GraphicsDevice.Clear(_tiledMap.BackgroundColor ?? Color.Black);
_spriteBatch.Begin();
_spriteBatch.Draw(background, new Rectangle(0, 0, 800, 480), Color.White);
_spriteBatch.End();
_spriteBatch.Begin(transformMatrix: _camera.GetViewMatrix());
// or you can have more control over drawing each individual layer
foreach (var layer in _tiledMap.Layers)
{
TiledTileLayer tiledTileLayer = layer as TiledTileLayer;
TiledTile t = tiledTileLayer.GetTile(0, 24);
_spriteBatch.Draw(layer, _camera);
}
_spriteBatch.Draw(_sprite); // Draws a sprite over the cursor
_spriteBatch.End();
//mainUI.Update (_spriteBatch, _world.WorldCalendar, gameTime);
// var textColor = Color.White;
// _spriteBatch.Begin(samplerState: SamplerState.PointClamp, blendState: BlendState.AlphaBlend);
// _spriteBatch.DrawString(_bitmapFont, "WASD/Arrows: move", new Vector2(5, 32), textColor);
// _spriteBatch.DrawString(_bitmapFont, "RF: zoom", new Vector2(5, 32 + _bitmapFont.LineSpacing), textColor);
// _spriteBatch.DrawString(_bitmapFont, $"FPS: {_fpsCounter.AverageFramesPerSecond:0}", Vector2.One, Color.AliceBlue);
// _spriteBatch.DrawString(_bitmapFont, "Tile: " + mouseOverTile.X + "," + mouseOverTile.Y, new Vector2(5, 32 + _bitmapFont.LineSpacing*2), Color.AliceBlue);
// _spriteBatch.DrawString(_bitmapFont, "MouseOver: " + mouseScreenPostion.X + "," + mouseScreenPostion.Y, new Vector2(5, 32 + _bitmapFont.LineSpacing*3), Color.AliceBlue);
// _spriteBatch.End();
base.Draw(gameTime);
}
public Player(InputHandler input, List <Subtexture> subtextures, TiledTileLayer collisionLayer, Entity followEntity, Vector2 velocity = new Vector2()) : base("player")
{
this.followEntity = followEntity;
var sprite = addComponent(new Sprite <Animations>(subtextures[32]));
sprite.renderLayer = (int)Constants.RenderLayers.Object;
var weaponSprite = addComponent(new Sprite(subtextures[82]));
weaponSprite.renderLayer = (int)Constants.RenderLayers.Foreground;
weaponSprite.name = Strings.Weapon;
var animManager = new AnimationManager(sprite, subtextures);
addComponent(animManager);
var box = addComponent(new BoxCollider(16, 16));
box.name = Strings.MoveCollider;
box.physicsLayer = PhysicsLayers.move;
box.collidesWithLayers = PhysicsLayers.tiles;
addComponent(new TiledMapMover(collisionLayer));
var playerController = addComponent(new PlayerController(input, followEntity));
playerController.velocity = velocity;
var collectionBox = addComponent(new BoxCollider(12, 12));
collectionBox.isTrigger = true;
collectionBox.physicsLayer = PhysicsLayers.collect;
collectionBox.collidesWithLayers = PhysicsLayers.mcguff;
var hurtBox = addComponent(new BoxCollider(12, 12));
hurtBox.isTrigger = true;
hurtBox.physicsLayer = Constants.PhysicsLayers.playerHit;
hurtBox.collidesWithLayers = Constants.PhysicsLayers.enemyBullet;
hurtBox.name = Constants.Strings.HitCollider;
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
// TODO: use this.Content to load your game content here
player.Load(Content);
asteroid.Load(Content);
var viewportAdapter = new BoxingViewportAdapter(Window, GraphicsDevice,
ScreenWidth, ScreenHeight);
camera = new Camera2D(viewportAdapter);
camera.Position = new Vector2(0, ScreenHeight);
map = Content.Load <TiledMap>("nm1");
foreach (TiledTileLayer layer in map.TileLayers)
{
if (layer.Name == "Floor")
{
collisionLayer = layer;
}
}
}
private Object[] CollisionLogic(TiledTileLayer layer)
{
int tx = game.PixelToTile(sprite.position.X);
int ty = game.PixelToTile(sprite.position.Y);
// x % y divides x by y then looks at the remainder
// because tile = 64, when the sprite's position (a single pixel)
// is equal to 64, the remainder is zero,
// therefore the sprite is only on one tile
// in any other case, it is overlapping two or more tiles
// therefore the bools are true
// nx checks left/right overlapping
// ny checks up/down overlapping
bool nx = (sprite.position.X) % Game1.tile != 0;
bool ny = (sprite.position.Y) % Game1.tile != 0;
bool cell = game.CellAtTileCoord(tx, ty, layer) != 0;
bool cellright = game.CellAtTileCoord(tx + 1, ty, layer) != 0;
bool celldown = game.CellAtTileCoord(tx, ty + 1, layer) != 0;
bool celldiag = game.CellAtTileCoord(tx + 1, ty + 1, layer) != 0;
return(new Object[] { tx, ty, nx, ny, cell, cellright, celldown, celldiag });
}
private static void ReadTileLayer(TiledMap map, XElement root)
{
var layer = new TiledTileLayer();
// Read generic layer information.
ReadGenericLayerInformation(layer, root);
// Read layer data.
var dataElement = root.Element("data");
if (dataElement != null)
{
ReadTileLayerData(layer, dataElement);
}
map.Layers.Add(layer);
}
public TiledCollisionSystem(IPossibleMovements possibleMovements, TiledMap map, string collisionLayerName) : base(possibleMovements)
{
TileCollisionLayer = map.GetLayer <TiledTileLayer>(collisionLayerName);
}
private static void ReadTileLayerData(TiledTileLayer layer, XElement root)
{
var encoding = root.ReadAttribute<string>("encoding", null);
if (encoding != null)
{
if (encoding.Equals("csv", StringComparison.OrdinalIgnoreCase))
ReadCsvTileLayer(layer, root);
else if (encoding.Equals("base64", StringComparison.OrdinalIgnoreCase))
ReadBase64TileLayer(layer, root);
}
}
private static TileLayerContent CreateTileLayer(TiledMap source, MapContent map, TiledTileLayer layer, int id)
{
var content = new TileLayerContent();
content.Id = id;
content.Name = layer.Name;
content.Opacity = layer.Opacity;
for (var gridIndex = 0; gridIndex < layer.Tiles.Length; gridIndex++)
{
var tileIndex = layer.Tiles[gridIndex];
if (tileIndex == 0)
{
// The tile with index 0 is reserved (nothing).
continue;
}
// Find witch tiled tileset the index belongs to...
var tiledTileset = source.Tilesets.Where(t => t.FirstId <= tileIndex).OrderByDescending(t => t.FirstId).FirstOrDefault();
if (tiledTileset == null)
{
tiledTileset = source.Tilesets.Where(t => t.FirstId >= tileIndex).OrderByDescending(t => t.FirstId).FirstOrDefault();
if (tiledTileset == null)
{
throw new InvalidOperationException("Could not find tileset.");
}
}
// Find the tileset reference.
var tileset = map.Tilesets[source.Tilesets.IndexOf(tiledTileset)];
var tileContent = new TileContent();
tileContent.GridIndex = gridIndex;
tileContent.TileSetId = tileset.Index;
tileContent.TilesetIndex = tileIndex - tiledTileset.FirstId;
content.Tiles.Add(tileContent);
}
return(content);
}
