protected override void AddCellsToPlayerShroud(Actor self, Player p, PPos[] uv)
        {
            if (!info.ValidStances.HasStance(p.Stances[self.Owner]))
                return;

            p.Shroud.AddSource(this, Shroud.SourceType.Shroud, uv);
        }

 public Smoke(World world, PPos pos, string trail)
 {
     this.pos = pos;
     anim = new Animation(trail);
     anim.PlayThen("idle",
         () => world.AddFrameEndTask(w => w.Remove(this)));
 }

 public Explosion(World world, PPos pixelPos, string style, bool isWater, int altitude)
 {
     this.pos = pixelPos;
     this.altitude = altitude;
     anim = new Animation("explosion");
     anim.PlayThen(style,
         () => world.AddFrameEndTask(w => w.Remove(this)));
 }

        public Leap(Actor self, Target target)
        {
            this.target = target;
            initialLocation = (PPos) self.Trait<Mobile>().PxPosition;

            self.Trait<RenderInfantry>().Attacking(self, target);
            Sound.Play("dogg5p.aud", self.CenterLocation);
        }

        public IEnumerable<Actor> ActorsInBox(PPos a, PPos b)
        {
            var r = Rectangle.FromLTRB(a.X, a.Y, b.X, b.Y);

            return ActorsInBins(a.X / scale, b.X / scale, a.Y / scale, b.Y / scale)
                .Distinct()
                .Where(u => u.IsInWorld && u.ExtendedBounds.Value.IntersectsWith(r));
        }

        public void ApplyOrders(World world, PPos xy, MouseInput mi)
        {
            if (world.OrderGenerator == null) return;

            var orders = world.OrderGenerator.Order(world, xy.ToCPos(), mi).ToArray();
            orders.Do(o => world.IssueOrder(o));

            world.PlayVoiceForOrders(orders);
        }

 public CashTick(string value, int lifetime, int velocity, PPos pos, Color color)
 {
     this.color = color;
     this.velocity = velocity;
     this.pos = pos;
     s = value;
     font = Game.Renderer.Fonts["TinyBold"];
     offset = 0.5f*font.Measure(s).ToFloat2();
     remaining = lifetime;
 }

        public Parachute(Actor cargo, PPos location, int altitude)
        {
            this.location = location;
            this.altitude = altitude;
            this.cargo = cargo;

            var pai = cargo.Info.Traits.GetOrDefault<ParachuteAttachmentInfo>();
            paraAnim = new Animation(pai != null ? pai.ParachuteSprite : "parach");
            paraAnim.PlayThen("open", () => paraAnim.PlayRepeating("idle"));

            if (pai != null) offset = pai.Offset;

            cargo.Trait<ITeleportable>().SetPxPosition(cargo, location);
        }

        public IEnumerable<Renderable> GenerateRenderables(WorldRenderer wr)
        {
            var bright = SequenceProvider.GetSequence(Info.Image, "bright");
            var dim = SequenceProvider.GetSequence(Info.Image, "dim");

            var src = new PPos(Args.src.X, Args.src.Y - Args.srcAltitude);
            var dest = new PPos(Args.dest.X, Args.dest.Y - Args.destAltitude);
            for (var n = 0; n < Info.DimZaps; n++)
                foreach (var z in DrawZapWandering(wr, src, dest, dim))
                    yield return z;
            for (var n = 0; n < Info.BrightZaps; n++)
                foreach (var z in DrawZapWandering(wr, src, dest, bright))
                    yield return z;
        }

        public FrozenActor(Actor self, PPos[] footprint, Shroud shroud)
        {
            actor = self;
            this.shroud = shroud;

            // Consider all cells inside the map area (ignoring the current map bounds)
            Footprint = footprint
                .Where(m => shroud.Contains(m))
                .ToArray();

            CenterPosition = self.CenterPosition;
            Bounds = self.Bounds;

            UpdateVisibility();
        }

		public FrozenActor(Actor self, PPos[] footprint, Shroud shroud, bool startsRevealed)
		{
			actor = self;
			this.shroud = shroud;
			NeedRenderables = startsRevealed;
			removeFrozenActors = self.TraitsImplementing<IRemoveFrozenActor>().ToArray();

			// Consider all cells inside the map area (ignoring the current map bounds)
			Footprint = footprint
				.Where(m => shroud.Contains(m))
				.ToArray();

			CenterPosition = self.CenterPosition;
			Bounds = self.Bounds;
			TargetTypes = self.TraitsImplementing<ITargetable>().Where(Exts.IsTraitEnabled).SelectMany(t => t.TargetTypes).ToHashSet();

			UpdateVisibility();
		}

        public static void DoExplosion(Actor attacker, string weapontype, PPos pos, int altitude)
        {
            var args = new ProjectileArgs
            {
                src = pos,
                dest = pos,
                srcAltitude = altitude,
                destAltitude = altitude,
                firedBy = attacker,
                target = Target.FromPos(pos),
                weapon = Rules.Weapons[ weapontype.ToLowerInvariant() ],
                facing = 0
            };

            if (args.weapon.Report != null)
                Sound.Play(args.weapon.Report + ".aud", pos);

            DoImpacts(args);
        }

        public IEnumerable<Renderable> Render(WorldRenderer wr)
        {
            if (explosion != null)
                yield return new Renderable(explosion.Image, args.dest.ToFloat2() - .5f * explosion.Image.size,
                                            wr.Palette("effect"), (int)args.dest.Y);

            if (ticks >= info.BeamDuration)
                yield break;

            var rc = Color.FromArgb((info.BeamDuration - ticks)*255/info.BeamDuration, color);

            var src = new PPos(args.src.X, args.src.Y - args.srcAltitude);
            var dest = new PPos(args.dest.X, args.dest.Y - args.destAltitude);
            var wlr = Game.Renderer.WorldLineRenderer;
            wlr.LineWidth = info.BeamRadius * 2;
            wlr.DrawLine(src.ToFloat2(), dest.ToFloat2(), rc, rc);
            wlr.Flush();
            wlr.LineWidth = 1f;
        }

		public void AddProjectedVisibility(Actor a, PPos[] visible)
		{
			if (!a.Owner.IsAlliedWith(self.Owner))
				return;

			foreach (var puv in visible)
			{
				// Force cells outside the visible bounds invisible
				if (!map.Contains(puv))
					continue;

				var uv = (MPos)puv;
				visibleCount[uv]++;
				explored[uv] = true;
			}

			if (visibility.ContainsKey(a))
				throw new InvalidOperationException("Attempting to add duplicate actor visibility");

			visibility[a] = visible;
			Invalidate(visible);
		}

        public Parachute(Player owner, PPos location, int altitude, Actor cargo)
        {
            this.location = location;
            this.altitude = altitude;
            this.cargo = cargo;

            var rs = cargo.Trait<RenderSimple>();
            var image = rs.anim.Name;
            palette = rs.Palette(owner);

            anim = new Animation(image);
            if (anim.HasSequence("idle"))
                anim.PlayFetchIndex("idle", () => 0);
            else
                anim.PlayFetchIndex("stand", () => 0);
            anim.Tick();

            var pai = cargo.Info.Traits.GetOrDefault<ParachuteAttachmentInfo>();

            paraAnim = new Animation(pai != null ? pai.ParachuteSprite : "parach");
            paraAnim.PlayThen("open", () => paraAnim.PlayRepeating("idle"));

            if (pai != null) offset = pai.Offset;
        }

 public static IEnumerable<Actor> FindAliveNonCombatantActorsInCircle(this World world, PPos location, int range)
 {
     return world.FindUnitsInCircle(location, Game.CellSize * range)
         .Where(u => u.IsInWorld && u != world.WorldActor && !u.IsDead() && u.Owner.NonCombatant);
 }

 Fly(PPos px)
 {
     Pos = px;
 }

 public static IEnumerable<Actor> ClosestPlayerUnits(World world, Player player, PPos location, int range)
 {
     return world.FindAliveCombatantActorsInCircle(location, range)
         .Where(a => a.Owner == player && a.HasTrait<IMove>())
         .OrderBy(a => (location - a.CenterLocation).LengthSquared);
 }

 public static IEnumerable<Actor> FindAliveCombatantActorsInBox(this World world, PPos a, PPos b)
 {
     return world.FindUnits(a, b).Where(u => u.IsInWorld && u != world.WorldActor && !u.IsDead() && !u.Owner.NonCombatant);
 }

 public static bool AreaSecuredWithUnits(World world, Player player, PPos location, int range)
 {
     var units = world.FindAliveCombatantActorsInCircle(location, range).Where(a => a.HasTrait<IMove>());
     return units.Any() && units.All(a => a.Owner == player);
 }