Esempio n. 1
0
        public CPos ViewToWorld(int2 view)
        {
            var world      = worldRenderer.Viewport.ViewToWorldPx(view);
            var map        = worldRenderer.World.Map;
            var ts         = Game.ModData.Manifest.TileSize;
            var candidates = CandidateMouseoverCells(world);
            var tileSet    = worldRenderer.World.TileSet;

            foreach (var uv in candidates)
            {
                // Coarse filter to nearby cells
                var p = map.CenterOfCell(uv.ToCPos(map.TileShape));
                var s = worldRenderer.ScreenPxPosition(p);
                if (Math.Abs(s.X - world.X) <= ts.Width && Math.Abs(s.Y - world.Y) <= ts.Height)
                {
                    var ramp = 0;
                    if (map.Contains(uv))
                    {
                        var tile = map.MapTiles.Value[uv];
                        var ti   = tileSet.GetTileInfo(tile);
                        if (ti != null)
                        {
                            ramp = ti.RampType;
                        }
                    }

                    var corners = map.CellCorners[ramp];
                    var pos     = map.CenterOfCell(uv.ToCPos(map));
                    var screen  = corners.Select(c => worldRenderer.ScreenPxPosition(pos + c)).ToArray();

                    if (screen.PolygonContains(world))
                    {
                        return(uv.ToCPos(map));
                    }
                }
            }

            // Mouse is not directly over a cell (perhaps on a cliff)
            // Try and find the closest cell
            if (candidates.Any())
            {
                return(candidates.OrderBy(uv =>
                {
                    var p = map.CenterOfCell(uv.ToCPos(map.TileShape));
                    var s = worldRenderer.ScreenPxPosition(p);
                    var dx = Math.Abs(s.X - world.X);
                    var dy = Math.Abs(s.Y - world.Y);

                    return dx * dx + dy * dy;
                }).First().ToCPos(map));
            }

            // Something is very wrong, but lets return something that isn't completely bogus and hope the caller can recover
            return(worldRenderer.World.Map.CellContaining(worldRenderer.ProjectedPosition(ViewToWorldPx(view))));
        }
Esempio n. 2
0
		public IEnumerable<IRenderable> Render(Actor self, WorldRenderer wr)
		{
			var pos = wr.ScreenPxPosition(self.CenterPosition);
			var bounds = self.Bounds;
			bounds.Offset(pos.X, pos.Y);
			var spaceBuffer = (int)(10 / wr.Viewport.Zoom);
			var effectPos = wr.ProjectedPosition(new int2(pos.X, bounds.Y - spaceBuffer));

			yield return new TextRenderable(font, effectPos, 0, color, name);
		}
Esempio n. 3
0
        public CPos ViewToWorld(int2 view)
        {
            var world      = worldRenderer.Viewport.ViewToWorldPx(view);
            var map        = worldRenderer.World.Map;
            var candidates = CandidateMouseoverCells(world).ToList();

            foreach (var uv in candidates)
            {
                // Coarse filter to nearby cells
                var p = map.CenterOfCell(uv.ToCPos(map.Grid.Type));
                var s = worldRenderer.ScreenPxPosition(p);
                if (Math.Abs(s.X - world.X) <= tileSize.Width && Math.Abs(s.Y - world.Y) <= tileSize.Height)
                {
                    var ramp   = map.Grid.Ramps[map.Ramp.Contains(uv) ? map.Ramp[uv] : 0];
                    var pos    = map.CenterOfCell(uv.ToCPos(map)) - new WVec(0, 0, ramp.CenterHeightOffset);
                    var screen = ramp.Corners.Select(c => worldRenderer.ScreenPxPosition(pos + c)).ToArray();
                    if (screen.PolygonContains(world))
                    {
                        return(uv.ToCPos(map));
                    }
                }
            }

            // Mouse is not directly over a cell (perhaps on a cliff)
            // Try and find the closest cell
            if (candidates.Count > 0)
            {
                return(candidates.MinBy(uv =>
                {
                    var p = map.CenterOfCell(uv.ToCPos(map.Grid.Type));
                    var s = worldRenderer.ScreenPxPosition(p);
                    var dx = Math.Abs(s.X - world.X);
                    var dy = Math.Abs(s.Y - world.Y);

                    return dx * dx + dy * dy;
                }).ToCPos(map));
            }

            // Something is very wrong, but lets return something that isn't completely bogus and hope the caller can recover
            return(worldRenderer.World.Map.CellContaining(worldRenderer.ProjectedPosition(ViewToWorldPx(view))));
        }
Esempio n. 4
0
		static IEnumerable<IFinalizedRenderable> DrawZap(WorldRenderer wr, float2 from, float2 to, ISpriteSequence s, out float2 p, string palette)
		{
			var dist = to - from;
			var q = new float2(-dist.Y, dist.X);
			var c = -float2.Dot(from, q);
			var rs = new List<IFinalizedRenderable>();
			var z = from;
			var pal = wr.Palette(palette);

			while ((to - z).X > 5 || (to - z).X < -5 || (to - z).Y > 5 || (to - z).Y < -5)
			{
				var step = steps.Where(t => (to - (z + new float2(t[0], t[1]))).LengthSquared < (to - z).LengthSquared)
					.MinBy(t => Math.Abs(float2.Dot(z + new float2(t[0], t[1]), q) + c));

				var pos = wr.ProjectedPosition((z + new float2(step[2], step[3])).ToInt2());
				rs.Add(new SpriteRenderable(s.GetSprite(step[4]), pos, WVec.Zero, 0, pal, 1f, true).PrepareRender(wr));

				z += new float2(step[0], step[1]);
				if (rs.Count >= 1000)
					break;
			}

			p = z;

			return rs;
		}