public Order IssueOrder( Actor self, IOrderTargeter order, Target target, bool queued )
        {
            if( order.OrderID == "SetRallyPoint" )
                return new Order(order.OrderID, self, false) { TargetLocation = target.CenterPosition.ToCPos() };

            return null;
        }

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

            return null;
        }

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

            return null;
        }

		public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued)
		{
			if (order.OrderID == "SetRallyPoint")
				return new Order(order.OrderID, self, false) { TargetLocation = self.World.Map.CellContaining(target.CenterPosition), SuppressVisualFeedback = true };

			return null;
		}

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

            return null;
        }

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

            return null;
        }

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

			return null;
		}

        public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued)
        {
            if (order.OrderID == "ChronoshiftJump" && chargeTick <= 0)
                self.World.OrderGenerator = new ChronoTankOrderGenerator(self);

            return new Order("ChronoshiftJump", self, false); // Hack until we can return null
        }

        public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued)
        {
            if (!(order is BeginMinefieldOrderTargeter))
                return null;

            var start = target.CenterPosition.ToCPos();
            self.World.OrderGenerator = new MinefieldOrderGenerator(self, start);
            return new Order("BeginMinefield", self, false) { TargetLocation = start };
        }

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

            if( order.OrderID == "Move" )
                return new Order( order.OrderID, self, Util.CellContaining( target.CenterLocation ) );

            return null;
        }

        public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued)
        {
            if (order.OrderID == "PortableChronoDeploy" && CanTeleport)
                self.World.OrderGenerator = new PortableChronoOrderGenerator(self, Info);

            if (order.OrderID == "PortableChronoTeleport")
                return new Order(order.OrderID, self, queued) { TargetLocation = self.World.Map.CellContaining(target.CenterPosition) };

            return new Order(order.OrderID, self, queued) { TargetActor = target.Actor };
        }

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

            if( order.OrderID == "Move" )
                return new Order(order.OrderID, self, queued) { TargetLocation = Util.CellContaining(target.CenterLocation) };

            return null;
        }

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

			if (target.Type == TargetType.FrozenActor)
				return new Order(order.OrderID, self, queued) { ExtraData = target.FrozenActor.ID };

			return new Order(order.OrderID, self, queued) { TargetActor = target.Actor };
		}

 public Order IssueOrder( Actor self, IOrderTargeter order, Target target, bool queued )
 {
     if( order is BeginMinefieldOrderTargeter )
     {
         var start = Traits.Util.CellContaining( target.CenterLocation );
         self.World.OrderGenerator = new MinefieldOrderGenerator( self, start );
         return new Order("BeginMinefield", self, false) { TargetLocation = start };
     }
     return null;
 }

 public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued)
 {
     switch (order.OrderID)
     {
         case "BeginMinefield":
             var start = self.World.Map.CellContaining(target.CenterPosition);
             self.World.OrderGenerator = new MinefieldOrderGenerator(self, start);
             return new Order("BeginMinefield", self, false) { TargetLocation = start };
         case "PlaceMine":
             return new Order("PlaceMine", self, false) { TargetLocation = self.Location };
         default:
             return null;
     }
 }

 public Order IssueOrder( Actor self, IOrderTargeter order, Target target )
 {
     if( order is AttackOrderTargeter )
     {
         if( target.IsActor )
             return new Order( IsHeal ? "Heal" : "Attack", self, target.Actor );
         else
             return new Order( IsHeal ? "Heal" : "Attack", self, Util.CellContaining( target.CenterLocation ) );
     }
     return null;
 }

 // Note: Returns a valid order even if the unit can't move to the target
 public Order IssueOrder( Actor self, IOrderTargeter order, Target target )
 {
     if( order is MoveOrderTargeter )
     {
         if( Info.OnRails ) return null;
         return new Order( "Move", self, Util.CellContaining( target.CenterLocation ), false );
     }
     return null;
 }

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

            if (order.OrderID == "Harvest")
                return new Order(order.OrderID, self, queued) { TargetLocation = self.World.Map.CellContaining(target.CenterPosition) };

            return null;
        }

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

            if (order.OrderID == "Harvest")
                return new Order(order.OrderID, self, queued) { TargetLocation = target.CenterLocation.ToCPos() };

            return null;
        }

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

            if( order.OrderID == "ReverseEnterTransport" )
                return new Order( order.OrderID, self, target.Actor );

            return null;
        }