public ControlState controlState;                //get and set the control state
        #endregion

        #region constructor/load
        public TacticalBattle(List<Piece> player1Army, List<Piece> player2Army, TacMap map, ContentManager content)
        {
            //p1Avatar = player1;
            //p2Avatar = player2;

            this.player1Army = player1Army;
            this.player2Army = player2Army;

            isPlayer1Turn = true;
            this.map = map;
            battleOver = false;
            gridOn = false;

            mouseVisible = true;
            controlState = ControlState.selectUnit;

            selectedUnit = null;
            status = "Combat begins";
            selectionTiles = new List<Tile>();
            unitInfo = "";
            //load interface items                  TODO
            confirmation = content.Load<Texture2D>("confirmationPopup");
            background = content.Load<Texture2D>("TerrainSprites/battle");
            statusFont = content.Load<SpriteFont>("Arial");
            playerFont = content.Load<SpriteFont>("playerFont");
            infoFont = content.Load<SpriteFont>("infoFont");
            moveBox = content.Load<Texture2D>("TerrainSprites/move");
            targetBox = content.Load<Texture2D>("TerrainSprites/target");
            selectedBox = content.Load<Texture2D>("TerrainSprites/selected");
            horizontal = content.Load<Texture2D>("TerrainSprites/horizontal");
            vertical = content.Load<Texture2D>("TerrainSprites/vertical");
            winBox = content.Load<Texture2D>("Menu/Win message");
            //set units to starting positions
            startingPositions();
        }

 public void LoadEditor(IProperties imageServiceSettings)
 {
     _loadedState = ControlState.Loading;
     _imageServiceSettings = imageServiceSettings;
     LoadEditor();
     _loadedState = ControlState.Loaded;
 }

    // Update is called once per frame
    void Update()
    {
        switch(controlState){
            case ControlState.DEBUG:
                Vector2 mouse = Input.mousePosition;
                float h = mouse.x / cam.pixelWidth;
                float v = (cam.pixelHeight - mouse.y)/cam.pixelHeight ;

                //Script used for detecting if controller should be used
                transform.rotation = Quaternion.Euler(v * verticalRotationAmount + verticalRotationOffset,h * horizontalRotationAmount + horizontalRotationOffset,0);

            break;
            case ControlState.NVR:
                controllerRotX += (Input.GetAxis("ViewY") * turnSpeed * Time.deltaTime);
                controllerRotY += (Input.GetAxis("ViewX") * turnSpeed * Time.deltaTime);

                controllerRotX = Mathf.Clamp(controllerRotX,-90,90);

                transform.rotation = Quaternion.Euler(controllerRotX,controllerRotY + cartOffsetRotY,0);
            break;
            case ControlState.VR:
                transform.rotation = Quaternion.Euler(0,cartOffsetRotY - 180,0);
            break;
        }

        if(Input.GetKeyDown("c")){
            if((int)++controlState % 3 == 0)
                controlState = ControlState.DEBUG;
                Console.Instance.AddMessage("ControlState: " + controlState);
                Debug.Log("ControlState: " + controlState);
        }
    }

 public void LoadEditor(IImageUploadSettingsEditorContext context)
 {
     _loadedState = ControlState.Loading;
     _context = context;
     LoadEditor();
     _loadedState = ControlState.Loaded;
 }

        public void Update(TimeSpan elapsedTime, ControlState controlState)
        {
            var leftRight = this.helpSteer(controlState).Clamped(-1, 1);

            this.updateMovement(elapsedTime, controlState.Acceleration, leftRight);

            this.update();
        }

 public PaintScrollBarThumbEventArgs(System.Drawing.Graphics graphics, Rectangle thumbRect, ControlState controlState, System.Windows.Forms.Orientation orientation, bool enabled)
 {
     this._graphics = graphics;
     this._thumbRect = thumbRect;
     this._controlState = controlState;
     this._orientation = orientation;
     this._enabled = enabled;
 }

 public PaintScrollBarThumbEventArgs(
     Graphics graphics,
     Rectangle thumbRect,
     ControlState controlState,
     Orientation orientation)
     : this(graphics, thumbRect, controlState, orientation, true)
 {
 }

        public ColorValue[] States; // Modulate colors for all possible control states

        #endregion Fields

        #region Methods

        /// <summary>Blend the colors together</summary>
        public void Blend(ControlState state, float elapsedTime, float rate)
        {
            if ((States == null) || (States.Length == 0) )
                return; // Nothing to do

            ColorValue destColor = States[(int)state];
            Current = ColorOperator.Lerp(Current, destColor, 1.0f - (float)Math.Pow(rate, 30 * elapsedTime) );
        }

 public PaintScrollBarArrowEventArgs(System.Drawing.Graphics graphics, Rectangle arrowRect, ControlState controlState, System.Windows.Forms.ArrowDirection arrowDirection, System.Windows.Forms.Orientation orientation, bool enabled)
 {
     this._graphics = graphics;
     this._arrowRect = arrowRect;
     this._controlState = controlState;
     this._arrowDirection = arrowDirection;
     this._orientation = orientation;
     this._enabled = enabled;
 }

 protected override void OnMouseEnter(EventArgs e)
 {
     if (state != ControlState.Down)
     {
         state = ControlState.Hover; ;
     }
     this.Invalidate();
     base.OnMouseEnter(e);
 }

 public void LoadEditor(ImageDecoratorEditorContext context, object state, IImageTargetEditor imageTargetEditor)
 {
     _loadedState = ControlState.Loading;
     _context = context;
     _state = state;
     _imageTargetEditor = imageTargetEditor;
     LoadEditor();
     _loadedState = ControlState.Loaded;
     OnEditorLoaded();
 }

 public PaintScrollBarArrowEventArgs(
     Graphics graphics,
     Rectangle arrowRect,
     ControlState controlState,
     ArrowDirection arrowDirection,
     Orientation orientation)
     : this(graphics,
     arrowRect,
     controlState,
     arrowDirection,
     orientation,
     true)
 {
 }

        public StateHotspot(ControlState representedState, Rectangle hotspotRect, bool selected, Image activeImage, Image inactiveImage)
        {
            //Setting what state the hotspot represents
            this.representedState = representedState;

            //Setting if it is currently selected
            this.selected = selected;

            //Setting the size and position of the hotspot
            this.hotspotRect = hotspotRect;

            //Setting the images it will use to display if it is active
            this.activeImage = activeImage;
            this.inactiveImage = inactiveImage;
        }

		public void Update ()
		{
			if (stateChanged)
			{
				stateChanged = false;
				return;
			}
			if (_state == ControlState.Starting)
			{
				_state = ControlState.Active;
			}
			if (_state == ControlState.Ending)
			{
				_state = ControlState.Inactive;
			}
		}

 private void SetControlState(ControlState state)
 {
     switch (state)
     {
         case ControlState.TimerStopped:
             this.groupBoxStartTimers.Enabled = true;
             this.groupBoxControls.Enabled = false;
             break;
         case ControlState.TimerRunning:
             this.groupBoxStartTimers.Enabled = false;
             this.groupBoxControls.Enabled = true;
             break;
         default:
             break;
     }
 }

        private float helpSteer(ControlState controlState)
        {
            var leftRight = (
                controlState.LeftRight * 2f
                ).Clamped(-1, 1);

            var rayAngle = Angle.FromRadians(0.7f);
            var rayLength = 2.5.U();

            var vVector = this.Direction.Vector;

            leftRight += this.modifySteering(rayAngle, rayLength, vVector);
            leftRight -= this.modifySteering(-rayAngle, rayLength, vVector);

            return leftRight;
        }

 /// <summary>
 /// 图片按钮的背景图是4个,根据状态获取其中背景图
 /// </summary>
 /// <param name="name">图片名称</param>
 /// <param name="state">状态</param>
 /// <returns></returns>
 public static Bitmap GetResWithState(String name, ControlState state)
 {
     Bitmap bitmap = (Bitmap)GetResAsImage(name);
     if (bitmap == null)
     {
         return null;
     }
     int block = 0;
     switch (state)
     {
         case ControlState.Normal: block = 0; break;
         case ControlState.MouseOver: block = 1; break;
         case ControlState.MouseDown: block = 2; break;
         case ControlState.Disable: block = 3; break;
     }
     int width = bitmap.Width / 4;
     Rectangle rect = new Rectangle(block * width, 0, width, bitmap.Height);
     return bitmap.Clone(rect, bitmap.PixelFormat);
 }

        public XbmcHandler(XbmcJsonRpcConnection xbmc, DisplayHandler display)
        {
            if (xbmc == null)
            {
                throw new ArgumentNullException("xbmc");
            }
            if (display == null)
            {
                throw new ArgumentNullException("display");
            }

            this.xbmc = xbmc;
            this.display = display;

            this.xbmc.Connected                     +=  this.xbmcConnected;
            this.xbmc.Aborted                       +=  this.xbmcAborted;
            this.xbmc.Player.PlaybackStarted        +=  this.xbmcPlaybackStarted;
            this.xbmc.Player.PlaybackPaused         +=  this.xbmcPlaybackPaused;
            this.xbmc.Player.PlaybackResumed        +=  this.xbmcPlaybackResumed;
            this.xbmc.Player.PlaybackStopped        +=  this.xbmcPlaybackStopped;
            this.xbmc.Player.PlaybackEnded          +=  this.xbmcPlaybackEnded;
            this.xbmc.Player.PlaybackSeek           +=  this.xbmcPlaybackSeek;
            this.xbmc.Player.PlaybackSeekChapter    +=  this.xbmcPlaybackSeek;
            this.xbmc.Player.PlaybackSpeedChanged   +=  this.xbmcPlaybackSpeedChanged;

            this.progressTimer = new System.Timers.Timer();
            this.progressTimer.Interval = ProgressUpdateInterval;
            this.progressTimer.Elapsed += progressTimerUpdate;
            this.progressTimer.AutoReset = true;

            this.WorkerReportsProgress = false;
            this.WorkerSupportsCancellation = true;

            this.controlModeState = new ControlState();
            this.controlModeTimer = new System.Timers.Timer();
            this.controlModeTimer.Interval = ControlModeUpdateInterval;
            this.controlModeTimer.Elapsed += controlModeTimerUpdate;
            this.controlModeTimer.AutoReset = true;

            this.semReady = new Semaphore(0, 1);
            this.semWork = new Semaphore(0, 1);
        }

        /// <summary>
        /// Set state of control
        /// </summary>
        /// <param name="controlState"></param>
        public void SetControlState(ControlState controlState)
        {
            switch (controlState)
            {
                case ControlState.NewFee:
                    {
                        this.txtCode.Enabled = true;
                        this.txtDescription.Enabled = true;
                        this.txtAmount.Enabled = true;

                        break;
                    }
                case ControlState.ViewFee:
                    {
                        this.txtCode.Enabled = false;
                        this.txtDescription.Enabled = false;
                        this.txtAmount.Enabled = false;
                        break;
                    }
            }
        }

    /// <summary>
    /// Определяет текущее состояние пользователя.
    /// </summary>
    protected virtual void DefineCurrentState()
    {
        SLService.SLService service = new SLService.SLService();
        IList<WorkEvent> mainAndLastWorkEvent = service.GetMainWorkAndLastEvent(Page.CurrentUser.ID.Value);
        WorkEvent TodayWorkEvent = mainAndLastWorkEvent[0];
        WorkEvent LastEvent = mainAndLastWorkEvent[1];

        if (TodayWorkEvent == null ||
            (TodayWorkEvent.BeginTime != TodayWorkEvent.EndTime))
        {
            State = ControlState.WorkFinished;
            return;
        }

        switch (LastEvent.EventType)
        {
            case WorkEventType.MainWork:
                State = ControlState.WorkGoes;
                break;

            case WorkEventType.TimeOff:
                State = LastEvent.BeginTime == LastEvent.EndTime
                            ? ControlState.Absent
                            : ControlState.WorkGoes;
                break;

            case WorkEventType.LanchTime:
                State = LastEvent.BeginTime == LastEvent.EndTime
                            ? ControlState.Feeding
                            : ControlState.WorkGoes;
                break;

            case WorkEventType.StudyEnglish:
                State = LastEvent.BeginTime == LastEvent.EndTime
                            ? ControlState.EnglishLesson
                            : ControlState.WorkGoes;
                break;
        }
    }