public UniversalDetector(int languageFilter) {
this.start = true;
this.inputState = InputState.PureASCII;
this.lastChar = 0x00;
this.bestGuess = -1;
this.languageFilter = languageFilter;
}
/// <summary>
/// Allows the game component to update itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
public override void Update(GameTime gameTime)
{
if (!Game.IsActive)
return;
input = new InputState();
WiimoteLib.PointF ws = wm.WiimoteState.IRState.Midpoint;
input.Position.X = GameEngine.WIDTH * (1 - ws.X);
input.Position.Y = GameEngine.HEIGHT * ws.Y;
float time = gameTime.ElapsedGameTime.Milliseconds; // time elapsed since last update
Vector2 posDiff = input.Position - buffer.CurrentPosition;
input.Velocity = posDiff / time;
WiimoteLib.Point3F acc = wm.WiimoteState.AccelState.Values;
input.Acceleration = new Vector2(acc.X, acc.Y);
input.Pause = wm.WiimoteState.ButtonState.Home;
input.Confirm = wm.WiimoteState.ButtonState.A;
if (ws.X == 0.0f && ws.Y == 0.0f) // sensor bar out of range
{
input.Position = lastPosition;
posDiff = new Vector2();
}
else
{
lastPosition = input.Position;
}
if (Math.Abs(posDiff.X) > POS_DIFF_THRESHOLD || Math.Abs(posDiff.Y) > POS_DIFF_THRESHOLD) // add only only if the baton has moved at least a decent amount of distance
{
buffer.Add(input);
}
base.Update(gameTime);
}
void Awake()
{
input = serverinput.GetValue(GetComponent<BasePlayer>()) as InputState;
player = GetComponent<BasePlayer>();
enabled = true;
ispressed = false;
}
protected override bool OnHover(InputState state)
{
icon.ClearTransformations();
ResizeTo(size_extended, transform_time, EasingTypes.OutElastic);
int duration = 0; //(int)(Game.Audio.BeatLength / 2);
if (duration == 0) duration = pulse_length;
double offset = 0; //(1 - Game.Audio.SyncBeatProgress) * duration;
double startTime = Time.Current + offset;
// basic pulse
icon.Transforms.Add(new TransformScale
{
StartValue = new Vector2(1.1f),
EndValue = Vector2.One,
StartTime = startTime,
EndTime = startTime + duration,
Easing = EasingTypes.Out,
LoopCount = -1,
LoopDelay = duration
});
return true;
}
void Start () {
//body2D = GetComponent<Rigidbody2D> ();
player = gameObject.GetComponent<Transform> ();
player.position = setPosition ((int)Positions.TOP);
inputState = GetComponent<InputState>();
}
public RunnerStatsMessage(RunnerState currentState, Vector3 velocity, CollisionInfo contacts, InputState currentInput)
{
CurrentState = currentState;
Velocity = velocity;
Contacts = contacts;
CurrentInput = currentInput;
}
/// <summary>
/// This is how we hook keyboard/other input.
/// </summary>
/// <param name="input"></param>
/// <param name="allowFull"></param>
/// <returns></returns>
public override bool UpdatePlayerActionInput(InputState input, bool allowFull)
{
// this is a simple, hard coded example to handle input from a player
// we can probably add some kind of modifier key here for doing something else cool
if (input.IsKeyReleased(Keys.OemPlus))
{
bool canAutoTarget = false;
bool canTargetSpace = false;
bool isAutoTarget;
bool isTargetBlocked;
// find something to kill
ITarget targetHere = this._world.Cursor.GetTargetHere(canAutoTarget, canTargetSpace, out isAutoTarget, out isTargetBlocked);
if (null != targetHere)
{
// output some data to the debug log
DebugLog.Write("Terminating target: {0}", targetHere.DisplayName);
// kill it
Damage.ApplyDamage(targetHere, targetHere.Health);
}
}
return base.UpdatePlayerActionInput(input, allowFull);
}
public override void HandleInput(GameTime gameTime, InputState input)
{
if (nameMenuEntry.IsSelected)
nameMenuEntry.HandleInput(gameTime,input);
base.HandleInput(gameTime,input);
}
public DirectionalIndicator(
ContentUtil content,
InputState.Move move,
float beatTimeInMs,
float travelSpeed)
{
this.recordings = new List<RecordedStart>();
this.color = Color.White;
this.move = move;
this.beatTimeInMs = beatTimeInMs;
this.travelSpeed = travelSpeed;
String texName = "hud/arrow_" + move.ToString().ToLower();
this.texture = new ScaledTexture(
content.load<Texture2D>(texName), TEXTURE_SCALE);
switch (move) {
case InputState.Move.UP:
this.direction = new Vector2(0, 1);
break;
case InputState.Move.DOWN:
this.direction = new Vector2(0, -1);
break;
case InputState.Move.LEFT:
this.direction = new Vector2(1, 0);
break;
case InputState.Move.RIGHT:
this.direction = new Vector2(-1, 0);
break;
}
this.isMoving = false;
}
public override void HandleInput(InputState inputState)
{
base.HandleInput(inputState);
this.mConfirmationDialogComponent.HandleInput(inputState);
this.mButtonMenuComponent.HandleInput(inputState);
}
//Oxide Hook
void OnPlayerInput(BasePlayer player, InputState input)
{
if (this.allowAdminRotate && player.IsAdmin() && player.GetActiveItem() != null && player.GetActiveItem().info.shortname.Equals("hammer"))
{
if (input.WasJustPressed(BUTTON.FIRE_PRIMARY))
{
RaycastHit hit;
if (Physics.Raycast(player.eyes.position, (player.eyes.rotation * Vector3.forward), out hit, 2f, Layers.Server.Buildings))
{
BaseEntity baseEntity = hit.collider.gameObject.ToBaseEntity();
if (baseEntity != null)
{
BuildingBlock block = baseEntity.GetComponent<BuildingBlock>();
if (block != null && block.blockDefinition.canRotate && !this.instanceIDs.Contains(block.GetInstanceID()))
{
block.SetFlag(BaseEntity.Flags.Reserved1, true);
addBlockToLists(block.GetInstanceID(), DateTime.Now.AddMinutes(-this.amountOfMinutesAfterUpgrade).ToString());
int remainingSeconds = timerInterval - DateTime.Now.Subtract(lastTimerTick).Seconds;
SendReply(player, "<color=green>You can now rotate this " + block.blockDefinition.info.name.english + " for " + remainingSeconds + " seconds.</color>");
}
}
}
}
}
}
protected virtual void Awake()
{
inputState = GetComponent<InputState> ();
body2d = GetComponent<Rigidbody2D> ();
collisionState = GetComponent<CollisionState> ();
spriteRenderer = GetComponent<SpriteRenderer> ();
}
void UpdateEmpty()
{
var chrono = FindObjectOfType<Chrono>();
var disco = FindObjectOfType<Disco>();
var collider = GetComponent<SphereCollider>();
var ray = Camera.main.ScreenPointToRay(Input.mousePosition);
var info = new RaycastHit();
var hit = Physics.Raycast(ray, out info);
if (!hit)
return;
var obj = info.collider.gameObject;
if (!obj)
return;
if (obj.CompareTag("Bouncer"))
{
hover_object = obj;
hover_object.GetComponent<Renderer>().material.color = Color.green;
state = InputState.Hover;
return;
}
if (obj.CompareTag("Palette"))
{
hover_object = obj;
hover_object.GetComponent<Renderer>().material.color = Color.green;
state = InputState.Hover;
return;
}
}
private void HandleInput(UserInput button, InputState state)
{
if (button == UserInput.A && state == InputState.Ingame)
{
m_Jump = true;
}
}
protected override void HandleInput(UserInput button, InputState state)
{
//First we need to define if we are inside the ingame screen
if (state == InputState.Ingame)
{
//If the pressed button equals Start we open the menu screen and disable ingame input
if (button == UserInput.Start)
{
StopAllCoroutines();
StartCoroutine(OpenPauseMenu());
}
}
//If we are not then maybe we are inside the menus screen?
else if (state == InputState.PauseMenu)
{
switch (button)
{
case UserInput.Start:
StopAllCoroutines();
StartCoroutine(ClosePauseMenu());
break;
case UserInput.Up:
Up();
break;
case UserInput.Down:
Down();
break;
case UserInput.A:
selectedButton.Invoke();
break;
}
}
}
protected override void ProcessKey(ConsoleKeyInfo consoleKey, InputState inputState)
{
switch(consoleKey.Key)
{
case ConsoleKey.End:
if(inputState.CarrageIndex < inputState.Line.Length)
{
inputState.GotoEnd();
}
break;
case ConsoleKey.Home:
if(inputState.CarrageIndex > 0)
{
inputState.GotoBegin();
}
break;
case ConsoleKey.LeftArrow:
if(inputState.CarrageIndex > 0)
{
inputState.CarrageIndex--;
Console.Write('\b');
}
break;
case ConsoleKey.RightArrow:
if(inputState.CarrageIndex < inputState.Line.Length)
{
Console.Write(inputState.Line.ToString().Substring(inputState.CarrageIndex, 1));
inputState.CarrageIndex++;
}
break;
default:
base.ProcessKey(consoleKey, inputState);
return;
}
}
protected override void ProcessKey(ConsoleKeyInfo consoleKey, InputState inputState)
{
switch(consoleKey.Key)
{
case ConsoleKey.Backspace:
if(inputState.CarrageIndex > 0)
{
inputState.Line.Remove(inputState.CarrageIndex - 1, 1);
inputState.CarrageIndex--;
Console.Write("\b");
inputState.RefreshTail(1);
}
break;
case ConsoleKey.Delete:
if(inputState.CarrageIndex < inputState.Line.Length)
{
inputState.Line.Remove(inputState.CarrageIndex, 1);
inputState.RefreshTail(1);
}
break;
default:
base.ProcessKey(consoleKey, inputState);
break;
}
}
/// <summary>
/// Responds to user input, changing the selected entry and accepting
/// or cancelling the menu.
/// </summary>
public override void HandleInput( InputState input )
{
// Move to the previous menu entry?
if ( input.MenuUp )
{
_selectedEntry--;
if ( _selectedEntry < 0 )
_selectedEntry = _menuEntries.Count - 1;
// AudioManager.PlaySound( "menu_scroll" );
}
// Move to the next menu entry?
if ( input.MenuDown )
{
_selectedEntry++;
if ( _selectedEntry >= _menuEntries.Count )
_selectedEntry = 0;
// AudioManager.PlaySound( "menu_scroll" );
}
// Accept or cancel the menu?
if ( input.MenuSelect )
{
// AudioManager.PlaySound( "menu_select" );
OnSelectEntry( _selectedEntry );
}
else if ( input.MenuCancel )
{
OnCancel();
}
}
/// <summary>
/// Lets the game respond to player input. Unlike the Update method,
/// this will only be called when the gameplay screen is active.
/// </summary>
public override void HandleInput(InputState input)
{
if (input == null)
{
return;
}
// Look up inputs for the active player profile.
if (ControllingPlayer == null)
{
Debug.WriteLine("ControllingPlayer is null...");
return;
}
var playerIndex = (int)ControllingPlayer.Value;
var keyboardState = input.CurrentKeyboardStates[playerIndex];
var gamePadState = input.CurrentGamePadStates[playerIndex];
// The game pauses either if the user presses the pause button, or if
// they unplug the active gamepad. This requires us to keep track of
// whether a gamepad was ever plugged in, because we don't want to pause
// on PC if they are playing with a keyboard and have no gamepad at all!
var gamePadDisconnected = !gamePadState.IsConnected &&
input.GamePadWasConnected[playerIndex];
if (input.IsPauseGame(ControllingPlayer) || gamePadDisconnected)
{
const string message = "Pause. Do you really want to exit game?";
var confirmExit = new DecisionScreen(message);
confirmExit.Accepted += ConfirmExitGameAccepted;
ScreenManager.AddScreen(confirmExit, ControllingPlayer);
}
}
public override void Update(GameTime gameTime)
{
// TODO: move this to better location
if (input.Pause && !lastState.Pause)
{
switch (gameState.CurrentScreen)
{
case DataTypes.Screens.Title:
break;
case DataTypes.Screens.SelectLevel:
gameState.CurrentScreen = DataTypes.Screens.Title;
break;
case DataTypes.Screens.WorldMap:
gameState.CurrentScreen = DataTypes.Screens.Title;
break;
case DataTypes.Screens.Pause:
gameState.CurrentScreen = gameState.PreviousScreen;
break;
default:
gameState.CurrentScreen = DataTypes.Screens.Pause;
break;
}
}
lastState = input;
gameState.Input = input;
base.Update(gameTime);
}
public override void HandleInput(GameTime gameTime, InputState input)
{
if (_saveNameEntry.IsSelected)
_saveNameEntry.HandleInput(gameTime, input);
base.HandleInput(gameTime, input);
}
public override void HandleInput(GameTime gameTime, InputState input)
{
if (_activeMenuEntry!=null)
_activeMenuEntry.HandleInput(gameTime,input);
else
base.HandleInput(gameTime, input);
}
/// <summary>
/// The same as Update() except only active screens get called.
/// </summary>
/// <param name="gameTime">Current GameTime</param>
/// <param name="input">Input Object to access Mouse and Keyboard</param>
public override void HandleInput(GameTime gameTime, InputState input)
{
foreach (IGuiItem menuEntry in MenuEntries)
{
menuEntry.HandleInput(input);
}
}
/// <summary>
/// Gets the current InputState.
/// </summary>
/// <param name="touch">The current touch.</param>
/// <param name="state">The state to check against.</param>
/// <returns>True if the InputState matches the current input</returns>
/// <exception cref="System.ArgumentOutOfRangeException">touch;null</exception>
public static bool GetState(Touch touch, InputState state)
{
#if UNITY_EDITOR
switch (state)
{
case InputState.Began:
return Input.GetMouseButtonDown(0);
case InputState.Moving:
return Input.GetMouseButton(0);
case InputState.Ended:
return Input.GetMouseButtonUp(0);
case InputState.Canceled:
return false;
default:
throw new ArgumentOutOfRangeException("touch", state, null);
}
#else
switch (state)
{
case InputState.Began:
return touch.phase == TouchPhase.Began;
case InputState.Moving:
return touch.phase == TouchPhase.Moved;
case InputState.Ended:
return touch.phase == TouchPhase.Ended;
case InputState.Canceled:
return touch.phase == TouchPhase.Canceled;
default:
throw new ArgumentOutOfRangeException("touchPhase", state, null);
}
#endif //UNITY_EDITOR
}
public override void HandleInput(GameTime gameTime, InputState input)
{
if (input == null)
throw new ArgumentNullException("input");
GamePadState gamePadState = input.CurrentGamePadState;
if (pauseAction.Evaluate(input))
{
ScreenManager.AddScreen(new PauseScreen());
}
else
{
Vector2 movement = Vector2.Zero;
if (input.touchState.Count > 0)
{
Vector2 touchPosition = input.touchState[0].Position;
Vector2 direction = touchPosition - playerPosition;
direction.Normalize();
movement += direction;
}
if (movement.Length() > 1)
movement.Normalize();
playerPosition += movement * 8f;
}
}
/// <summary>
/// Evaluates the action against a given InputState.
/// </summary>
/// <param name="state">The InputState to test for the action.</param>
/// <param name="controllingPlayer">The player to test, or null to allow any player.</param>
/// <param name="player">If controllingPlayer is null, this is the player that performed the action.</param>
/// <returns>True if the action occurred, false otherwise.</returns>
public bool Evaluate(InputState state, PlayerIndex? controllingPlayer, out PlayerIndex player)
{
// Figure out which delegate methods to map from the state which takes care of our "newPressOnly" logic
ButtonPress buttonTest;
KeyPress keyTest;
if (newPressOnly)
{
buttonTest = state.IsNewButtonPress;
keyTest = state.IsNewKeyPress;
}
else
{
buttonTest = state.IsButtonPressed;
keyTest = state.IsKeyPressed;
}
// Now we simply need to invoke the appropriate methods for each button and key in our collections
foreach (Buttons button in buttons)
{
if (buttonTest(button, controllingPlayer, out player))
return true;
}
foreach (Keys key in keys)
{
if (keyTest(key, controllingPlayer, out player))
return true;
}
// If we got here, the action is not matched
player = PlayerIndex.One;
return false;
}
void HandleLeftMoveRightAttack(InputState state,Vector3 acc)
{
var player = MyPlayerController.Instance;
Vector3 weapon = new Vector3(Mathf.Clamp(EulerAsin(-acc.z), -45f, 30f), 0, 0); // 視線
const float DUMP = 0.4f; // 減衰
if(state == InputState.NONE)
{
player.ActAttackEnd();
if (acc.x > 0) player.TurnRight(acc.x); else player.TurnLeft(-acc.x);
}
else if(state == InputState.MOVE)
{
player.ActAttackEnd();
if (acc.z < 0) player.MoveForward(-acc.z); else player.MoveBack(acc.z);
if (acc.x > 0) player.MoveRight(acc.x); else player.MoveLeft(-acc.x);
weapon = Vector3.zero;
}
else if(state == InputState.ATTACK)
{
player.ActAttackStart();
if (acc.x > 0) player.TurnRight(acc.x); else player.TurnLeft(-acc.x);
}
else if(state == InputState.ATTACK_AND_MOVE)
{
player.ActAttackStart();
if (acc.x > 0) player.TurnRight(acc.x * DUMP); else player.TurnLeft(-acc.x * DUMP);
if (acc.x > 0) player.MoveRight(acc.x * DUMP); else player.MoveLeft(-acc.x * DUMP);
if (acc.z < 0) player.MoveForward(-acc.z * DUMP); else player.MoveBack(acc.z * DUMP);
}
// 視線
_BufferWeaponAngle = _BufferWeaponAngle * 0.9f + weapon * 0.1f;
player.WeaponAngle = _BufferWeaponAngle;
}
void Awake () {
inputState = GetComponent<InputState> ();
walkBehaviour = GetComponent<Walk> ();
duckBehaviour = GetComponent<Duck> ();
animator = GetComponent<Animator> ();
collisionState = GetComponent<CollisionState> ();
}
public override void HandleInput(GameTime gameTime, InputState inputState)
{
base.HandleInput(gameTime, inputState);
if (increaseCountAction.Evaluate(inputState))
{
switch (SelectedMenuItemIndex)
{
case 0:
verticalNodeCount = verticalNodeCount + 1 > verticalMax ? verticalMax : verticalNodeCount + 1;
MenuItems[0].Text = String.Format("Vertical Nodes: {0}", verticalNodeCount);
break;
case 1:
horizontalNodeCount = horizontalNodeCount + 1 > horizontalMax ? horizontalMax : horizontalNodeCount + 1;
MenuItems[1].Text = String.Format("Horizontal Nodes: {0}", horizontalNodeCount);
break;
}
}
if (decreaseCountAction.Evaluate(inputState))
{
switch (SelectedMenuItemIndex)
{
case 0:
verticalNodeCount = verticalNodeCount - 1 < verticalMin ? verticalMin : verticalNodeCount - 1;
MenuItems[0].Text = String.Format("Vertical Nodes: {0}", verticalNodeCount);
break;
case 1:
horizontalNodeCount = horizontalNodeCount - 1 < horizontalMin ? horizontalMin : horizontalNodeCount - 1;
MenuItems[1].Text = String.Format("Horizontal Nodes: {0}", horizontalNodeCount);
break;
}
}
}
public override void DoResize(DiagramView view, RectangleF origRect, PointF newPoint, int whichHandle, InputState evttype, SizeF min, SizeF max)
{
INodeIconConstraint constraint1 = this.Constraint;
SizeF ef1 = constraint1.MinimumIconSize;
SizeF ef2 = constraint1.MaximumIconSize;
base.DoResize(view, origRect, newPoint, whichHandle, evttype, ef1, ef2);
}
protected override void OnProgress(TElement element, float progress, InputState istate)
{
//
}
protected override void OnHoverLost(InputState state)
{
updateHoverState();
base.OnHoverLost(state);
}
public void HandleInput(InputState input)
{
Temp_updateCount++;
ButtonState currentMouseState = new ButtonState();
ButtonState previousMouseState = new ButtonState();;
if (input.CurrentMouseState.MiddleButton == ButtonState.Pressed)
{
currentMouseState = input.CurrentMouseState.MiddleButton;
previousMouseState = input.PreviousMouseState.MiddleButton;
}
else if (input.CurrentMouseState.RightButton == ButtonState.Pressed)
{
currentMouseState = input.CurrentMouseState.RightButton;
previousMouseState = input.PreviousMouseState.RightButton;
}
if (currentMouseState == ButtonState.Pressed)
{
ScreenManager.GetInstance().Game.IsMouseVisible = false;
//Only record position on click
if (previousMouseState == ButtonState.Released)
{
TEMP_mouseClickPosition = new Vector2(input.CurrentMouseState.X, input.CurrentMouseState.Y);
}
TEMP_mouseDelta = input.CurrentMouseState.X - TEMP_mouseClickPosition.X;
DebugScreen.GetInstance().SetDebugListing("Mouse Delta:", "" + TEMP_mouseDelta);
RotateCamera(TEMP_mouseDelta);
if (input.CurrentMouseState.RightButton == ButtonState.Pressed)
{
if (targetObject != null && targetObject is TEMPPlayerActor)
{
(targetObject as TEMPPlayerActor).Rotation = new Vector3((targetObject as TEMPPlayerActor).Rotation.X, -rotationRadians, (targetObject as TEMPPlayerActor).Rotation.Z);
}
}
//NOTE: Resetting this position is causing camera rotation to be jerky
//Don't reset every tick
//TEMPORARY SOLUTION - need proper way to make mouse rotation smooth
if (Temp_updateCount % 5 == 0)
{
Mouse.SetPosition((int)TEMP_mouseClickPosition.X, (int)TEMP_mouseClickPosition.Y);
}
}
else
{
ScreenManager.GetInstance().Game.IsMouseVisible = true;
}
bool trackingObject = false;
if (targetObject != null)
{
/* if (input.CurrentKeyboardState.IsKeyDown(Keys.LeftControl) || isSoftLocked)
* {
* trackingObject = true;
* }*/
}
else
{
trackingObject = true;
}
if (trackingObject)
{
Vector3 positiveCameraDirection = cameraTarget - CameraPosition;
Vector3 cameraMove = Vector3.Zero;
isCameraControllable = true;
//if (input.CurrentKeyboardState.IsKeyDown(Keys.W))
//{
// cameraMove.X -= cameraMoveSpeed;
// if (isSoftLocked)
// {
// targetObject = null;
// isSoftLocked = false;
// }
//}
//if (input.CurrentKeyboardState.IsKeyDown(Keys.D))
//{
// cameraMove.Z -= cameraMoveSpeed;
// if (isSoftLocked)
// {
// targetObject = null;
// isSoftLocked = false;
// }
//}
//if (input.CurrentKeyboardState.IsKeyDown(Keys.S))
//{
// cameraMove.X += cameraMoveSpeed;
// if (isSoftLocked)
// {
// targetObject = null;
// isSoftLocked = false;
// }
//}
//if (input.CurrentKeyboardState.IsKeyDown(Keys.A))
//{
// cameraMove.Z += cameraMoveSpeed;
// if (isSoftLocked)
// {
// targetObject = null;
// isSoftLocked = false;
// }
//}
//if (input.CurrentKeyboardState.IsKeyDown(Keys.Space)/* && input.PreviousKeyboardState.IsKeyUp(Keys.Space)*/)
//{
// if (TEMP_velJump == 0)
// {
// TEMP_velJump = 0.5f;
// }
//}
//cameraTarget.Y += TEMP_velJump;
//TEMP_velJump -= (9.8f / 200);
//if (cameraTarget.Y < 0)
//{
// cameraTarget.Y = 0;
// TEMP_velJump = 0;
//}
//Matrix rotationMatrix = Matrix.CreateRotationY(-rotationRadians);
//Vector3 transformedReference = Vector3.Transform(cameraMove, rotationMatrix);
//cameraTarget += transformedReference;
}
else
{
isCameraControllable = false;
}
float scrollWheelChange = 0;
if (input != null)
{
scrollWheelChange = input.PreviousMouseState.ScrollWheelValue - input.CurrentMouseState.ScrollWheelValue;
}
if (scrollWheelChange < 0 || (input.CurrentKeyboardState.IsKeyDown(Keys.Add) && input.PreviousKeyboardState.IsKeyUp(Keys.Add)))
{
ZoomCameraIn();
}
else if (scrollWheelChange > 0 || (input.CurrentKeyboardState.IsKeyDown(Keys.Subtract) && input.PreviousKeyboardState.IsKeyUp(Keys.Subtract)))
{
ZoomCameraOut();
}
if (Temp_updateCount % 60 == 0)
{
Temp_updateCount = 0;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MouseButtonEventArgs"/> class.
/// </summary>
/// <param name="position">Cursor position.</param>
/// <param name="positionNorm">Normalized position.</param>
/// <param name="button">Active buttons.</param>
/// <param name="state">Key and button actions.</param>
/// <param name="mods">Modifier flags.</param>
public MouseButtonEventArgs(Vector2 position, Vector2 positionNorm, MouseButton button, InputState state, KeyMods mods)
{
Position = position;
PositionNorm = positionNorm;
Button = button;
State = state;
Mods = mods;
}
protected override void OnHoverLost(InputState state)
{
FadeEdgeEffectTo(0, transition_time, Easing.OutQuint);
base.OnHoverLost(state);
}
protected override bool OnHover(InputState state)
{
FadeEdgeEffectTo(1, transition_time, Easing.OutQuint);
return(base.OnHover(state));
}
public DragEndEvent(InputState state, MouseButton button, Vector2?screenSpaceMouseDownPosition = null)
: base(state, button, screenSpaceMouseDownPosition)
{
}
protected override void OnHoverLost(InputState state)
{
contract();
base.OnHoverLost(state);
}
protected override bool OnHover(InputState state)
{
expand();
return(base.OnHover(state));
}
private void DrawSetupPhoton()
{
this.DrawInputWithLabel("Photon Cloud Setup", () =>
{
GUILayout.BeginVertical();
GUILayout.Space(5);
GUILayout.Label(WizardText.PHOTON, this.textLabelStyle);
GUILayout.EndVertical();
GUILayout.Space(5);
GUILayout.BeginHorizontal();
GUILayout.Label(WizardText.PHOTON_DASH, this.textLabelStyle);
if (GUILayout.Button("Visit Dashboard", this.minimalButtonStyle))
{
string mail = (this.inputState == InputState.Email) ? appIdOrEmail : string.Empty;
this.OpenURL(EditorIntegration.UrlCloudDashboard + mail)();
}
GUILayout.EndHorizontal();
}, false);
GUILayout.Space(15);
this.DrawInputWithLabel("Photon AppID or Email", () =>
{
GUILayout.BeginVertical();
appIdOrEmail = EditorGUILayout.TextField(appIdOrEmail, this.centerInputTextStyle).Trim(); // trimming all input in/of this field
GUILayout.EndVertical();
}, false, true, 300);
// input state check to show dependent info / buttons
if (AccountService.IsValidEmail(appIdOrEmail))
{
this.inputState = InputState.Email;
}
else
{
this.inputState = AppSettings.IsAppId(appIdOrEmail) ? InputState.Appid : InputState.NotFinished;
}
// button to skip setup
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
if (GUILayout.Button("Skip", GUILayout.Width(100)))
{
this.requestHighlighSettings = true;
this.setupState = SetupState.Skip;
}
// SETUP button
EditorGUI.BeginDisabledGroup(this.inputState == InputState.NotFinished || requestingAppId);
if (GUILayout.Button("Setup", GUILayout.Width(100)))
{
this.requestHighlighSettings = true;
GUIUtility.keyboardControl = 0;
if (this.inputState == InputState.Email && !requestingAppId)
{
requestingAppId = new AccountService().RegisterByEmail(appIdOrEmail, new List <ServiceTypes>()
{
ServiceTypes.Realtime
}, SuccessCallback, ErrorCallback, this.originAssetVersion);
if (requestingAppId)
{
EditorUtility.DisplayProgressBar(WizardText.CONNECTION_TITLE, WizardText.CONNECTION_INFO, 0.5f);
this.setupState = SetupState.SendingEmail;
}
}
else if (this.inputState == InputState.Appid)
{
this.setupState = SetupState.AppIdApplied;
// Save App ID
AppSettingsInstance.AppIdRealtime = appIdOrEmail;
}
}
EditorGUI.EndDisabledGroup();
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
GUILayout.Space(10);
switch (this.setupState)
{
case SetupState.RegisteredSuccessful:
GUILayout.Label(WizardText.RegisteredNewAccountInfo, this.textLabelStyle);
GUILayout.Label(WizardText.SetupCompleteInfo, this.textLabelStyle);
this.HighlightSettings();
break;
case SetupState.AppIdApplied:
GUILayout.Label(WizardText.AppliedToSettingsInfo, this.textLabelStyle);
GUILayout.Label(WizardText.SetupCompleteInfo, this.textLabelStyle);
this.HighlightSettings();
break;
case SetupState.AlreadyRegistered:
GUILayout.Label(WizardText.AlreadyRegisteredInfo, this.textLabelStyle);
this.HighlightSettings();
break;
case SetupState.RegistrationError:
GUILayout.Label(WizardText.RegistrationError, this.textLabelStyle);
this.HighlightSettings();
break;
case SetupState.Skip:
GUILayout.Label(WizardText.SkipRegistrationInfo, this.textLabelStyle);
this.HighlightSettings();
break;
}
}
protected virtual void OnExclusiveDown(InputState istate) /* OVERRIDE ME */ }
protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
{
if (!HasFocus)
{
return(false);
}
if (textInput?.ImeActive == true)
{
return(true);
}
switch (args.Key)
{
case Key.Tab:
return(false);
case Key.End:
moveSelection(InternalText.Length, state.Keyboard.ShiftPressed);
return(true);
case Key.Home:
moveSelection(-InternalText.Length, state.Keyboard.ShiftPressed);
return(true);
case Key.Left:
{
if (!HandleLeftRightArrows)
{
return(false);
}
if (selectionEnd == 0)
{
//we only clear if you aren't holding shift
if (!state.Keyboard.ShiftPressed)
{
resetSelection();
}
return(true);
}
int amount = 1;
if (state.Keyboard.ControlPressed)
{
int lastSpace = InternalText.LastIndexOf(' ', Math.Max(0, selectionEnd - 2));
if (lastSpace >= 0)
{
//if you have something selected and shift is not held down
//A selection reset is required to select a word inside the current selection
if (!state.Keyboard.ShiftPressed)
{
resetSelection();
}
amount = selectionEnd - lastSpace - 1;
}
else
{
amount = selectionEnd;
}
}
moveSelection(-amount, state.Keyboard.ShiftPressed);
return(true);
}
case Key.Right:
{
if (!HandleLeftRightArrows)
{
return(false);
}
if (selectionEnd == InternalText.Length)
{
if (!state.Keyboard.ShiftPressed)
{
resetSelection();
}
return(true);
}
int amount = 1;
if (state.Keyboard.ControlPressed)
{
int nextSpace = InternalText.IndexOf(' ', selectionEnd + 1);
if (nextSpace >= 0)
{
if (!state.Keyboard.ShiftPressed)
{
resetSelection();
}
amount = nextSpace - selectionEnd;
}
else
{
amount = InternalText.Length - selectionEnd;
}
}
moveSelection(amount, state.Keyboard.ShiftPressed);
return(true);
}
case Key.Enter:
selectionStart = selectionEnd = 0;
TriggerFocusLost(state);
return(true);
case Key.Delete:
if (selectionLength == 0)
{
if (InternalText.Length == selectionStart)
{
return(true);
}
if (state.Keyboard.ControlPressed)
{
int spacePos = selectionStart;
while (InternalText[spacePos] == ' ' && spacePos < InternalText.Length)
{
spacePos++;
}
spacePos = MathHelper.Clamp(InternalText.IndexOf(' ', spacePos), 0, InternalText.Length);
selectionEnd = spacePos;
if (selectionStart == 0 && spacePos == 0)
{
selectionEnd = InternalText.Length;
}
if (selectionLength == 0)
{
return(true);
}
}
else
{
//we're deleting in front of the cursor, so move the cursor forward once first
selectionStart = selectionEnd = selectionStart + 1;
}
}
removeCharacterOrSelection();
return(true);
case Key.Back:
if (selectionLength == 0 && state.Keyboard.ControlPressed)
{
int spacePos = selectionLeft >= 2 ? Math.Max(0, InternalText.LastIndexOf(' ', selectionLeft - 2) + 1) : 0;
selectionStart = spacePos;
}
removeCharacterOrSelection();
return(true);
}
if (state.Keyboard.ControlPressed)
{
//handling of function keys
switch (args.Key)
{
case Key.A:
selectionStart = 0;
selectionEnd = InternalText.Length;
cursorAndLayout.Invalidate();
return(true);
case Key.C:
if (string.IsNullOrEmpty(SelectedText) || !AllowClipboardExport)
{
return(true);
}
//System.Windows.Forms.Clipboard.SetText(SelectedText);
return(true);
case Key.X:
if (string.IsNullOrEmpty(SelectedText))
{
return(true);
}
//if (AllowClipboardExport)
// System.Windows.Forms.Clipboard.SetText(SelectedText);
removeCharacterOrSelection();
return(true);
case Key.V:
//the text is pasted into the hidden textbox, so we don't need any direct clipboard interaction here.
insertString(textInput?.GetPendingText());
return(true);
}
return(false);
}
string str = textInput?.GetPendingText();
if (!string.IsNullOrEmpty(str))
{
if (state.Keyboard.ShiftPressed)
{
audio.Sample.Get(@"Keyboard/key-caps")?.Play();
}
else
{
audio.Sample.Get($@"Keyboard/key-press-{RNG.Next(1, 5)}")?.Play();
}
insertString(str);
}
return(true);
}
protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
{
doubleClickWord = null;
return(true);
}
public void Update(SAMTime gameTime, InputState istate)
{
if (istate.IsExclusiveJustDown && innerBoundings.Contains(istate.GamePointerPositionOnMap))
{
istate.Swallow(InputConsumer.GameEntity);
OnExclusiveDown(istate);
}
if (Fraction.KICycleWaitQueue.Any() && Owner.CannonMap[Fraction.KICycleWaitQueue.Peek()].Fraction != Fraction)
{
SAMLog.Warning("AFC::DirtyCycleQueue", $"Cycle Queue for {Fraction.Type} contains {Fraction.KICycleWaitQueue.Peek()} ({Owner.CannonMap[Fraction.KICycleWaitQueue.Peek()].Fraction.Type})");
Fraction.KICycleWaitQueue.Clear();
return;
}
bool queuePriority = false;
if (Fraction.KICycleWaitQueue.Any() && Fraction.KICycleWaitQueue.Peek() == Cannon.BlueprintCannonID)
{
Fraction.KICycleWaitQueue.Dequeue();
queuePriority = true;
}
timeUntilNextUpdate -= gameTime.ElapsedSeconds;
if (timeUntilNextUpdate <= 0)
{
if (onlySingleUpdate)
{
if (timeUntilNextUpdate < -KIController.MAX_UPDATE_TIME)
{
SAMLog.Warning("AFC::QTIMEOUT", $"Overriding SingleUpdate condition - Max wait time overstepped for cannon {Cannon.BlueprintCannonID}");
DoUpdate(gameTime, istate);
return; // F**k it, we have waited long enough, now it's our turn
}
if (Fraction.LastKiSingleCycle == MonoSAMGame.GameCycleCounter)
{
if (_isWaitingForQueue)
{
Fraction.KICycleWaitQueue.Enqueue(Cannon.BlueprintCannonID);
}
_isWaitingForQueue = true;
return; // We want - but someone else was first
}
if (Fraction.KICycleWaitQueue.Count == 0)
{
DoUpdate(gameTime, istate);
return; // We want and we don't have to wait
}
if (Fraction.KICycleWaitQueue.Count > 128)
{
SAMLog.Warning("AFC::QFULL", $"Fraction.KICycleWaitQueue is full for cannon {Cannon.BlueprintCannonID}");
return; // Queue is full - we delay our update
}
if (queuePriority)
{
DoUpdate(gameTime, istate);
return; // We want and its out turn
}
Fraction.KICycleWaitQueue.Enqueue(Cannon.BlueprintCannonID);
_isWaitingForQueue = true;
return; // We want - but someone else has priority
}
else
{
DoUpdate(gameTime, istate);
return;
}
}
}
protected override bool OnDragEnd(InputState state)
{
dragContainer.MoveTo(Vector2.Zero, 800, EasingTypes.OutElastic);
return(base.OnDragEnd(state));
}
protected override bool OnWheel(InputState state) => mouseWheelDisabled.Value && !pauseContainer.IsPaused;
protected override bool OnDragStart(InputState state) => true;
public DragEvent(InputState state, MouseButton button, Vector2?screenSpaceMousePosition = null, Vector2?screenSpaceLastMousePosition = null)
: base(state, button, screenSpaceMousePosition)
{
ScreenSpaceLastMousePosition = screenSpaceLastMousePosition ?? state.Mouse.Position;
}
/// <summary>
/// Handles input
/// </summary>
/// <param name="gameTime">the game's time</param>
/// <param name="input">the inputs</param>
public override void HandleInput(GameTime gameTime, InputState input)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
// Look up inputs for the active player profile.
int playerIndex = (int)ControllingPlayer.Value;
var keyboardState = input.CurrentKeyboardStates[playerIndex];
var gamePadState = input.CurrentGamePadStates[playerIndex];
// The game pauses either if the user presses the pause button, or if
// they unplug the active gamepad. This requires us to keep track of
// whether a gamepad was ever plugged in, because we don't want to pause
// on PC if they are playing with a keyboard and have no gamepad at all!
bool gamePadDisconnected = !gamePadState.IsConnected && input.GamePadWasConnected[playerIndex];
PlayerIndex player;
if (_pauseAction.Occurred(input, ControllingPlayer, out player) || gamePadDisconnected)
{
ScreenManager.AddScreen(new PauseMenuScreen(_game), ControllingPlayer);
}
else
{
// Otherwise move the player position.
var movement = Vector2.Zero;
if (keyboardState.IsKeyDown(Keys.Left))
{
movement.X--;
}
if (keyboardState.IsKeyDown(Keys.Right))
{
movement.X++;
}
if (keyboardState.IsKeyDown(Keys.Up))
{
movement.Y--;
}
if (keyboardState.IsKeyDown(Keys.Down))
{
movement.Y++;
}
var thumbstick = gamePadState.ThumbSticks.Left;
movement.X += thumbstick.X;
movement.Y -= thumbstick.Y;
if (movement.Length() > 1)
{
movement.Normalize();
}
_playerPosition += movement * 8f;
}
}
protected override void OnHoverLost(InputState state)
{
solidBackground.FadeTo(alpha_normal, transition_time, Easing.OutQuint);
gradientBackground.FadeOut(transition_time, Easing.OutQuint);
}
protected override void OnAfterUpdate(SAMTime gameTime, InputState state)
{
// NOP
}
protected override void OnProgress(Bullet entity, float progress, SAMTime gameTime, InputState istate)
{
entity.BulletExtraScale = progress;
}
protected new void OnNextUpdate()
{
base.OnNextUpdate();
InputState.Change(scroll, Vector2.zero);
}
protected override void OnPress(InputState istate)
{
MainGame.Inst.GDBridge.OpenURL(GDConstants.URL_BLACKFORESTBYTES);
}
protected override void OnPress(InputState istate)
{
MainGame.Inst.Profile.ColorblindMode = !MainGame.Inst.Profile.ColorblindMode;
MainGame.Inst.SaveProfile();
}
protected override bool OnHover(InputState state)
{
solidBackground.FadeTo(alpha_hovering, transition_time, Easing.OutQuint);
gradientBackground.FadeIn(transition_time, Easing.OutQuint);
return(true);
}
protected override void OnFocusLost(InputState state)
{
finalise();
base.OnFocusLost(state);
}
protected override bool OnHover(InputState state)
{
updateHoverState();
return(base.OnHover(state));
}
protected override bool OnClick(InputState state) => true;
protected override void OnPress(InputState istate)
{
MainGame.Inst.GDBridge.OpenURL(GDConstants.URL_REDDIT);
}
