} // and of Activate() public void Deactivate() { active = false; diffuse = null; HelpOverlay.Pop(); CommandStack.Pop(commandMap); } // end of Deactivate()
} // end of RunSimUpdateObj Activate() public override void Deactivate() { if (active) { active = false; if (parent.cursorClone != null) { parent.cursorClone.Deactivate(); parent.cursorClone = null; } // Deactivate the PreGame if any. if (parent.PreGame != null) { parent.PreGame.Active = false; } CommandStack.Pop(commandMap); HelpOverlay.Pop(); Instrumentation.StopTimer(timerInstrument); #if !NETFX_CORE MicrobitManager.ReleaseDevices(); #endif base.Deactivate(); // ObjectAnalysis oa = new ObjectAnalysis(); //oa.beginAnalysis("out.txt"); } } // end of RunSimUpdateObj Deactivate()
} // end of MainMenu Activate() override public void Deactivate() { if (state != States.Inactive) { // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. shared.menu.Active = false; CommandStack.Pop(commandMap); shared.menu.DeleteText(Strings.Localize("mainMenu.resume")); shared.menu.Active = false; // Just to be sure. shared.optionsMenu.Deactivate(); pendingState = States.Inactive; BokuGame.objectListDirty = true; GamePadInput.IgnoreUntilReleased(Buttons.A); Instrumentation.StopTimer(timerInstrument); Foley.StopMenuLoop(); } } // end of MainMenu Deactivate()
public void Undo(CharacterObservable caller, CharacterObservable personaeToInteracWith, GameManager gm) { PreviousAction = (ICharacterActionCommand)CommandStack.Pop(); if (PreviousAction is AttackCommand && LastCharacterAttacked != null) { var attackStrenght = caller.Stats.GetAttackStrenght(caller, LastCharacterAttacked); LastCharacterAttacked.Health.RaiseHealth(caller); ((AttackCommand)PreviousAction).IsExecuted = false; return; } if (PreviousAction is DefendCommand) { caller.Stats.DefenseBonusActivated = false; caller.Stats.ResetTemporaryBonus(); ((DefendCommand)PreviousAction).IsExecuted = false; return; } if (PreviousAction is MoveCommand) { //caller.CurrentCoordinates = caller.OldCoordinates; //((MoveCommand)PreviousAction).Execute(caller.CurrentCoordinates); //((MoveCommand)PreviousAction).IsExecuted = false; } PreviousAction.Execute(caller); }
} // end of ToolBoxUpdateObj c'tor /// <summary> /// ToolBoxUpdateObj Update() /// </summary> /// <param name="camera"></param> public override void Update() { base.Update(); // No need to check for input focus or anything. If // we're active then the ToolBox object has focus. shared.ToolBox.Update(); // If the ToolBox is no longer active we're done. if (!shared.ToolBox.Active) { return; } // Do the common bits of the Update(). // The actual input focus is in the currently active tool so // temporarily push ourselves onto the command stack so we // can still steal camera control input. // TODO (****) Move this up above the tool update to remove a frame of lag? Will this cause other problems? CommandStack.Push(commandMap); // No need to lock the zoom any more since we're using the trigger buttons for grid selection. bool lockZoom = false; UpdateCamera(lockZoom); UpdateWorld(); UpdateEditBrush(); CommandStack.Pop(commandMap); } // end of ToolBoxUpdateObj Update()
} // end of Activate() public void Deactivate() { if (Active) { if (prevLanguage != XmlOptionsData.Language) { changeLanguageMessage.Activate(useRtCoords: true); grid.Active = true; // Keep grid active. return; } grid.Active = false; HelpOverlay.Pop(); // Pop off the help overlay for the current options element. CommandStack.Pop(commandMap); HelpOverlay.Pop(); // Pop off the help for the options menu. // Prevent the button pressed from leaking into runtime. GamePadInput.IgnoreUntilReleased(Buttons.B); active = false; touched = (PlayerIndex)(-1); GamePadInput.ClearAllWasPressedState(); MainMenu.Instance.LiveFeedDirty = true; } } // end of Deactivate()
public override void Deactivate() { CommandStack.Pop(commandMap); KeyboardInput.OnChar = null; KeyboardInput.OnKey = null; #if !NETFX_CORE BokuGame.bokuGame.winKeyboard.CharacterEntered = null; #endif }
} // end of PreGameBase Activate() protected virtual void Deactivate() { CommandStack.Pop(commandMap); if (HelpOverlay.Peek() == "PreGame") { HelpOverlay.Pop(); } // If the pre-game has messed with the clock, restore it. Time.ClockRatio = 1.0f; } // end of PreGameBase Deactivate()
} // end of BaseEditUpdateObj Activate() public override void Deactivate() { if (active) { CommandStack.Pop(commandMap); active = false; base.Deactivate(); } } // end of BaseEditUpdateObj Deactivate()
} // end of Activate public void Deactivate() { if (state != States.Inactive) { // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. CommandStack.Pop(commandMap); state = States.Inactive; } }
} // end of Deactivate() /// <summary> /// Called once per frame by the /// </summary> public void Update() { if (Active) { /// Don't let anyone else grab focus, if anyone has, grab it back. if (CommandStack.Peek() != commandMap) { CommandStack.Pop(commandMap); CommandStack.Push(commandMap); } // Check if we have input focus. if (CommandStack.Peek() == commandMap) { GamePadInput pad = GamePadInput.GetGamePad0(); if (handlerA != null && (pad.ButtonA.WasPressed || KeyboardInput.WasPressed(Keys.A))) { GamePadInput.ClearAllWasPressedState(); GamePadInput.IgnoreUntilReleased(Buttons.A); handlerA(this); } if (handlerB != null && (pad.ButtonB.WasPressed || KeyboardInput.WasPressed(Keys.B))) { GamePadInput.ClearAllWasPressedState(); GamePadInput.IgnoreUntilReleased(Buttons.B); handlerB(this); } if (handlerX != null && (pad.ButtonX.WasPressed || KeyboardInput.WasPressed(Keys.X))) { GamePadInput.ClearAllWasPressedState(); GamePadInput.IgnoreUntilReleased(Buttons.X); handlerX(this); } if (handlerY != null && (pad.ButtonY.WasPressed || KeyboardInput.WasPressed(Keys.Y))) { GamePadInput.ClearAllWasPressedState(); GamePadInput.IgnoreUntilReleased(Buttons.Y); handlerY(this); } } // end if we have input focus. if (dirty) { // Calc max width for text string. maxWidth = (int)(width - 2.0f * margin); RefreshTexture(); } } } // end of Update()
public void UndoWrapper() { if (!commandStack.isAtStart) { undoRedoSnapInfo = null; commandStack.Pop(); groupSelect.reset(); ApplyUndoRedoSnapInfo(); undoRedoSnapInfo = null; } }
} // end of Activate() public void Deactivate() { if (active) { active = false; HelpOverlay.Pop(); CommandStack.Pop(commandMap); if (onExit != null) { onExit(this); } } } // end of Deactivate()
} // end of ToolMenuUpdateObj c'tor /// <summary> /// ToolMenuUpdateObj Update() /// </summary> /// <param name="camera"></param> public override void Update() { base.Update(); // No need to check for input focus or anything. If // we're active then the ToolMenu object has focus. shared.ToolMenu.Update(); // If the ToolMenu is no longer active we're done. if (!shared.ToolMenu.Active) { return; } // Do the common bits of the Update(). If our child is active we // can temporarily push/pop our commandMap to grab input focus. if (shared.ToolMenu.Active) { CommandStack.Push(commandMap); } UpdateCamera(false); if (shared.ToolMenu.Active) { CommandStack.Pop(commandMap); } UpdateWorld(); // TODO (****) Should this only be called for tools that use the edit brush? // TODO (****) How do we turn off the edit brush rendering if we don't need it? UpdateEditBrush(); GamePadInput pad = GamePadInput.GetGamePad0(); // Run! if (pad.Back.WasPressed) { // TODO (****) Transition to RunSim. // Or is this already done in the base class??? } // MiniHub! if (pad.Start.WasPressed) { // TODO (****) Transition to MinHub. // Or is this already done in the base class??? } ToolTipManager.Update(); ThoughtBalloonManager.Update(shared.camera); } // end of ToolMenuUpdateObj Update()
public static void UnregisterOperation(ProgressOperation op) { if (instance != null) { if (instance.operations.Contains(op)) { instance.operations.Remove(op); } if (instance.operations.Count == 0) { CommandStack.Pop(instance.commandMap); } } }
public override void Deactivate() { // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. CommandStack.Pop(commandMap); if (state != States.Inactive) { shared.Deactivate(); pendingState = States.Inactive; BokuGame.objectListDirty = true; DeactivateMessages(); } }
public void Deactivate() { if (active) { grid.Active = false; // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. CommandStack.Pop(commandMap); HelpOverlay.Pop(); InGame.inGame.RenderWorldAsThumbnail = false; active = false; } }
public void Deactivate() { if (active) { if (GamePadInput.ActiveMode == GamePadInput.InputMode.Touch) { if (TouchInput.TouchCount == 1 && TouchInput.GetOldestTouch().TouchedObject == null) { TouchInput.GetOldestTouch().TouchedObject = this; } } active = false; CommandStack.Pop(commandMap); Boku.Common.HelpOverlay.Pop(); } }
public void Deactivate() { if (active) { if (activeTool != null) { activeTool.Active = false; } // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. CommandStack.Pop(commandMap); HelpOverlay.Pop(); active = false; } }
override public void Deactivate() { if (state != States.Inactive) { // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. CommandStack.Pop(commandMap); UIGrid grid = shared.GetGridFromCurTab(); if (grid != null) { grid.Active = false; } pendingState = States.Inactive; BokuGame.objectListDirty = true; } }
override public void Deactivate() { if (state != States.Inactive) { // Make sure VirutalKeyboard is also shut down. VirtualKeyboard.Deactivate(); // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. CommandStack.Pop(commandMap); state = States.Inactive; HelpOverlay.Pop(); updateObj.Deactivate(); } }
public override bool Refresh(List <UpdateObject> updateList, List <RenderObject> renderList) { bool result = false; if (state != pendingState) { if (pendingState == States.Active) { updateList.Add(updateObj); updateObj.Activate(); renderList.Add(renderObj); renderObj.Activate(); // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. // If we do this in the Activate/Deactivate calls then we get garbaged // handling if we're polling. What can happen is that we pop ourselves // because of a 'B' button that we polled but then we no longer have input // focus and the next object in the update list may also look for and // find the B button being pressed. CommandStack.Push(commandMap); } else { renderObj.Deactivate(); renderList.Remove(renderObj); updateObj.Deactivate(); updateList.Remove(updateObj); // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. // If we do this in the Activate/Deactivate calls then we get garbaged // handling if we're polling. What can happen is that we pop ourselves // because of a 'B' button that we polled but then we no longer have input // focus and the next object in the update list may also look for and // find the B button being pressed. CommandStack.Pop(commandMap); } state = pendingState; } return(result); }
} // end of HelpScreens Activate() override public void Deactivate() { if (state != States.Inactive) { // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. CommandStack.Pop(commandMap); pendingState = States.Inactive; BokuGame.objectListDirty = true; GamePadInput.ClearAllWasPressedState(); Foley.StopMenuLoop(); // Exiting, restart the main menu. BokuGame.bokuGame.mainMenu.Activate(); } } // end of HelpScreens Deactivate()
public void Deactivate() { if (active) { grid0.Active = false; grid1.Active = false; grid2.Active = false; grid3.Active = false; grid0.RenderWhenInactive = false; grid1.RenderWhenInactive = false; grid2.RenderWhenInactive = false; grid3.RenderWhenInactive = false; // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. CommandStack.Pop(commandMap); active = false; } }
} // end of Activate public void Deactivate() { if (state != States.Inactive) { // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. CommandStack.Pop(commandMap); state = States.Inactive; HelpOverlay.Pop(); // Turn off thumbnail rendering if needed. if (!prevRenderWorldAsThumbnail) { InGame.inGame.RenderWorldAsThumbnail = false; } Time.Paused = false; } }
public void Deactivate() { if (active) { if (activeTool != null) { activeTool.Active = false; } // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. CommandStack.Pop(commandMap); active = false; } // Ensure that all of the pickers have been deactivated. brushPicker.Hidden = true; materialPicker.Hidden = true; waterPicker.Hidden = true; }
} // end of Activate override public void Deactivate() { if (state != States.Inactive) { // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. CommandStack.Pop(commandMap); state = States.Inactive; if (shared.examplesGrid != null) { shared.examplesGrid.Active = false; } InGame.inGame.RenderWorldAsThumbnail = false; HelpOverlay.Pop(); Instrumentation.StopTimer(timerInstrument); } }
} // end of VideoOutput Activate() override public void Deactivate() { if (state != States.Inactive) { // Release file list. shared.filenames = null; shared.curFileIndex = 0; // Release the memeory buffer. shared.data = null; BokuGame.Release(ref shared.texture); shared.colors = null; // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. CommandStack.Pop(commandMap); pendingState = States.Inactive; BokuGame.objectListDirty = true; } } // end of VideoOutput Deactivate()
//TODO: Update method's signature public void Undo(CharacterObservable caller, CharacterObservable active) { if (!Equals(caller, active)) { throw new Exception("Cannot Undo on non-active character"); } PreviousAction = (ICharacterActionCommand)CommandStack.Pop(); if (PreviousAction is AttackCommand && LastCharacterAttacked != null) { var attackStrenght = caller.Stats.GetAttackStrenght(caller, LastCharacterAttacked); LastCharacterAttacked.Health.RaiseHealth(caller); LastCharacterAttacked.healthWasRaised = true; LastCharacterAttacked.Notify(); LastCharacterAttacked.healthWasRaised = false; ((AttackCommand)PreviousAction).IsExecuted = false; return; } if (PreviousAction is DefendCommand) { caller.Stats.DefenseBonusActivated = false; caller.Stats.ResetTemporaryBonus(); ((DefendCommand)PreviousAction).IsExecuted = false; return; } //Implementation to come if (PreviousAction is MoveCommand) { //caller.CurrentCoordinates = caller.OldCoordinates; //((MoveCommand)PreviousAction).Execute(caller.CurrentCoordinates); //((MoveCommand)PreviousAction).IsExecuted = false; } if (PreviousAction is RotateCommand) { } }
override public void Deactivate() { if (state != States.Inactive && pendingState != States.Inactive) { // Do stack handling here. If we do it in the update object we have no // clue which order things get pushed and popped and madness ensues. CommandStack.Pop(commandMap); HelpOverlay.Pop(); shared.menu.Active = false; pendingState = States.Inactive; BokuGame.objectListDirty = true; InGame.inGame.RenderWorldAsThumbnail = false; Instrumentation.StopTimer(timerInstrument); Foley.StopMenuLoop(); Time.Paused = false; AuthUI.HideAllDialogs(); } }