IEnumerable<Order> InnerOrder(World world, CPos xy, MouseInput mi)
		{
			if (world.Paused)
				yield break;

			if (mi.Button == MouseButton.Left)
			{
				var topLeft = xy - FootprintUtils.AdjustForBuildingSize(BuildingInfo);
				if (!world.CanPlaceBuilding(Building, BuildingInfo, topLeft, null)
					|| !BuildingInfo.IsCloseEnoughToBase(world, Producer.Owner, Building, topLeft))
				{
					Sound.PlayNotification(world.Map.Rules, Producer.Owner, "Speech", "BuildingCannotPlaceAudio", Producer.Owner.Country.Race);
					yield break;
				}

				var isLineBuild = world.Map.Rules.Actors[Building].Traits.Contains<LineBuildInfo>();
				yield return new Order(isLineBuild ? "LineBuild" : "PlaceBuilding", Producer.Owner.PlayerActor, false)
				{
					TargetLocation = topLeft,
					TargetActor = Producer,
					TargetString = Building,
					SuppressVisualFeedback = true
				};
			}
		}

        public Order IssueOrder(Actor self, int2 xy, MouseInput mi, Actor underCursor)
        {
            if (underCursor != null && underCursor.HasTrait<RenderInfantry>())
                return new Order("Disguise", self, underCursor);

            return null;
        }

        public IEnumerable<Order> Order(World world, int2 xy, MouseInput mi)
        {
            if (mi.Button == MouseButton.Right)
                world.CancelInputMode();

            return OrderInner(world, xy, mi);
        }

		public bool HandleMouseInput(MouseInput mi)
		{
			// Exclusively uses left and right mouse buttons, but nothing else
			if (mi.Button != MouseButton.Left && mi.Button != MouseButton.Right)
				return false;

			if (mi.Button == MouseButton.Right)
			{
				if (mi.Event == MouseInputEvent.Up)
				{
					editorWidget.ClearBrush();
					return true;
				}

				return false;
			}

			var cell = worldRenderer.Viewport.ViewToWorld(mi.Location);

			if (mi.Button == MouseButton.Left && AllowResourceAt(cell))
			{
				var type = (byte)ResourceType.ResourceType;
				var index = (byte)ResourceType.MaxDensity;
				world.Map.MapResources.Value[cell] = new ResourceTile(type, index);
			}

			return true;
		}

        public IEnumerable<Order> Order(World world, int2 xy, MouseInput mi)
        {
            if (mi.Button == MouseButton.Right)
                Game.controller.CancelInputMode();

            return InnerOrder(world, xy, mi);
        }

 static IEnumerable<Actor> FriendlyGuardableUnits(World world, MouseInput mi)
 {
     return world.ScreenMap.ActorsAt(mi)
         .Where(a => !world.FogObscures(a) && !a.IsDead &&
             a.AppearsFriendlyTo(world.LocalPlayer.PlayerActor) &&
             a.Info.HasTraitInfo<GuardableInfo>());
 }

		private void WriteInputStats(ref FormattedText target, MouseInput input)
		{
			// Initialize the formatted text block we'll write to
			this.PrepareFormattedText(ref target);

			// Determine all pressed mouse buttons
			string activeButtons = "";
			foreach (MouseButton button in Enum.GetValues(typeof(MouseButton)))
			{
				if (input.ButtonPressed(button))
				{
					if (activeButtons.Length != 0)
						activeButtons += ", ";
					activeButtons += button.ToString();
				}
			}

			// Compose the formatted text to display
			target.SourceText = 
				"/f[1]Mouse Stats/f[0]/n/n" +
				string.Format("Description: /cFF8800FF{0}/cFFFFFFFF/n", input.Description) +
				string.Format("IsAvailable: /cFF8800FF{0}/cFFFFFFFF/n", input.IsAvailable) +
				string.Format("X:     /c44AAFFFF{0,4}/cFFFFFFFF | XSpeed:     /c44AAFFFF{1,4}/cFFFFFFFF/n", input.X, input.XSpeed) +
				string.Format("Y:     /c44AAFFFF{0,4}/cFFFFFFFF | YSpeed:     /c44AAFFFF{1,4}/cFFFFFFFF/n", input.Y, input.YSpeed) +
				string.Format("Wheel: /c44AAFFFF{0,4}/cFFFFFFFF | WheelSpeed: /c44AAFFFF{1,4}/cFFFFFFFF/n", input.WheelPrecise, input.WheelSpeedPrecise) +
				string.Format("Buttons: /c44AAFFFF{0}/cFFFFFFFF/n", activeButtons);
		}

        public IEnumerable<Order> Order( World world, int2 xy, MouseInput mi )
        {
            var underCursor = world.FindUnitsAtMouse(mi.Location)
                .Where(a => a.HasTrait<ITargetable>())
                .OrderByDescending(
                    a =>
                    a.Info.Traits.Contains<SelectableInfo>()
                        ? a.Info.Traits.Get<SelectableInfo>().Priority
                        : int.MinValue)
                .FirstOrDefault();

            var orders = world.Selection.Actors
                .Select(a => OrderForUnit(a, xy, mi, underCursor))
                .Where(o => o != null)
                .ToArray();

            var actorsInvolved = orders.Select(o => o.self).Distinct();
            if (actorsInvolved.Any())
                yield return new Order("CreateGroup", actorsInvolved.First().Owner.PlayerActor, false)
                {
                    TargetString = string.Join(",", actorsInvolved.Select(a => a.ActorID.ToString()).ToArray())
                };

            foreach (var o in orders)
                yield return CheckSameOrder(o.iot, o.trait.IssueOrder(o.self, o.iot, o.target, mi.Modifiers.HasModifier(Modifiers.Shift)));
        }

        // Used for classic mouse orders, determines whether or not action at xy is move or select
        public virtual bool InputOverridesSelection(World world, int2 xy, MouseInput mi)
        {
            var actor = world.ScreenMap.ActorsAt(xy).WithHighestSelectionPriority(xy);
            if (actor == null)
                return true;

            var target = Target.FromActor(actor);
            var cell = world.Map.CellContaining(target.CenterPosition);
            var actorsAt = world.ActorMap.GetActorsAt(cell).ToList();
            var underCursor = world.Selection.Actors.WithHighestSelectionPriority(xy);

            var o = OrderForUnit(underCursor, target, actorsAt, cell, mi);
            if (o != null)
            {
                var modifiers = TargetModifiers.None;
                if (mi.Modifiers.HasModifier(Modifiers.Ctrl))
                    modifiers |= TargetModifiers.ForceAttack;
                if (mi.Modifiers.HasModifier(Modifiers.Shift))
                    modifiers |= TargetModifiers.ForceQueue;
                if (mi.Modifiers.HasModifier(Modifiers.Alt))
                    modifiers |= TargetModifiers.ForceMove;

                if (o.Order.TargetOverridesSelection(modifiers))
                    return true;
            }

            return false;
        }

        public IEnumerable<Order> Order(World world, CPos xy, MouseInput mi)
        {
            var underCursor = world.ScreenMap.ActorsAt(mi)
                .Where(a => !world.FogObscures(a) && a.HasTrait<ITargetable>())
                .WithHighestSelectionPriority();

            Target target;
            if (underCursor != null)
                target = Target.FromActor(underCursor);
            else
            {
                var frozen = world.ScreenMap.FrozenActorsAt(world.RenderPlayer, mi)
                    .Where(a => a.Info.Traits.Contains<ITargetableInfo>() && !a.Footprint.All(world.ShroudObscures))
                    .WithHighestSelectionPriority();
                target = frozen != null ? Target.FromFrozenActor(frozen) : Target.FromCell(world, xy);
            }

            var orders = world.Selection.Actors
                .Select(a => OrderForUnit(a, target, mi))
                .Where(o => o != null)
                .ToList();

            var actorsInvolved = orders.Select(o => o.Actor).Distinct();
            if (actorsInvolved.Any())
                yield return new Order("CreateGroup", actorsInvolved.First().Owner.PlayerActor, false)
                {
                    TargetString = actorsInvolved.Select(a => a.ActorID).JoinWith(",")
                };

            foreach (var o in orders)
                yield return CheckSameOrder(o.Order, o.Trait.IssueOrder(o.Actor, o.Order, o.Target, mi.Modifiers.HasModifier(Modifiers.Shift)));
        }

        public string GetCursor(World world, CPos xy, MouseInput mi)
        {
            var useSelect = false;
            var underCursor = world.ScreenMap.ActorsAt(mi)
                .Where(a => !world.FogObscures(a) && a.HasTrait<ITargetable>())
                .OrderByDescending(a => a.Info.SelectionPriority())
                .FirstOrDefault();

            if (underCursor != null && (mi.Modifiers.HasModifier(Modifiers.Shift) || !world.Selection.Actors.Any()))
            {
                var selectable = underCursor.TraitOrDefault<Selectable>();
                if (selectable != null && selectable.Info.Selectable)
                    useSelect = true;
            }

            Target target;
            if (underCursor != null)
                target = Target.FromActor(underCursor);
            else
            {
                var frozen = world.ScreenMap.FrozenActorsAt(world.RenderPlayer, mi)
                    .Where(a => a.Info.Traits.Contains<ITargetableInfo>())
                    .OrderByDescending(a => a.Info.SelectionPriority())
                    .FirstOrDefault();
                target = frozen != null ? Target.FromFrozenActor(frozen) : Target.FromCell(xy);
            }

            var orders = world.Selection.Actors
                .Select(a => OrderForUnit(a, target, mi))
                .Where(o => o != null)
                .ToArray();

            var cursorName = orders.Select(o => o.Cursor).FirstOrDefault();
            return cursorName ?? (useSelect ? "select" : "default");
        }

    public GameClass(bool startFullScreen, Size size, bool enableNetwork)
    {
        this.startFullscreen = startFullScreen;
        this.Size = size;
        this.networkEnabled = enableNetwork;
        this.Text = "SpaceWar3D-Step12";
        statusMessageTimer = Constants.StatusMessageDisplayTime;

        drawingFont = new GraphicsFont( "Verdana", System.Drawing.FontStyle.Regular);

        input = new InputClass(this);
        mouseInput = new MouseInput(this);
        this.MouseMove +=new MouseEventHandler(GameClass_MouseMove);
        this.Cursor = Cursors.NoMove2D;

        camera = new Camera();
        soundHandler = new SoundHandler(this);

        if (networkEnabled) {
            peer = new PlayClass(this);
            if (peer.IsHost) {
                hullColor = HullColors.Red;
            }
        }
    }

        static IEnumerable<Order> OrderInner(World world, MouseInput mi)
        {
            if (mi.Button != MouseButton.Left)
                yield break;

            var underCursor = world.ScreenMap.ActorsAt(mi)
                .FirstOrDefault(a => a.AppearsFriendlyTo(world.LocalPlayer.PlayerActor) && !world.FogObscures(a));

            if (underCursor == null)
                yield break;

            if (underCursor.GetDamageState() == DamageState.Undamaged)
                yield break;

            // Repair a building.
            if (underCursor.Info.HasTraitInfo<RepairableBuildingInfo>())
                yield return new Order("RepairBuilding", world.LocalPlayer.PlayerActor, false) { TargetActor = underCursor };

            // Don't command allied units
            if (underCursor.Owner != world.LocalPlayer)
                yield break;

            // Test for generic Repairable (used on units).
            var repairable = underCursor.TraitOrDefault<Repairable>();
            if (repairable == null)
                yield break;

            // Find a building to repair at.
            var repairBuilding = repairable.FindRepairBuilding(underCursor);
            if (repairBuilding == null)
                yield break;

            yield return new Order("Repair", underCursor, false) { TargetActor = repairBuilding };
        }

        public Order IssueOrder(Actor self, int2 xy, MouseInput mi, Actor underCursor)
        {
            if (mi.Button == MouseButton.Right && xy == self.Location && chargeTick <= 0)
                return new Order("Deploy", self);

            return null;
        }

        public override bool OnMouseUp(Widget w, MouseInput mi)
        {
            if (w.Id == "MAINMENU_BUTTON_CREATE")
            {
                Game.chrome.rootWidget.ShowMenu("CREATESERVER_BG");
                return true;
            }

            if (w.Id == "CREATESERVER_BUTTON_CANCEL")
            {
                Game.chrome.rootWidget.ShowMenu("MAINMENU_BG");
                return true;
            }

            if (w.Id == "CREATESERVER_BUTTON_START")
            {
                Game.chrome.rootWidget.ShowMenu(null);
                Log.Write("Creating server");

                Server.Server.ServerMain(AdvertiseServerOnline, Game.Settings.MasterServer,
                                        Game.Settings.GameName, Game.Settings.ListenPort,
                                        Game.Settings.ExternalPort, Game.Settings.InitialMods);

                Log.Write("Joining server");
                Game.JoinServer(IPAddress.Loopback.ToString(), Game.Settings.ListenPort);
                return true;
            }

            return false;
        }

 public override bool HandleMouseInput(MouseInput mi)
 {
     if (ClickThrough) return false;
     if (!Draggable || moving && (!TakeFocus(mi) || mi.Button != MouseButton.Left)) return true;
     if (prevMouseLocation == null)
         prevMouseLocation = mi.Location;
     var vec = mi.Location - (int2)prevMouseLocation;
     prevMouseLocation = mi.Location;
     switch (mi.Event)
     {
         case MouseInputEvent.Up:
             moving = false;
             LoseFocus(mi);
             break;
         case MouseInputEvent.Down:
             moving = true;
             Bounds = new Rectangle(Bounds.X + vec.X, Bounds.Y + vec.Y, Bounds.Width, Bounds.Height);
             break;
         case MouseInputEvent.Move:
             if (moving)
                 Bounds = new Rectangle(Bounds.X + vec.X, Bounds.Y + vec.Y, Bounds.Width, Bounds.Height);
             break;
     }
     return true;
 }

		public override bool HandleMouseInput(MouseInput mi)
		{
			if (CurrentBrush.HandleMouseInput(mi))
				return true;

			return base.HandleMouseInput(mi);
		}

        public string GetCursor( World world, int2 xy, MouseInput mi )
        {
            bool useSelect = false;

            var custom = world.WorldActor.TraitOrDefault<ICustomUnitOrderGenerator>();
            if (custom != null)
            {
               return custom.GetCursor(world, xy, mi);
            }

            var underCursor = world.FindUnitsAtMouse(mi.Location)
                .Where(a => a.HasTrait<ITargetable>())
                .OrderByDescending(a => a.Info.Traits.Contains<SelectableInfo>() ? a.Info.Traits.Get<SelectableInfo>().Priority : int.MinValue)
                .FirstOrDefault();

            if (mi.Modifiers.HasModifier(Modifiers.Shift) || !world.Selection.Actors.Any())
                if (underCursor != null)
                    useSelect = true;

            var orders = world.Selection.Actors
                .Select(a => OrderForUnit(a, xy, mi, underCursor))
                .Where(o => o != null)
                .ToArray();

            if( orders.Length == 0 ) return (useSelect) ? "select" : "default";

            return orders[0].cursor ?? ((useSelect) ? "select" : "default");
        }

		public override bool HandleMouseInput(MouseInput mi)
		{
			if (mi.Button != MouseButton.Left) return false;
			if (IsDisabled()) return false;
			if (mi.Event == MouseInputEvent.Down && !TakeFocus(mi))	return false;
			if (!Focused) return false;

			switch( mi.Event )
			{
			case MouseInputEvent.Up:
				isMoving = false;
				LoseFocus(mi);
				break;

			case MouseInputEvent.Down:
				isMoving = true;
				/* todo: handle snapping to ticks properly again */
				/* todo: handle nudge via clicking outside the thumb */
				UpdateValue(ValueFromPx(mi.Location.X - RenderBounds.Left));
				break;

			case MouseInputEvent.Move:
				if (isMoving)
					UpdateValue(ValueFromPx(mi.Location.X - RenderBounds.Left));
				break;
			}

			return ThumbRect.Contains(mi.Location);
		}

        public override bool OnMouseDown(Widget w, MouseInput mi)
        {
            if (w.Id == "SETTINGS_CHECKBOX_UNITDEBUG")
            {
                Game.Settings.UnitDebug = !Game.Settings.UnitDebug;
                return true;
            }

            if (w.Id == "SETTINGS_CHECKBOX_PATHDEBUG")
            {
                Game.Settings.PathDebug = !Game.Settings.PathDebug;
                return true;
            }

            if (w.Id == "SETTINGS_CHECKBOX_INDEXDEBUG")
            {
                Game.Settings.IndexDebug = !Game.Settings.IndexDebug;
                return true;
            }

            if (w.Id == "SETTINGS_CHECKBOX_PERFGRAPH")
            {
                Game.Settings.PerfGraph = !Game.Settings.PerfGraph;
                return true;
            }

            if (w.Id == "SETTINGS_CHECKBOX_PERFTEXT")
            {
                Game.Settings.PerfText = !Game.Settings.PerfText;
                return true;
            }

            return false;
        }