private void setupMap() { var sysManager = Core.getGlobalManager <SystemManager>(); var mapId = sysManager.MapId; _tiledMap = content.Load <TiledMap>($"maps/map{mapId}"); sysManager.setTiledMapComponent(_tiledMap); var tiledEntity = createEntity("tiledMap"); var collisionLayer = _tiledMap.properties["collisionLayer"]; var defaultLayers = _tiledMap.properties["defaultLayers"].Split(',').Select(s => s.Trim()).ToArray(); _tiledMapComponent = tiledEntity.addComponent(new TiledMapComponent(_tiledMap, collisionLayer) { renderLayer = TILED_MAP_RENDER_LAYER }); _tiledMapComponent.setLayersToRender(defaultLayers); if (_tiledMap.properties.ContainsKey("aboveWaterLayer")) { var aboveWaterLayer = _tiledMap.properties["aboveWaterLayer"]; var tiledAboveWater = tiledEntity.addComponent(new TiledMapComponent(_tiledMap) { renderLayer = WATER_RENDER_LAYER }); tiledAboveWater.setLayerToRender(aboveWaterLayer); } Core.getGlobalManager <SystemManager>().setTiledMapComponent(_tiledMap); }
private void addTiledMapComponent( ) { var spriteSheet = scene.content.Load <Texture2D>("images/blocks"); var tileset = _tileMap.createTileset(spriteSheet, 0, TILESIZE, TILESIZE, true, 0, 0, TILE_COUNT, TILESET_COLUMNS); // Nez' tiledmap implementation will only take 1d arrays, // so we have to do this if we want to use the more intuitive // 2d array, unfortunatly. var _tilesTEMP = new TiledTile[WIDTH * HEIGHT]; for (int x = 0; x < _tiles.GetLength(0); x++) { for (int y = 0; y < _tiles.GetLength(1); y++) { _tiles[x, y] = new TiledTile(0); _tiles[x, y].tileset = tileset; _tilesTEMP[WIDTH * y + x] = _tiles[x, y]; } } var layer = _tileMap.createTileLayer("Default", WIDTH, HEIGHT, _tilesTEMP); var component = new TiledMapComponent(_tileMap); addComponent(component); }
public override void onAddedToEntity() { _circleCollider = entity.getComponent <CircleCollider>(); _mover = entity.getComponent <Mover>(); _physicsHandler = entity.getComponent <PhysicsHandler>(); _mapComponent = entity.scene.findEntity("tiled-map").getComponent <TiledMapComponent>(); }
public static Scene sceneOneBloom() { var scene = new Scene(); var bloomLayerRenderer = scene.addRenderer(new RenderLayerRenderer(-1, 1)); bloomLayerRenderer.renderTarget = RenderTarget.create(256, 144); bloomLayerRenderer.renderTargetClearColor = Color.Transparent; scene.addRenderer(new RenderLayerExcludeRenderer(0, 1)); scene.letterboxColor = Color.MonoGameOrange; scene.setDesignResolution(256, 144, Scene.SceneResolutionPolicy.ShowAllPixelPerfect); // load a TiledMap and move it back so is drawn before other entities var tiledEntity = scene.createEntity("tiled-map-entity"); var tiledmap = scene.contentManager.Load <TiledMap>("bin/MacOSX/Tilemap/tilemap"); var tc1 = new TiledMapComponent(tiledmap, "collision"); tc1.layerIndicesToRender = new int[] { 0, 1, 2 }; tiledEntity.addComponent(tc1); var tc2 = new TiledMapComponent(tiledmap); tiledEntity.addComponent(tc2); tc2.renderLayer = 1; tc2.layerIndicesToRender = new int[] { 3 }; scene.addPostProcessor(new PixelBloomPostProcessor(bloomLayerRenderer.renderTarget, -1)); return(scene); }
public override void onAddedToEntity() { _sprite = this.getComponent <Sprite>(); _tiledMapComponent = entity.scene.findEntity("tiled-map").getComponent <TiledMapComponent>(); _mover = new Mover(); entity.addComponent(_mover); }
private void addAnimation() { _tiledMapComponent = entity .scene.findEntity("tiled-map") .getComponent <TiledMapComponent>(); Mover = this.getComponent <TiledMapMover>(); // _mover = this.getComponent<Mover>(); }
// Scene has loaded, send data so we know how far a player gets void Start() { mapComponent = GetComponent<TiledMapComponent>(); if(mapComponent) { TrackingScript.instance.AddProperty("scene", mapComponent.MapTMX.name); TrackingScript.instance.Track("scene loaded"); } }
public override void onStart() { base.onStart(); Entity tileMapEntity = createEntity("tileMapEntity"); TiledMapComponent comp = tileMapEntity.addComponent(new TiledMapComponent(testmap)); tileMapEntity.position = new Vector2(100, 100); }
void OnEnable() { _renderer = GetComponent <Renderer>(); // Try to get TiledMap from TiledMapComponent _tiledMapComponent = GameObject.FindObjectOfType <TiledMapComponent>(); if (_tiledMapComponent != null) { _tiledMap = _tiledMapComponent.TiledMap; } }
void OnEnable() { _renderer = GetComponent<Renderer>(); // Try to get TiledMap from TiledMapComponent _tiledMapComponent = GameObject.FindObjectOfType<TiledMapComponent>(); if (_tiledMapComponent != null) { _tiledMap = _tiledMapComponent.TiledMap; } }
public static Entity Map(TiledMap Map) { TiledMapComponent M = new TiledMapComponent(Map, "collisions"); M.layerDepth = 1; Entity E = Create(new Vector2(-4), M); E.name = "map"; return(E); }
/// <summary> /// Carga un mapa de Tiled /// </summary> private void LoadMap() { mapEntity = createEntity(EntityType.TileMap.ToString()); tiledMap = content.Load <TiledMap>(Content.Map.level1); mapLayer = mapEntity.addComponent(new TiledMapComponent(tiledMap, "Map")); // Camera bounds var topLeft = new Vector2(tiledMap.tileWidth, tiledMap.tileWidth); var bottomRight = new Vector2(tiledMap.tileWidth * (tiledMap.width - 1), tiledMap.tileWidth * (tiledMap.height - 1)); mapEntity.addComponent(new CameraBounds(topLeft, bottomRight)); mapEntity.tag = (int)TagType.TileMap; //mapLayer.renderLayer = 4; }
public override void initialize() { clearColor = Color.PowderBlue; addRenderer(new DefaultRenderer()); Entity tiledEntity = createEntity("tiled-map"); TiledMap map = content.Load <TiledMap>("Temp/Temp"); TiledObject spawn = map.getObjectGroup("Entrances").objectWithName("Spawn"); TiledMapComponent mapComponent = new TiledMapComponent(map); tiledEntity.addComponent <TiledMapComponent>(mapComponent); }
private void CustomizeTiles(TiledMapComponent mapComponent) { var tileSize = new Vector2(mapComponent.tiledMap.tileWidth, mapComponent.tiledMap.tileHeight); for (float x = 0; x < mapComponent.width; x += tileSize.X) { for (float y = 0; y < mapComponent.height; y += tileSize.X) { var tilePos = new Vector2(x, y); var tile = mapComponent.getTileAtWorldPosition(tilePos); CustomizeTile(tile, tilePos, tileSize); } } }
void Start() { map = FindObjectOfType <TiledMapComponent>(); numberShoots = PlayerPrefs.GetInt("PlayerShoots", numberShoots); numberLife = PlayerPrefs.GetInt("PlayerLife", numberLife); // Locate the spawnPoint RespawnPoint[] objs = FindObjectsOfType <RespawnPoint>(); foreach (RespawnPoint r in objs) { if (r.spawnPointName.Equals(PlayerPrefs.GetString("PlayerRespawn", "Start"))) { transform.position = r.transform.position; } } }
public void OnCollisionHitboxLoaded(TiledMapComponent onComponent, Transform2 componentTrans, TmxObject hitbox, float localX, float localY) { if (hitbox.ObjectType != TmxObjectType.Basic) { Log.Info("Can only load basic objects (not " + hitbox.ObjectType + ") into physics!" + (++counter)); return; } Actor hitboxActor = stage.CreateActor(onComponent.Actor.Layer + 1); Transform2 trans = hitboxActor.AddComponent <ScaledTransform2>(); trans.LocalPosition = new Vector2(localX + (float)hitbox.X, localY + (float)hitbox.Y); Rigidbody body = hitboxActor.AddComponent <Rigidbody>(); body.Set(width: (float)hitbox.Width, height: (float)hitbox.Height, isStatic: true, isSquare: true, isTrigger: false); trans.Parent = componentTrans; }
protected void createTileMap(string mapName) { Entity tiledEntity = createEntity("tiled-map-entity"); TiledMap tiledMap = this.content.Load <TiledMap>("Maps/" + mapName); TiledMapComponent tiledMapComponent = tiledEntity.addComponent(new TiledMapComponent(tiledMap, "Collisions")); tiledMapComponent.setLayersToRender(new string[] { "Ground", "Walls", "Details" }); tiledMapComponent.renderLayer = 10; TiledMapComponent tiledMapDetailsComp = tiledEntity.addComponent(new TiledMapComponent(tiledMap)); tiledMapDetailsComp.setLayerToRender("Above-Details"); tiledMapDetailsComp.renderLayer = -1; List <TiledObjectGroup> tiledObjects = tiledMap.objectGroups; tiledEntity = TransitionManager.attachTransitionColliders(tiledObjects, tiledEntity, mapName); this.PlayerSpawn = TransitionManager.findPlayerSpawn(tiledObjects, PrevMapName); tiledMapDetailsComp.material = Material.stencilWrite(); tiledMapDetailsComp.material.effect = this.content.loadNezEffect <SpriteAlphaTestEffect>(); }
private void setupMap() { _tiledMap = content.Load <TiledMap>("maps/map"); var tiledEntity = createEntity("tiled-map"); var collisionLayer = _tiledMap.properties["collisionLayer"]; var defaultLayers = _tiledMap.properties["defaultLayers"].Split(',').Select(s => s.Trim()).ToArray(); _tiledMapComponent = tiledEntity.addComponent(new TiledMapComponent(_tiledMap, collisionLayer) { renderLayer = GlobalConstants.TILED_MAP_RENDER_LAYER }); _tiledMapComponent.setLayersToRender(defaultLayers); if (_tiledMap.properties.ContainsKey("aboveWaterLayer")) { var aboveWaterLayer = _tiledMap.properties["aboveWaterLayer"]; var tiledAboveWater = tiledEntity.addComponent(new TiledMapComponent(_tiledMap) { renderLayer = GlobalConstants.WATER_RENDER_LAYER }); tiledAboveWater.setLayerToRender(aboveWaterLayer); } }
private void setupMap() { var background = createEntity("map-background"); var texture = content.Load <Texture2D>(Content.Maps.background); _backgroundSprite = background.addComponent(new Sprite(texture) { renderLayer = BACKGROUND_RENDER_LAYER }); background.position = (virtualSize.ToVector2() / 2); var sysManager = Core.getGlobalManager <SystemManager>(); _tiledMap = content.Load <TiledMap>("maps/map"); sysManager.setTiledMapComponent(_tiledMap); var tiledEntity = createEntity("tiled-map"); var collisionLayer = _tiledMap.properties["collisionLayer"]; var defaultLayers = _tiledMap.properties["defaultLayers"].Split(',').Select(s => s.Trim()).ToArray(); _tiledMapComponent = tiledEntity.addComponent(new TiledMapComponent(_tiledMap, collisionLayer) { renderLayer = TILED_MAP_RENDER_LAYER }); _tiledMapComponent.setLayersToRender(defaultLayers); if (_tiledMap.properties.ContainsKey("aboveWaterLayer")) { var aboveWaterLayer = _tiledMap.properties["aboveWaterLayer"]; var tiledAboveWater = tiledEntity.addComponent(new TiledMapComponent(_tiledMap) { renderLayer = WATER_RENDER_LAYER }); tiledAboveWater.setLayerToRender(aboveWaterLayer); } }
void Start() { TMComponent = GetComponent<TiledMapComponent>(); TMComponent.OnMapComplet = OnMapLoaded; }
public override void initialize() { Debug.log("Scene initialized"); clearColor = Color.CornflowerBlue; addRenderer(new DefaultRenderer()); Entity tiledEntity = createEntity("tiled-map"); PlayerController playerController = new PlayerController(); Sprite playerSprite = new Sprite(content.Load <Texture2D>("Temp/TestPlayerAnimationFiles/Idle/Idle_1")); playerSprite.setRenderLayer(1); //Load map here************************************************************ TiledMap map = content.Load <TiledMap>("Temp/TestingWorld"); TiledObject spawn = map.getObjectGroup("SpawnPoint").objectWithName("Spawn"); TiledMapComponent mapComponent = new TiledMapComponent(map, "Ground"); mapComponent.setRenderLayer(2); tiledEntity.addComponent(mapComponent); #region SpawnPlayer //Create player Entity CookieCutterEntity player = new CookieCutterEntity("Player", spawn.position, ref playerSprite, playerController); //Add camera to player FollowCamera camera = new FollowCamera(player); camera.mapLockEnabled = true; camera.mapSize = new Vector2(map.width * map.tileWidth, map.height * map.tileHeight); player.addComponent <FollowCamera>(camera); //Add collision layers here******************************************************************* BoxCollider collider = new BoxCollider(-playerSprite.width / 2, -playerSprite.height / 2, playerSprite.width, playerSprite.height); player.addComponent <TiledMapMover>(new TiledMapMover(map.getLayer <TiledTileLayer>("Ground"))); player.addComponent <BoxCollider>(collider); player.addComponent <PhysicsHandler>(new PhysicsHandler(player, playerController.collisionState, 20f, .5f)); Flags.setFlagExclusive(ref collider.collidesWithLayers, 0); //Prevent collisions with projectiles Flags.setFlagExclusive(ref collider.physicsLayer, 1); this.addEntity <Entity> (player); #endregion #region SpawnAI //Initialize EnemyController EnemyMeleeController enemy = new EnemyMeleeController(map.getLayer <TiledTileLayer>("Ground")); Sprite enemySprite = new Sprite(content.Load <Texture2D>("Temp/TestPlayerAnimationFiles/Idle/Idle_1")); enemySprite.setRenderLayer(1); TiledObject enemySpawn = map.getObjectGroup("SpawnPoint").objectWithName("EnemySpawn"); CookieCutterEntity enemyEntity = new CookieCutterEntity("Enemy", enemySpawn.position, ref enemySprite, enemy); //Add collision layers BoxCollider enemyCollider = new BoxCollider(-enemySprite.width / 2, -enemySprite.height / 2, enemySprite.width, enemySprite.height); enemy.addComponent <TiledMapMover>(new TiledMapMover(map.getLayer <TiledTileLayer>("Ground"))); enemy.addComponent <BoxCollider>(enemyCollider); enemy.addComponent <PhysicsHandler>(new PhysicsHandler(enemyEntity, enemy.collisionState, 20f, .5f)); Flags.setFlagExclusive(ref enemyCollider.collidesWithLayers, 0); //Prevent collisions with projectiles Flags.setFlagExclusive(ref enemyCollider.physicsLayer, 1); //Add target enemy.target = player; this.addEntity <Entity>(enemyEntity); #endregion }
protected bool InitPath() { // If the path isn't currently set, then set it // The path will be set & unset many times over the course of a single chase if (Path == null) { // If the collisions layer hasn't been set yet, set it // We need that to find paths around if (Layer == null) { // First, get the main map Entity Map = Core.scene.findEntity("map"); // If the map doesn't exist, there's nothing to find paths around // Just quit, this should never happen if (Map == null) { return(false); } // Get the map data // We use Tiled in this game TiledMapComponent MapData = Map.getComponent <TiledMapComponent>(); // If there is no map data, then there's no use // Just quit, this should never happen if (MapData == null) { return(false); } // Set the collision layer Layer = MapData.collisionLayer; // If the collision layer is null, there's no use // Just quit, this should never happen if (Layer == null) { return(false); } } // If the graph hasn't been set, set it // The graph is the object that sets the path if (graph == null) { graph = new WeightedGridGraph(Layer); // If graph didn't properly set, there's no use // Just quit, this should never happen if (graph == null) { return(false); } } // Set the path SetPath(); // If the path is somehow still null, it's no use // Just quit, this should never happen if (Path == null) { return(false); } // If the path is more-or-less empty, make it null, then quit // (The first node is usually useless) // This should never happen if (Path.Count < 1) { ChosenPatrolStalkPoint = null; Player = null; Path = null; return(false); } // Set the place on the map we want to go to // We make it a Vector2 as opposed to a Point. It's easier for us to use it that way // We also multiply it by the map's tilesize, as the Point it gives us is coordinates NextPoint = new Vector2((Path[1].X * 8) + 4, (Path[1].Y * 8) - 4); } return(true); }
public override void initialize() { base.initialize(); this.addRenderer(new DefaultRenderer()); SetupPostProcess(); //var deferredRenderer = addRenderer(new DeferredLightingRenderer( // 0, 1, 10, 20)); //deferredRenderer.setAmbientColor(new Color(10, 10, 10)); _enemiesContainer = addEntity(new ContainerEntity { name = "container-enemies" }); EnemyEntity.Container = _enemiesContainer; _bulletContainer = addEntity(new ContainerEntity { name = "container-bullet" }); BulletEntity.Container = _bulletContainer; _itemsContainer = addEntity(new ContainerEntity() { name = "container-items" }); _currentMap = content.Load <TiledMap>(Content.Tilemaps.map1); _mapBoundsGroup = _currentMap.getObjectGroup("MapBounds"); var startPos = _currentMap.getObjectGroup("Points").objectWithName("StartPos"); _mapEnemies = _currentMap.getObjectGroup("Enemies"); _mapItems = _currentMap.getObjectGroup("Upgrades"); Texture2D freePlayerTexture = content.Load <Texture2D>(Content.Textures.tempFlightSprite); Entity map = createEntity("map"); TiledMapComponent tiledMap = map.addComponent(new TiledMapComponent(_currentMap, "Level")); // Vector2 halfMapDimensions = new Vector2(tiledMap.width, tiledMap.height) / 2.0f; // map.setPosition(-halfMapDimensions); tiledMap.setRenderLayer(10); var flyingPlayer = new FreemovePlayerEntity(freePlayerTexture) { name = "player-flying" }; flyingPlayer.addComponent <PositionBoundsLimitComponent>(); this.addEntity(flyingPlayer); EnemyEntity.Player = flyingPlayer; var platformPlayer = new PlatformPlayerEntity(freePlayerTexture) { name = "player-platform" }; platformPlayer.transform.position = new Vector2(startPos.x, startPos.y); this.addEntity(platformPlayer); CameraFollowComponent cameraFollow = new CameraFollowComponent(platformPlayer.transform); camera.addComponent(cameraFollow); PlayerManagerComponent p = addSceneComponent <PlayerManagerComponent>(); p.PlatformPlayer = platformPlayer.getComponent <PlatformPlayerComponent>(); p.FreemovePlayer = flyingPlayer.getComponent <FreemovePlayerComponent>(); p.CameraFollow = cameraFollow; p.OnTogglePlatforming += OnPlatformToggle; p.TogglePlatforming(); //var scanLines = content.loadEffect(@"nez\effects\Invert.mgfxo"); _bulletTextures = new Texture2D[1]; _enemyTextures = new Texture2D[1]; _upgradeTextures = new Texture2D[1]; _bulletTextures[0] = content.Load <Texture2D>(Content.Textures.Enemies.bullet); _enemyTextures[0] = content.Load <Texture2D>(Content.Textures.Enemies.enemy1); _upgradeTextures[0] = content.Load <Texture2D>(Content.Textures.tempFlightSprite); //// EnemyEntity e = new EnemyEntity(enemyTexture, bullet); //e.getComponent<EnemyComponent>().Player = flyingPlayer; //addEntity(e); addEntityProcessor(new UpgradeTriggerProcessor(new Matcher().all(typeof(UpgradeComponent)))); CreateUi(); Time.timeScale = 0.0f; Core.startCoroutine(WaitToStart(0.5f)); ChangeCameraPos(); }
public void Draw(TiledMapComponent map, float layerDepth, MeshBatch batch, Matrix transformMatrix) { if (map.TiledMap.Orientation != TiledMapOrientation.Orthogonal) { throw new NotImplementedException(); } for (var i = 0; i < map.TiledMap.Layers.Count; i++) { if (!map.TiledMap.Layers[i].Visible || (map.LayerIndicesToRender != null && !map.LayerIndicesToRender.Contains(i))) { continue; } var layer = (TiledTileLayer)map.TiledMap.Layers[i]; for (var y = 0; y < layer.Height; y++) { for (var x = 0; x < layer.Width; x++) { var tile = layer.GetTile(x, y); if (tile == null) { continue; } if (tile.TileSet == null || tile.TileSetTile == null || tile.OldId != tile.Id) { tile.OldId = tile.Id; tile.TileSet = map.TiledMap.TileSets.First(a => a.Tiles.Any(b => b.Id + a.FirstGid == tile.Id)); tile.TileSetTile = tile.TileSet.Tiles.First(b => b.Id + tile.TileSet.FirstGid == tile.Id); tile.RenderTileSetTile = tile.TileSetTile; tile.CurrentFrame = 0; tile.ElapsedTime = 0; } // for the y position, we need to take into account if the tile is larger than the tileHeight and shift. Tiled uses // a bottom-left coordinate system and MonoGame a top-left var tx = x * map.TiledMap.TileWidth; var ty = y * map.TiledMap.TileHeight; var rotation = 0f; var spriteEffects = SpriteEffects.None; if (tile.FlippedHorizonally) { spriteEffects |= SpriteEffects.FlipHorizontally; } if (tile.FlippedVertically) { spriteEffects |= SpriteEffects.FlipVertically; } if (tile.FlippedDiagonally) { if (tile.FlippedHorizonally && tile.FlippedVertically) { spriteEffects ^= SpriteEffects.FlipVertically; rotation = MathHelper.PiOver2; tx += map.TiledMap.TileHeight + (tile.RenderTileSetTile.SourceRect.Height - map.TiledMap.TileHeight); ty -= (tile.RenderTileSetTile.SourceRect.Width - map.TiledMap.TileWidth); } else if (tile.FlippedHorizonally) { spriteEffects ^= SpriteEffects.FlipVertically; rotation = -MathHelper.PiOver2; ty += map.TiledMap.TileHeight; } else if (tile.FlippedVertically) { spriteEffects ^= SpriteEffects.FlipHorizontally; rotation = MathHelper.PiOver2; tx += map.TiledMap.TileWidth + (tile.RenderTileSetTile.SourceRect.Height - map.TiledMap.TileHeight); ty += (map.TiledMap.TileWidth - tile.RenderTileSetTile.SourceRect.Width); } else { spriteEffects ^= SpriteEffects.FlipHorizontally; rotation = -MathHelper.PiOver2; ty += map.TiledMap.TileHeight; } } // if we had no rotations (diagonal flipping) shift our y-coord to account for any non-tileSized tiles to account for // Tiled being bottom-left origin if (rotation == 0) { ty += map.TiledMap.TileHeight - tile.RenderTileSetTile.SourceRect.Height; } var destRect = tile.RenderTileSetTile.SourceRect; destRect.Location = new Point(0, 0); var meshItem = batch.Draw(tile.TileSet.ImageTexture, destRect, tile.RenderTileSetTile.SourceRect, Color.White, layerDepth); meshItem.RotateMesh(rotation); meshItem.ApplyEffectToMesh(spriteEffects); meshItem.MoveMesh(new Vector3(tx + layer.Offset.X, ty + layer.Offset.Y, 0)); meshItem.ApplyTransformMesh(transformMatrix); } } } }
public override void onEnabled() { base.onEnabled(); _map = scene.findComponentOfType <TiledMapComponent>(); }