/// <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);
}
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;
}
}
}
//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);
}
}
//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);
}
/// <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();
}
// Use this for initialization
void Start()
{
state = SceneState.ACTIVE;
opScreenCover = 0.0f;
opText = 0.0f;
currAnimTick = 0.0f;
maxAnimTime = 2.4f;
}
public MySceneBehavior()
: base("MySceneBehavior")
{
this.diagnostics = false;
WaveServices.ScreenContextManager.SetDiagnosticsActive(this.diagnostics);
this.sceneState = SceneState.EMITER;
this.gravityIndex = 0;
}
void OnTaskFinished(SingleGameLogic logic)
{
this.logic = logic;
task = null;
startButton.Activate();
loading.Stop();
state = SceneState.Ready;
OnAppearanceChanged();
}
public void LoadSceneSystemViever(Location location)
{
Glob.sceneLocation = location;
SceneManager.sceneLoaded += OnDrawMapAfterLoadScene;
SceneManager.LoadScene("SystemViewer");
Glob.currentScene = EScene.systemViewer;
sceneState = new SceneStateSystemViewer(location);
UI.Escaper.Add(LoadSceneStarSystem);
}
/// <summary>
/// シーンチェンジをするときに呼び出すもの
/// </summary>
/// <param name="name"></param>
public void SceneChange(SceneState name)
{
// 2重に入らないようにするための仕掛け
if (changeNowFlg)
{
return;
}
StartCoroutine(SceneActiveChange(name));
}
private void ApplyBeforeDraw(DrawState drawState, SceneState sceneState)
{
ApplyRenderState(drawState.RenderState);
ApplyVertexArray(drawState.VertexArray);
ApplyShaderProgram(drawState, sceneState);
_textureUnits.Clean();
ApplyFramebuffer();
}
// 「STAGE CLEAR」演出
IEnumerator OnStageClear()
{
// 3秒待ってシーン遷移
sceneState = SceneState.StageClear;
ShowMessage("STAGE CLEAR");
yield return(new WaitForSeconds(3.0f));
SceneManager.LoadScene("StageClear");
}
// このステージをクリアーさせます。
public void StageClear()
{
// ステージプレイ中のみ
if (sceneState == SceneState.Play)
{
sceneState = SceneState.StageClear;
LoadNextScene();
}
}
// handle anything that needs to happen before loading
private void UpdateScenePreload()
{
sceneLoadTask = SceneManager.LoadSceneAsync(nextSceneName);
//sceneLoadTask = Application.LoadLevelAsync(nextSceneName);
//sceneLoadTask.allowSceneActivation = false;
//Debug.Log (sceneLoadTask.progress);
sceneState = SceneState.Load;
}
//-----------------------------------------------------------
/// <summary>
/// Called whenever a modal window button is tapped
/// </summary>
/// <param name="buttonID">ID of button (really of modal)</param>
/// <param name="buttonAction">Action dictated by button</param>
/// <remarks>
/// Called directly by buttons--should be event-driven
/// </remarks>
public void ModalButtonClicked(ButtonID buttonID, ButtonAction buttonAction)
{
SceneState sceneState = sceneManager.GetCurrentState();
if (sceneState == SceneState.Modal || sceneState == SceneState.GameOver)
{
sceneManager.ButtonClicked(buttonID, buttonAction);
}
}
public void ChangeScene(SceneState _sceneState)
{
switch (_sceneState)
{
case SceneState.MAIN:
{
if (sceneState == SceneState.WIN)
{
AudioManager.instance.Stop("Victory Theme");
}
else if (sceneState == SceneState.LOSS)
{
AudioManager.instance.Stop("Loss Theme");
}
transition = GameObject.Find("SceneTransition").GetComponent <Animator>();
StartCoroutine(TransitionScene("MenuScene", 1.0f, "Opening Theme"));
sceneState = _sceneState;
break;
}
case SceneState.GAME:
{
AudioManager.instance.Stop("Opening Theme");
transition = GameObject.Find("SceneTransition").GetComponent <Animator>();
StartCoroutine(TransitionScene("GameScene", 1.0f, "In-Game Theme"));
sceneState = _sceneState;
break;
}
case SceneState.WIN:
{
AudioManager.instance.Stop("In-Game Theme");
transition = GameObject.Find("SceneTransition").GetComponent <Animator>();
StartCoroutine(TransitionScene("WinScene", 1.0f, "Victory Theme"));
sceneState = _sceneState;
break;
}
case SceneState.LOSS:
{
AudioManager.instance.Stop("In-Game Theme");
transition = GameObject.Find("SceneTransition").GetComponent <Animator>();
StartCoroutine(TransitionScene("LossScene", 1.0f, "Loss Theme"));
sceneState = _sceneState;
break;
}
}
IEnumerator TransitionScene(string _sceneName, float _transitionTime, string _sceneMusicName)
{
transition.SetTrigger("Start");
yield return(new WaitForSeconds(_transitionTime));
SceneManager.LoadScene(sceneName: _sceneName);
AudioManager.instance.Play(_sceneMusicName);
}
}
public void Render(Context context, SceneState sceneState)
{
Verify.ThrowIfNull(context);
Verify.ThrowIfNull(sceneState);
_lineWidth.Value = (float)(0.5 * Width * sceneState.HighResolutionSnapScale);
context.Draw(_primitiveType, _drawState, sceneState);
}
public void OnGameSceneActive()
{
if (CurrentSceneState == SceneState.Game)
{
return;
}
Logger.log.Debug(">>>> Plugin|OnGameSceneActive doing stuff");
CurrentSceneState = SceneState.Game;
}
} // End of FadeIn.
/// <summary>
/// @brief 実行
/// </summary>
private void Play()
{
// タイマーが止まったとき
if (m_timer.IsFinish())
{
// シーンステータスを " タイムアップ " へ
m_scene_state = SceneState.TIME_UP;
}
} // End of Play.
internal void HandleTransition(SceneState _State, float _TransitionStatus)
{
mColor = mColor * _TransitionStatus;
mPosition = Vector2.Lerp(mDesc.StartPosition, mDesc.EndPosition, _TransitionStatus);
if (_TransitionStatus == 1)
{
mPosition = mDesc.EndPosition;
}
}
// handle anything that needs to happen immediately before running
private void UpdateSceneReady()
{
// run a gc pass
// if you have assets loaded in the scene that are
// currently unused currently but may be used later
// DON'T do this here
System.GC.Collect();
sceneState = SceneState.Run;
}
public override void Render(Context context, SceneState sceneState)
{
_polyline.Render(context, sceneState);
foreach (Polygon polygon in _polygons)
{
polygon.Render(context, sceneState);
}
}
// 「GAME OVER」演出
IEnumerator OnGameOver()
{
// 3秒待ってシーン遷移
sceneState = SceneState.GameOver;
ShowMessage("GAME OVER");
yield return(new WaitForSeconds(3.0f));
SceneManager.LoadScene("Title");
}
public void GameClear()
{
if (singleton == 1)
{
S = SceneState.GAME_WIN;
SceneManager.LoadScene(game_win);
}
singleton = 0;
}
private void OnSceneLoad(Scene scene, LoadSceneMode mode)
{
CurrentScene = _loadState;
if (_loadState != null)
{
Debug.Log("Load: " + _loadState.SceneName);
_loadState.OnLoad();
}
}
void Start()
{
titleAnim = title.GetComponent <Animator>();
tagAnim = tag.GetComponent <Animator>();
titleAnim.SetBool("isHidden", false);
tagAnim.SetBool("isHidden", false);
state = SceneState.INTRO;
start.GetComponent <Animator>().SetBool("active", false);
}
// このステージをクリアーさせます。
public void StageClear()
{
// ステージプレイ中のみ
if (sceneState == SceneState.Play)
{
sceneState = SceneState.StageClear;
Instantiate(stageClearPrefab, uiRoot);
}
}
// このステージをゲームオーバーで終了させます。
public void GameOver()
{
// ステージプレイ中のみ
if (sceneState == SceneState.Play)
{
sceneState = SceneState.GameOver;
Instantiate(gameOverPrefab, uiRoot);
}
}
void onOptionsLoaded()
{
currentState = SceneState.MENU;
OptionsHandler optionsHandler =
GameController.FindObjectOfType <OptionsHandler>();
optionsHandler.startOptionsMenu(myPrefs, this);
}
private void OnSceneUnload(Scene scene)
{
if (CurrentScene != null)
{
Debug.Log("Unload: " + CurrentScene.SceneName);
CurrentScene.OnUnload();
}
CurrentScene = null;
}
public Scene()
{
mChannels = new ArrayList();
mSteps = new ArrayList();
mName = "";
mCategory = "";
mChannelNames = new ArrayList();
mState = SceneState.Nothing;
}
void onArenaLoaded()
{
currentState = SceneState.PLAYING;
mouseController = new MouseController();
boardController = new BoardController();
boardController.beginChessGame(boardInfo);
}
/**
* Overrides the start functionality
* provided by manager
*/
public override void Start()
{
if (state == null) {
DontDestroyOnLoad(gameObject);
state = this;
} else if (state != this) {
Destroy(gameObject);
}
}
public static SceneState LoadBinary(string dataPath)
{
BinaryFormatter binary = new BinaryFormatter();
FileStream stream = new FileStream(dataPath, FileMode.Open);
SceneState state = (SceneState)binary.Deserialize(stream);
stream.Close();
return(state);
}
public void OnSceneStateChanged(SceneState state)
{
if (state == SceneState.Minigame)
{
MiniGame minigame = FindObjectOfType <MiniGame>();
minigame.OnScoreChanged += OnScoreChanged;
minigame.OnItemCountChanged += OnItemCountChanged;
}
}
public SaveState()
{
LoadedDataPack = "";
EntryName = "";
SceneState = new SceneState();
ResourcePacks = new List <string>();
x = 0;
y = 0;
}
// このステージをゲームオーバーで終了させます。
public void GameOver()
{
// ステージプレイ中のみ
if (sceneState == SceneState.Play)
{
sceneState = SceneState.GemaOver;
LoadSceneWithFadeOut("GameOver");
}
}
public void Restart()
{
gameState = GameState.Running;
sceneState = SceneState.Waiting;
currentRound = 1;
currentTrial = 1;
score = 0;
onRefresh.Invoke(this, EventArgs.Empty);
}
public int changeAndMoveScene(SceneState stateNum)
{
if (SM.sceneState != stateNum)
{
SM.sceneState = stateNum;
moveScene();
return 1;
}
else
return 0;
}
// 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 Update()
{
if (Time.timeSinceLevelLoad - lastSwitchSeconds > intervalSeconds) {
lastSwitchSeconds = Time.timeSinceLevelLoad;
sceneState++;
if (sceneState > SceneState.WaterFloors) {
sceneState = SceneState.FireFloors;
}
SetScene(sceneState);
}
}
void Start () {
mainCamera = Camera.main;
playerController = GetComponent<PlayerController>();
if(!sceneDebug)
{
actualSceneState = SceneState.FirstScene;
disableAllButtons();
firstScene.enableButtons();
}
}
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>();
}
/// <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();
}
//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; };
}
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);
}
}
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;
}
// 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> ().
}
//======================================================================================
// protected mono methods
//======================================================================================
protected void Awake()
{
Object.DontDestroyOnLoad (gameObject);
mainController = this;
updateDelegates = new UpdateDelegate[(int)SceneState.Count];
updateDelegates [(int)SceneState.Reset] = UpdateSceneReset;
updateDelegates [(int)SceneState.Preload] = UpdateScenePreload;
updateDelegates [(int)SceneState.Load] = UpdateSceneLoad;
updateDelegates [(int)SceneState.Unload] = UpdateSceneUnload;
updateDelegates [(int)SceneState.Postload] = UpdateScenePostload;
updateDelegates [(int)SceneState.Ready] = UpdateSceneReady;
updateDelegates [(int)SceneState.Run] = UpdateSceneRun;
nextSceneName = "Menu Scene";
sceneState = SceneState.Reset;
GetComponent<Camera>().orthographicSize = Screen.height/2;
}
protected void Awake()
{
//Make this a singleton
Object.DontDestroyOnLoad (gameObject);
mainController = this;
//Store all update functions in an array of delegates.
updateDelegates = new UpdateDelegate[(int)SceneState.Count];
updateDelegates [(int)SceneState.Reset] = UpdateSceneReset;
updateDelegates [(int)SceneState.Preload] = UpdateScenePreload;
updateDelegates [(int)SceneState.Load] = UpdateSceneLoad;
updateDelegates [(int)SceneState.Unload] = UpdateSceneUnload;
updateDelegates [(int)SceneState.Postload] = UpdateScenePostload;
updateDelegates [(int)SceneState.Ready] = UpdateSceneReady;
updateDelegates [(int)SceneState.Run] = UpdateSceneRun;
nextSceneName = defaultSceneName;
sceneState = SceneState.Reset;
}
// Update is called once per frame
void Update()
{
switch(currentState) {
case SceneState.WalkingOffPorch:
thinkingOnPorch += Time.deltaTime;
if(thinkingOnPorch > 1) { //TODO:Change this for when he talks on porch
pauseForABit += Time.deltaTime;
MoveTo (wanderPoints [wanderIndex], wanderSpeed);
if(transform.position.z < 269.8f && pauseForABit > 2.0f) {
mainCamera.GetComponent<MainCameraScriptScene5>().OnTriggerSwitchCam2();
currentState = SceneState.Thinking;
wanderIndex++;
} else {
anim.Play ("Walking");
}
} else {
//anim.Play ();
}
break;
case SceneState.Thinking:
thinkingPeriod += Time.deltaTime;
if(thinkingPeriod < 10) {
anim.Play ("Thinking");
} else {
anim.Play ("Excited");
currentState = SceneState.Water;
}
break;
case SceneState.Water:
MoveTo(wanderPoints[wanderIndex], wanderSpeed);
if(transform.eulerAngles.y > 210) {
transform.Rotate(new Vector3(0,-1f,0));
}
anim.Play ("WalkingToWater");
if(transform.position.x == 202.9) {
currentState = SceneState.waitAtWater;
}
break;
case SceneState.waitAtWater:
anim.Play ("Idle");
break;
}
}
public ScreenManager(Game game, GraphicsDeviceManager graphics)
{
this.content = new ContentManager(game.Services, "Content");
this.GraphicsDevice = graphics.GraphicsDevice;
this.graphicsDeviceService = (IGraphicsDeviceService)game.Services.GetService(typeof(IGraphicsDeviceService));
if (this.graphicsDeviceService == null)
{
throw new InvalidOperationException("No graphics device service.");
}
this.lightingSystemManager = new LightingSystemManager(game.Services);
this.sceneState = new SceneState();
this.inter = new SceneInterface(graphics);
this.inter.CreateDefaultManagers(false, false, true);
this.editor = new LightingSystemEditor(game.Services, graphics, game)
{
UserHandledView = true
};
this.inter.AddManager(this.editor);
}
public void Update(Microsoft.Xna.Framework.GameTime GameTime) {
switch (MenuState) {
case MenuState.Animation:
break;
case MenuState.PressToStart:
if (Keyboard.GetState().IsKeyDown(Keys.Z) || Keyboard.GetState().IsKeyDown(Keys.Enter) && !transitioning) {
transitioning = true;
KeyDownSpan = Environment.TickCount;
}
if (transitioning && Environment.TickCount - KeyDownSpan >= transitionTime) {
transitioning = false;
MenuState = MenuState.Interaction;
}
break;
case MenuState.Interaction:
bool up = Keyboard.GetState().IsKeyDown(Keys.Up);
bool down = Keyboard.GetState().IsKeyDown(Keys.Down);
bool A = Keyboard.GetState().IsKeyDown(Options.A) || Keyboard.GetState().IsKeyDown(Options.Start);
if (up && !Pressed) {
if (Selection - 1 >= 0) {
Selection--;
Pressed = true;
}
} else if (down && !Pressed) {
if (Selection + 1 < Boxes.Count) {
Selection++;
Pressed = true;
}
}
if (!up && !down) Pressed = false;
if (A) {
this.SceneState = SceneState.Dead;
}
break;
}
}
// Update is called once per frame
void Update()
{
switch (state)
{
case SceneState.ENDING:
opScreenCover = opScreenCover + Time.deltaTime;
if (opScreenCover > maxAnimTime)
{
opScreenCover = maxAnimTime;
state = SceneState.ENDED;
}
break;
case SceneState.ENDED:
opText = opText + Time.deltaTime;
if(opText > maxAnimTime)
{
opText = maxAnimTime;
state = SceneState.DISPLAYINGTEXT;
}
break;
case SceneState.DISPLAYINGTEXT:
currAnimTick = currAnimTick + Time.deltaTime;
if (currAnimTick > maxAnimTime)
{
currAnimTick = maxAnimTime;
state = SceneState.FADINGTEXT;
}
break;
case SceneState.FADINGTEXT:
opText -= Time.deltaTime;
if(opText < 0)
{
opText = 0;
UnityEngine.SceneManagement.SceneManager.LoadScene("Menu");
}
break;
default:
break;
}
}
public SimpleGameScreen()
{
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);
BaseGameProgram.Instance.OnInitializeSceneInterface(sceneInterface);
// 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.High);
sceneInterface.ResourceManager.AssignOwnership(frameBuffers);
}
//--------------------------------------------------------------------------
// protected mono methods
//--------------------------------------------------------------------------
protected void Awake()
{
//Let's keep this alive between scene changes
Object.DontDestroyOnLoad(gameObject);
//Setup the singleton instance
mainController = this;
//Setup the array of updateDelegates
updateDelegates = new UpdateDelegate[(int)SceneState.Count];
//Set each updateDelegate
updateDelegates[(int)SceneState.Reset] = UpdateSceneReset;
updateDelegates[(int)SceneState.Preload] = UpdateScenePreload;
updateDelegates[(int)SceneState.Load] = UpdateSceneLoad;
updateDelegates[(int)SceneState.Unload] = UpdateSceneUnload;
updateDelegates[(int)SceneState.Postload] = UpdateScenePostload;
updateDelegates[(int)SceneState.Ready] = UpdateSceneReady;
updateDelegates[(int)SceneState.Run] = UpdateSceneRun;
nextSceneName = "Start Menu";
sceneState = SceneState.Reset;
}
//--------------------------------------------------------------------------
// protected mono methods
//--------------------------------------------------------------------------
protected void Awake()
{
//Let's keep this alive between scene changes
Object.DontDestroyOnLoad(gameObject);
//Setup the singleton instance
mainController = this;
//Setup the array of updateDelegates
updateDelegates = new UpdateDelegate[(int)SceneState.Count];
//Set each updateDelegate
updateDelegates[(int)SceneState.Reset] = UpdateSceneReset;
updateDelegates[(int)SceneState.Preload] = UpdateScenePreload;
updateDelegates[(int)SceneState.Load] = UpdateSceneLoad;
updateDelegates[(int)SceneState.Unload] = UpdateSceneUnload;
updateDelegates[(int)SceneState.Postload] = UpdateScenePostload;
updateDelegates[(int)SceneState.Ready] = UpdateSceneReady;
updateDelegates[(int)SceneState.Run] = UpdateSceneRun;
nextSceneName = "Menu Scene";
sceneState = SceneState.Reset;
GetComponent<Camera>().orthographicSize = Screen.height/2;
}
