public virtual void Update(double totalTime, double frameTime)
        {
            m_elapsed += (float)frameTime;

            switch (m_sceneState)
            {
                case SceneState.TransitioningOn:
                    {
                        m_transitionAlpha = 1 - (m_elapsed / (float)TransitionOffLength.TotalSeconds);

                        if (m_elapsed >= (float)TransitionOnLength.TotalSeconds)
                        {
                            m_elapsed = 0;
                            m_sceneState = SceneState.Active;
                        }

                        break;
                    }
                case SceneState.TransitioningOff:
                    {
                        m_transitionAlpha = m_elapsed / (float)TransitionOnLength.TotalSeconds;

                        if (m_elapsed >= (float)TransitionOffLength.TotalSeconds)
                        {
                            m_elapsed = 0;
                            m_sceneState = SceneState.None;

                            if (TransitionCompleted != null)
                                TransitionCompleted();
                        }

                        break;
                    }
            }
        }

        /// <summary>
        /// Constructs a new screen manager component.
        /// </summary>
        public ScreenManager(Game game)
            : base(game)
        {
            // we must set EnabledGestures before we can query for them, but
            // we don't assume the game wants to read them.
            TouchPanel.EnabledGestures = GestureType.None;

            // Create the lighting system.
            sunBurnCoreSystem = new SunBurnCoreSystem(game.Services, game.Content);
            sceneState = new SceneState();

            // Create the scene interface. Acts as a service provider containing all scene managers
            // and returning them by type (including custom managers). Also acts as a component
            // container where calls to manager methods on the SceneInterface (such as BeginFrameRendering,
            // Unload, ...) are automatically called on all contained managers.
            //
            // This design allows managers to be plugged-in like modular components and for managers
            // to easily be added, removed, or replaced with custom implementations.
            //
            sceneInterface = new SceneInterface();
            sceneInterface.CreateDefaultManagers(RenderingSystemType.Forward, CollisionSystemType.Physics, true);

            // Create the frame buffers used for rendering (sized to the backbuffer) and
            // assign them to the ResourceManager so we don't have to worry about cleanup.
            frameBuffers = new FrameBuffers(DetailPreference.High, DetailPreference.Medium);
            sceneInterface.ResourceManager.AssignOwnership(frameBuffers);

            // Post console messages letting the user know how to open the SunBurn Editor.
            sceneInterface.ShowConsole = true;
            SystemConsole.AddMessage("Welcome to the SunBurn Engine.", 4);
            SystemConsole.AddMessage("Use an Xbox controller or the W, A, S, D keys to navigate the scene.", 8);
            SystemConsole.AddMessage("Press F11 to open the SunBurn Editor.", 12);
        }

    //sets scene to main menu by default
    public void Awake()
    {
        //keep alive
        DontDestroyOnLoad(gameObject);
        _mainController = this;

        _updateDelegates = new UpdateDelegate[(int)SceneState.Count];

        _updateDelegates[(int)SceneState.Reset] = SceneStateReset;
        _updateDelegates[(int)SceneState.Preload] = SceneStatePreload;
        _updateDelegates[(int)SceneState.Load] = SceneStateLoad;
        _updateDelegates[(int)SceneState.Unload] = SceneStateUnload;
        _updateDelegates[(int)SceneState.PostLoad] = ScreenStatePostLoad;
        _updateDelegates[(int)SceneState.Ready] = ScreenStateReady;
        _updateDelegates[(int)SceneState.Run] = ScreenStateRun;

        _nextSceneName = "MainMenu";

        //testing event messaging system
        Messenger.AddListener<string>("Scene change",Test);
        Messenger.MarkAsPermanent("Scene change"); // <-- persists through scene changes
        Messenger.Broadcast("Scene change", _nextSceneName);
        //oh yeah... that's how I like it.

        _currentSceneState = SceneState.Reset;
    }

    public void SetState(SceneState state)
    {
        State = state;

        if (state == SceneState.LookScene)
        {
            MenuListUI.gameObject.SetActive(false);
            MenuItemUI.gameObject.SetActive(false);

            virtualTouch.joystickRight.gameObject.SetActive(true);
            virtualTouch.joystickLeft.gameObject.SetActive(true);
        }
        else if (state == SceneState.LookMenuList)
        {
            MenuListUI.gameObject.SetActive (true);
            MenuItemUI.gameObject.SetActive(false);

            virtualTouch.joystickRight.gameObject.SetActive(false);
            virtualTouch.joystickLeft.gameObject.SetActive(false);
        }
        else if (state == SceneState.LookMenuItem)
        {
            MenuListUI.gameObject.SetActive (false);
            MenuItemUI.gameObject.SetActive(true);

            virtualTouch.joystickRight.gameObject.SetActive(false);
            virtualTouch.joystickLeft.gameObject.SetActive(false);
        }
    }

 // Use this for initialization
 void Start()
 {
     state = SceneState.ACTIVE;
     opScreenCover = 0.0f;
     opText = 0.0f;
     currAnimTick = 0.0f;
     maxAnimTime = 2.4f;
 }

 /// <summary>
 ///   Creates a new Camera instance
 /// </summary>
 /// <param name = "aspectRatio">The viewport aspect ratio</param>
 protected Camera2D(float aspectRatio)
 {
     AspectRatio = aspectRatio;
     Distance = 1.0f;
     
     SceneState = new SceneState();
     SceneEnvironment = new SceneEnvironment();
 }

 public MySceneBehavior()
     : base("MySceneBehavior")
 {
     this.diagnostics = false;
     WaveServices.ScreenContextManager.SetDiagnosticsActive(this.diagnostics);
     this.sceneState = SceneState.EMITER;
     this.gravityIndex = 0;
 }

 //triggers events in the sequence
 public void SetSceneState(SceneState state)
 {
     //sets the current scene state and then applies its value to all stored Animator components
     currentSceneState = state;
     char1Animator.SetInteger("SceneState", (int)currentSceneState);
     doorAnimator.SetInteger("SceneState", (int)currentSceneState);
     char2Animator.SetInteger("SceneState", (int)currentSceneState);
 }

	public int changeAndMoveScene(SceneState stateNum)
	{
		if (SM.sceneState != stateNum) 
		{
			SM.sceneState = stateNum;
			moveScene();
			return 1;
		} 
		else
			return 0;
	}

 void Update()
 {
     if (Time.timeSinceLevelLoad - lastSwitchSeconds > intervalSeconds) {
     lastSwitchSeconds = Time.timeSinceLevelLoad;
     sceneState++;
     if (sceneState > SceneState.WaterFloors) {
     sceneState = SceneState.FireFloors;
     }
     SetScene(sceneState);
     }
 }

    // Use this for initialization
    void Start ()
    {
        mapInstances = FindObjectsOfType<Map>().ToList();
        if (!waveManager)
            waveManager = FindObjectOfType<WaveManager>();
        waveManager.OnWaveFinished += OnWaveFinished;
        waveManager.OnWaveStart += OnWaveStart; 
        ga = GetComponent<GeneticAlgorithm>();

        state = SceneState.Idle;
    }

	void Start () {
        mainCamera = Camera.main;

        playerController = GetComponent<PlayerController>();

        if(!sceneDebug)
        {
            actualSceneState = SceneState.FirstScene;
            disableAllButtons();
            firstScene.enableButtons();
        }
    }

        /// <summary>
        ///   Creates a new Camera instance
        /// </summary>
        /// <param name = "aspectRatio">The viewport aspect ratio</param>
        /// <param name = "fieldOfView">The _instances of view expressed in radians</param>
        /// <param name = "nearPlaneDistance">The nearest point in projected space of the camera</param>
        /// <param name = "farPlaneDistance">The farest point in projected space of the camera</param>
        protected Camera3D(float aspectRatio, float fieldOfView, float nearPlaneDistance,
                         float farPlaneDistance)
        {
            _aspectRatio = aspectRatio;
            _fieldOfView = fieldOfView;
            _nearPlaneDistance = nearPlaneDistance;
            _farPlaneDistance = farPlaneDistance;

            _isProjectionDirty = true;

            SceneState = new SceneState();
            SceneEnvironment = new SceneEnvironment();
        }

        public BaseScene(Game game, bool needsUIService)
        {
            _game = game;
            _clearColor = Color.Black;
            _content = new ContentManager(_game.Services);
            _content.RootDirectory = "Content";
            _sceneState = SceneState.TransitioningOn;

            _sceneService = game.Services.GetService<ISceneService>(true);
            _inputService = game.Services.GetService<IInputState>(true);
            _worldService = game.Services.GetService<IIsometricRenderer>(true);
            _uiService = game.Services.GetService<IUIManager>();
        }

    //Stateを変更する
    public void ChangeState(SceneState sceneState)
    {
        //前Stateの終了処理
        if(state != null)
            state.StateExit();

        currentState = sceneState;

        //新規Stateのセット
        state = Activator.CreateInstance(stateTable[sceneState]) as IState;

        //新規Stateの初期化処理
        state.StateStart();
    }

 // Update is called once per frame
 void Update()
 {
     switch (currentState) {
         case SceneState.Walking:
             if (target != null) {
                 if(orbitY) {
                     if(totalAngle < 110) {
                         transform.RotateAround(target.transform.position, Vector3.up, Time.deltaTime * camRotateSpeed);
                         totalAngle += 10 * Time.deltaTime;
                     } else {
                         currentState = SceneState.hearsSomething;
                     }
                 }
             }
             break;
         case SceneState.hearsSomething:
             waitTimerHearsSomething += Time.deltaTime;
             if(waitTimerHearsSomething >= waitTime) {
                 //TODO: zoom into facial expression if can
                 currentState = SceneState.reaperGiantFight;
             }
             break;
         case SceneState.reaperGiantFight:
             transform.LookAt(transformToLookAt.transform);
             //Debug.Log(transformToLookAt.transform);
             //transform.LookAt (new Vector3(0,-.3f,-1));
             //TODO: Zoom in on the fight
             waitTimeCameraFight += Time.deltaTime;
             if(waitTimeCameraFight <= waitTime) {
                 transform.Translate(Vector3.forward * Time.deltaTime * 14);
             } else {
                 currentState = SceneState.runToHelp;
             }
             break;
         case SceneState.runToHelp:
             //waitFor3Seconds();
             waitTimeWatchFight += Time.deltaTime;
             if(waitTimeWatchFight >= waitTimeForFight) {
                 if(transform.position.x < 150.0) {
                     transform.Translate(new Vector3(0, 0, -1));
                     //TODO: stablize the camera, it keeps bouncing back and forth
                 } else {
                     //Switch to zoom into scythe
                     mainCamera.GetComponent<MainCameraScript>().SwitchToCam4();
                 }
             }
             break;
     }
 }

        /// <summary>
        ///   Creates a new Camera instance
        /// </summary>
        /// <param name = "aspectRatio">The viewport aspect ratio</param>
        /// <param name = "fieldOfView">The _instances of view expressed in radians</param>
        /// <param name = "nearPlaneDistance">The nearest point in projected space of the camera</param>
        /// <param name = "farPlaneDistance">The farest point in projected space of the camera</param>
        protected Camera3D(float aspectRatio, float fieldOfView, float nearPlaneDistance,
                         float farPlaneDistance)
        {
            _aspectRatio = aspectRatio;
            _fieldOfView = fieldOfView;
            _nearPlaneDistance = nearPlaneDistance;
            _farPlaneDistance = farPlaneDistance;

            _isProjectionDirty = true;

            SceneState = new SceneState();
            SceneEnvironment = new SceneEnvironment();
            Application.Graphics.DeviceReset += (sender, args) => {
                _isProjectionDirty = true; };
        }

		public GameScene(GameData data, SpriteBatch SpriteBatch) {
			this.SpriteBatch = SpriteBatch;
			this.UIManager = new UIManager();
			this.Data = data;
			World = Data.RegionData.CreateWorld(this, SpriteBatch.GraphicsDevice);
			World.Maps.Add(Data.MapDatas[0].CreateMap(World));

			EntityTemplate templatePlayer = World.EntityContainer.GetPlayers()[0];

			Player = templatePlayer.CreateEntity(World.EntityFactory, true) as PlayerEntity;
			World.Player = Player;
			World.Maps[0].AddEntity(Player);
			new LivingController(Player);
			World.CurrentMap = Player.Map;
			this.SceneState = SceneState.Alive;
		}

 void SetScene(SceneState state)
 {
     if (state == SceneState.BillieJean) {
     ActivateBillieJean(true);
     ActivateFireFloors(false);
     ActivateWaterFloors(false);
     } else if (state == SceneState.FireFloors) {
     ActivateBillieJean(false);
     ActivateFireFloors(true);
     ActivateWaterFloors(false);
     } else if (state == SceneState.WaterFloors) {
     ActivateBillieJean(true);
     ActivateFireFloors(false);
     ActivateWaterFloors(true);
     }
 }

	// Use this for initialization
	void Awake() 
	{
		//SIMON.GlobalSIMON.CleanSIMONEnvironment ();
		SIMON.GlobalSIMON.CleanSIMONGroup (GameTimeManager_Simulation.GroupC);
		SIMON.GlobalSIMON.CleanSIMONGroup (GameTimeManager_Simulation.GroupA);
		SIMON.GlobalSIMON.CleanSIMONGroup (GameTimeManager_Simulation.GroupB);
		SIMON.GlobalSIMON.CleanSIMONGroup (GameTimeManager.GroupA);
		SIMON.GlobalSIMON.CleanSIMONGroup (GameTimeManager.GroupB);
		SIMON.GlobalSIMON.CleanSIMONGroup (GameTimeManager_Compare.GroupB);
		SIMON.GlobalSIMON.CleanSIMONGroup (GameTimeManager_Compare.GroupA);

		SIMON.GlobalSIMON.CleanSIMONEnvironment ();
		PlayGame_State = 1;
		SM = this;
		sceneState = SceneState.scene_menu;
	//	btnStartGame.GetComponent<Animator> ().
	}