public override void DoImpact(Target target, Actor firedBy, IEnumerable<int> damageModifiers)
        {
            if (!target.IsValidFor(firedBy))
                return;

            var pos = target.CenterPosition;
            var world = firedBy.World;
            var targetTile = world.Map.CellContaining(pos);
            var isValid = IsValidImpact(pos, firedBy);

            if ((!world.Map.Contains(targetTile)) || (!isValid))
                return;

            var palette = ExplosionPalette;
            if (UsePlayerPalette)
                palette += firedBy.Owner.InternalName;

            var explosion = Explosions.RandomOrDefault(Game.CosmeticRandom);
            if (Image != null && explosion != null)
                world.AddFrameEndTask(w => w.Add(new SpriteEffect(pos, w, Image, explosion, palette)));

            var impactSound = ImpactSounds.RandomOrDefault(Game.CosmeticRandom);
            if (impactSound != null)
                Game.Sound.Play(impactSound, pos);
        }

		public override void Activate(Actor self, Order order, SupportPowerManager manager)
		{
			base.Activate(self, order, manager);

			var wsb = self.TraitOrDefault<WithSpriteBody>();
			if (wsb != null && wsb.DefaultAnimation.HasSequence(info.GrantUpgradeSequence))
				wsb.PlayCustomAnimation(self, info.GrantUpgradeSequence);

			Game.Sound.Play(info.GrantUpgradeSound, self.World.Map.CenterOfCell(order.TargetLocation));

			foreach (var a in UnitsInRange(order.TargetLocation))
			{
				var um = a.TraitOrDefault<UpgradeManager>();
				if (um == null)
					continue;

				foreach (var u in info.Upgrades)
				{
					if (info.Duration > 0)
					{
						if (um.AcknowledgesUpgrade(a, u))
							um.GrantTimedUpgrade(a, u, info.Duration);
					}
					else
					{
						if (um.AcceptsUpgrade(a, u))
							um.GrantUpgrade(a, u, this);
					}
				}
			}
		}

        public int DrawCostume(VirtScreen vs, int numStrips, Actor actor, bool drawToBackBuf)
        {
            var pixelsNavigator = new PixelNavigator(vs.Surfaces[drawToBackBuf ? 1 : 0]);
            pixelsNavigator.OffsetX(vs.XStart);

            ActorX += (vs.XStart & 7);
            _w = vs.Width;
            _h = vs.Height;
            pixelsNavigator.OffsetX(-(vs.XStart & 7));
            startNav = new PixelNavigator(pixelsNavigator);

            if (_vm.Game.Version <= 1)
            {
                _xmove = 0;
                _ymove = 0;
            }
            else if (_vm.Game.IsOldBundle)
            {
                _xmove = -72;
                _ymove = -100;
            }
            else
            {
                _xmove = _ymove = 0;
            }

            int result = 0;
            for (int i = 0; i < 16; i++)
                result |= DrawLimb(actor, i);
            return result;
        }

        public override void Activate(Actor self, Order order)
        {
            // TODO: Reveal submarines

            // Should this play for all players?
            Sound.Play("sonpulse.aud");
        }

 public UnloadCargo(Actor self, bool unloadAll)
 {
     this.self = self;
     cargo = self.Trait<Cargo>();
     cloak = self.TraitOrDefault<Cloak>();
     this.unloadAll = unloadAll;
 }

        public override void Activate(Actor collector)
        {
            var actorsInRange = self.World.FindActorsInCircle(self.CenterPosition, info.Range)
                .Where(a => a != self && a != collector && a.Owner == collector.Owner && AcceptsUpgrade(a));

            if (info.MaxExtraCollectors > -1)
                actorsInRange = actorsInRange.Take(info.MaxExtraCollectors);

            collector.World.AddFrameEndTask(w =>
            {
                foreach (var a in actorsInRange.Append(collector))
                {
                    if (!a.IsInWorld || a.IsDead)
                        continue;

                    var um = a.TraitOrDefault<UpgradeManager>();
                    foreach (var u in info.Upgrades)
                    {
                        if (info.Duration > 0)
                        {
                            if (um.AcknowledgesUpgrade(a, u))
                                um.GrantTimedUpgrade(a, u, info.Duration);
                        }
                        else
                        {
                            if (um.AcceptsUpgrade(a, u))
                                um.GrantUpgrade(a, u, this);
                        }
                    }
                }
            });

            base.Activate(collector);
        }

 public ShroudPalette(Actor self, ShroudPaletteInfo info)
 {
     // TODO: This shouldn't rely on a base palette
         var wr = self.World.WorldRenderer;
         var pal = wr.GetPalette("terrain");
         wr.AddPalette(info.Name, new Palette(pal, new ShroudPaletteRemap(info.IsFog)));
 }

 public FallToEarth(Actor self, FallsToEarthInfo info)
 {
     this.info = info;
     aircraft = self.Trait<Aircraft>();
     if (info.Spins)
         acceleration = self.World.SharedRandom.Next(2) * 2 - 1;
 }

        public override Activity Tick(Actor self)
        {
            if (self.World.Map.DistanceAboveTerrain(self.CenterPosition).Length <= 0)
            {
                if (info.ExplosionWeapon != null)
                {
                    // Use .FromPos since this actor is killed. Cannot use Target.FromActor
                    info.ExplosionWeapon.Impact(Target.FromPos(self.CenterPosition), self, Enumerable.Empty<int>());
                }

                self.Dispose();
                return null;
            }

            if (info.Spins)
            {
                spin += acceleration;
                aircraft.Facing = (aircraft.Facing + spin) % 256;
            }

            var move = info.Moves ? aircraft.FlyStep(aircraft.Facing) : WVec.Zero;
            move -= new WVec(WDist.Zero, WDist.Zero, info.Velocity);
            aircraft.SetPosition(self, aircraft.CenterPosition + move);

            return this;
        }

		public void Tick(Actor self)
		{
			if (!validTileset)
				return;

			t += info.RotationStep;
		}

 public IActivity Tick(Actor self)
 {
     var targetAltitude = self.Info.Traits.Get<PlaneInfo>().CruiseAltitude;
     if (isCanceled || !self.World.Map.IsInMap(self.Location)) return NextActivity;
     FlyUtil.Fly(self, targetAltitude);
     return this;
 }

        public override Activity Tick(Actor self)
        {
            switch (state)
            {
                case State.Wait:
                    return this;
                case State.Turn:
                    state = State.DragIn;
                    return Util.SequenceActivities(new Turn(112), this);
                case State.DragIn:
                    state = State.Dock;
                    return Util.SequenceActivities(new Drag(startDock, endDock, 12), this);
                case State.Dock:
                    ru.PlayCustomAnimation(self, "dock", () => { ru.PlayCustomAnimRepeating(self, "dock-loop"); state = State.Loop; });
                    state = State.Wait;
                    return this;
                case State.Loop:
                    if (!proc.IsInWorld || proc.IsDead() || harv.TickUnload(self, proc))
                        state = State.Undock;
                    return this;
                case State.Undock:
                    ru.PlayCustomAnimBackwards(self, "dock", () => state = State.DragOut);
                    state = State.Wait;
                    return this;
                case State.DragOut:
                    return Util.SequenceActivities(new Drag(endDock, startDock, 12), NextActivity);
            }

            throw new InvalidOperationException("Invalid harvester dock state");
        }

 static Actor ChooseHelipad(Actor self)
 {
     var rearmBuildings = self.Info.Traits.Get<HelicopterInfo>().RearmBuildings;
     return self.World.Actors.Where( a => a.Owner == self.Owner ).FirstOrDefault(
         a => rearmBuildings.Contains(a.Info.Name) &&
             !Reservable.IsReserved(a));
 }

        public void SetUp()
        {
            Location location = new Location (null, new Point (5, 5));

            actor = new MockActor (location);
            item = new MockItem (location);
        }

        public Minelayer(Actor self)
        {
            this.self = self;

            var tileset = self.World.Map.Tileset.ToLowerInvariant();
            tile = self.World.Map.Rules.Sequences.GetSequence("overlay", "build-valid-{0}".F(tileset)).GetSprite(0);
        }

        protected override void OnInside(Actor self)
        {
            self.World.AddFrameEndTask(w =>
            {
                if (target.IsDead)
                    return;

                if (cloak != null && cloak.Info.UncloakOnDemolish)
                    cloak.Uncloak();

                for (var f = 0; f < flashes; f++)
                    w.Add(new DelayedAction(flashesDelay + f * flashInterval, () =>
                        w.Add(new FlashTarget(target, ticks: flashDuration))));

                w.Add(new DelayedAction(delay, () =>
                {
                    if (target.IsDead)
                        return;

                    var modifiers = target.TraitsImplementing<IDamageModifier>()
                        .Concat(self.Owner.PlayerActor.TraitsImplementing<IDamageModifier>())
                        .Select(t => t.GetDamageModifier(self, null));

                    if (Util.ApplyPercentageModifiers(100, modifiers) > 0)
                        demolishables.Do(d => d.Demolish(target, self));
                }));
            });
        }

        public override Activity Tick(Actor self)
        {
            switch (dockingState)
            {
                case State.Wait:
                    return this;
                case State.Turn:
                    dockingState = State.Dock;
                    if (IsDragRequired)
                        return ActivityUtils.SequenceActivities(new Turn(self, DockAngle), new Drag(self, StartDrag, EndDrag, DragLength), this);
                    return ActivityUtils.SequenceActivities(new Turn(self, DockAngle), this);
                case State.Dock:
                    if (Refinery.IsInWorld && !Refinery.IsDead)
                        foreach (var nd in Refinery.TraitsImplementing<INotifyDocking>())
                            nd.Docked(Refinery, self);
                    return OnStateDock(self);
                case State.Loop:
                    if (!Refinery.IsInWorld || Refinery.IsDead || Harv.TickUnload(self, Refinery))
                        dockingState = State.Undock;
                    return this;
                case State.Undock:
                    return OnStateUndock(self);
                case State.Complete:
                    if (Refinery.IsInWorld && !Refinery.IsDead)
                        foreach (var nd in Refinery.TraitsImplementing<INotifyDocking>())
                            nd.Undocked(Refinery, self);
                    Harv.LastLinkedProc = Harv.LinkedProc;
                    Harv.LinkProc(self, null);
                    if (IsDragRequired)
                        return ActivityUtils.SequenceActivities(new Drag(self, EndDrag, StartDrag, DragLength), NextActivity);
                    return NextActivity;
            }

            throw new InvalidOperationException("Invalid harvester dock state");
        }

		public Transforms(ActorInitializer init, TransformsInfo info)
		{
			self = init.self;
			this.info = info;
			bi = self.World.Map.Rules.Actors[info.IntoActor].Traits.GetOrDefault<BuildingInfo>();
			race = init.Contains<RaceInit>() ? init.Get<RaceInit, string>() : self.Owner.Country.Race;
		}

 public UpgradeActorsNear(Actor self, UpgradeActorsNearInfo info)
 {
     this.info = info;
     this.self = self;
     cachedRange = info.Range;
     cachedVRange = info.MaximumVerticalOffset;
 }

		public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued)
		{
			if (order.OrderID == "DeployTransform")
				return new Order(order.OrderID, self, queued);

			return null;
		}