void IInputEvent.ButtonEvent(int input, IGameManager igameManager)
{
if (input == 0)
{
nowNumber++;
}
else if (input == 1)
{
nowNumber--;
if (nowNumber < 0)
{
nowNumber = 0;
}
}
if (nowNumber < filePath.Length)
{
mauanlImage.sprite = Resources.Load("UserInterface/" + filePath[nowNumber], typeof(Sprite)) as Sprite;
}
else
{
igameManager.SetEnemyUnitsActive();
nextMenu = null;
MonoBehaviour.Destroy(canvas.gameObject);
}
}
protected override bool OnViewProcessInput(ref IInputEvent evt)
{
if (evt.Kind == E_EventKind.Key)
{
KeyEvent key = (KeyEvent)evt;
switch (key.Code)
{
case KeyCode.Tab:
if (key.State == E_KeyState.Pressed)
{
OnScorePressed(null);
}
else if (key.State == E_KeyState.Released)
{
OnScoreReleased(null);
}
return(true);
case KeyCode.Escape:
if (Client.Instance.GameState.State != Client.ClientGameState.Running && WaitingForSpawn == false)
{
OnCancel(null);
}
return(true);
default:
break;
}
}
return(base.OnViewProcessInput(ref evt));
}
private InputEventProcessResult MouseDownLockProc(object o, IInputEvent inputEvent)
{
if (!(inputEvent is IMouseEvent args))
{
return(InputEventProcessResult.DontCare);
}
if (args.IsOfType(MouseEventType.Move) && args.State.Buttons == MouseButtons.Left)
{
var placementSurface = cText.Node.PresentationInfra().Placement;
if (placementSurface == null)
{
return(InputEventProcessResult.StopPropagating);
}
var globalRay = args.Viewport.GetGlobalRayForPixelPos(args.State.Position);
if (!placementSurface.PlacementSurface2D.TryFindPoint2D(globalRay, out var point2D))
{
return(InputEventProcessResult.StopPropagating);
}
var cRect = cText.Node.GetComponent <IRectangleComponent>();
var rect = cRect.Rectangle;
var textBox = cText.TextBox;
var textBoxPointYswapped = (point2D - rect.MinMax) * textBox.PixelScaling;
var textBoxPoint = new Vector2(textBoxPointYswapped.X, -textBoxPointYswapped.Y);
var layout = textBox.Layout;
var newPos = layout.GetPosition(textBoxPoint);
HeadlessEditor.MoveCursor(newPos, true);
return(InputEventProcessResult.StopPropagating);
}
return(InputEventProcessResult.ReleaseLock);
}
public bool TryHandleInput(IInputEvent eventArgs)
{
if (!(eventArgs is IMouseEvent mouseArgs))
return false;
if (mouseArgs.ComplexEventType == MouseEventType.Move)
{
if (mouseArgs.State.Buttons == MouseButtons.Left)
{
var scale = 0.01f;
realProps.Yaw += scale * mouseArgs.Delta.X;
realProps.Pitch += scale * mouseArgs.Delta.Y;
realProps.Pitch = MathHelper.Clamp(realProps.Pitch, -MathHelper.PiOver2 + 1e-5f, MathHelper.PiOver2 - 1e-5f);
return true;
}
if (mouseArgs.State.Buttons == MouseButtons.Right)
{
var viewFrame = realProps.GetFrame();
var scale = 0.00115f * realProps.Distance;
var offset = -viewFrame.Right * scale * mouseArgs.Delta.X + viewFrame.Up * scale * mouseArgs.Delta.Y;
realProps.Target += offset;
return true;
}
}
else if (mouseArgs.ComplexEventType == MouseEventType.Wheel && mouseArgs.KeyModifiers == KeyModifiers.None)
{
var scale = 0.1f;
realProps.Distance *= (1f - scale * mouseArgs.WheelDelta);
return true;
}
return false;
}
// PRIVATE METHODS
bool ProcessMouse(ref IInputEvent evt)
{
MouseEvent mouse = (MouseEvent)evt;
GUIBase_Widget widget = HitTest(mouse.Position);
if (evt is MouseEvent)
{
ProcessMouseWheel(widget, (MouseEvent)evt);
}
if (m_HoverWidget != widget)
{
if (m_HoverWidget != null)
{
widget = m_HoverWidget;
m_HoverWidget = null;
return(HandleTouchEvent(widget, GUIBase_Widget.E_TouchPhase.E_TP_MOUSEOVER_END, evt, false));
}
if (m_HoverWidget == null)
{
m_HoverWidget = widget;
return(HandleTouchEvent(widget, GUIBase_Widget.E_TouchPhase.E_TP_MOUSEOVER_BEGIN, evt, true));
}
}
return(ProcessImpl(ref evt));
}
public bool Process(ref IInputEvent evt)
{
#if UNITY_EDITOR || MADFINGER_KEYBOARD_MOUSE
switch (evt.Kind)
{
case E_EventKind.Touch:
{
// If controls are set up by user, everything happens in ProcessKey
// Therefore mouse events can't be processed as Touch events
if (m_InputTable != null)
{
IInputEvent keyEvent = (IInputEvent)TouchEventToKeyEvent((TouchEvent)evt);
return(ProcessKey(ref keyEvent));
}
return(ProcessTouch(ref evt));
}
case E_EventKind.Key:
return(ProcessKey(ref evt));
default:
break;
}
#endif
return(false);
}
void IInputEvent.CreateCanvas(DataManager dataManager)
{
nextMenu = this;
GameObject canvasObject = new GameObject();
canvas = canvasObject.AddComponent <Canvas> ();
canvas.name = "ImageCanvas";
canvas.renderMode = RenderMode.ScreenSpaceOverlay;
TextAsset jsonAsset = Resources.Load("Data/ImageMenu", typeof(TextAsset)) as TextAsset;
JsonData jsonData = JsonMapper.ToObject(jsonAsset.text);
JsonData[] jsonArray = JsonMapper.ToObject <JsonData[]> (jsonData["labels"].ToJson());
foreach (JsonData array in jsonArray)
{
BaseLabel label = new BaseLabel();
label.Json = array;
label.CreateMenuItem(canvas);
}
GameObject imageObject = MonoBehaviour.Instantiate(canvas.transform.GetChild(0).gameObject) as GameObject;
imageObject.name = "Image";
imageObject.transform.SetParent(canvas.transform);
Image nameImage = imageObject.GetComponent <Image> ();
nameImage.sprite = Resources.Load("UserInterface/" + imageFile,
typeof(Sprite)) as Sprite;
}
public override InputHandledStatus HandleInput(IInputEvent input)
{
if (input is DashInput)
{
Finish();
return(InputHandledStatus.Permit);
}
if (!(input is CommandInput))
{
return(InputHandledStatus.Deny);
}
var buttonInput = ((CommandInput)input).button;
if (buttonInput.button_name != this.Command)
{
return(InputHandledStatus.Deny);
}
if (buttonInput.is_on() && !this.busy)
{
DoCharge();
}
return(InputHandledStatus.Handled);
}
internal void Process(IInputEvent evt)
{
//Debug.Log(GetType().Name + ".Process() :: event=" + evt);
foreach (var controller in m_Controllers)
{
if (controller.CaptureInput == false)
{
continue;
}
bool result = controller.Process(ref evt);
//TODO ... do some code here ...
if (controller.Opacity == E_InputOpacity.SemiTransparent && result == true)
{
break;
}
if (controller.Opacity == E_InputOpacity.Opaque)
{
break;
}
//TODO ... do some code here ...
}
}
protected override bool OnProcessInput(ref IInputEvent evt)
{
if (base.OnProcessInput(ref evt) == true)
{
return(true);
}
if (evt.Kind == E_EventKind.Touch)
{
TouchEvent touch = (TouchEvent)evt;
return(ForwardInputToRows(ref touch));
}
if (evt.Kind == E_EventKind.Mouse && m_ScrollingTable != null)
//when a scrollbar is present, it catches all of the mouse callbacks, so we have to simulate them
{
MouseEvent mouseEvent = (MouseEvent)evt;
foreach (Row row in m_Rows)
{
if (row.IsSelected && row.IsVisible)
{
mouseEvent.Position.y = Screen.height - mouseEvent.Position.y;
row.ProcessMouseMovement(mouseEvent);
break;
}
}
}
return(false);
}
public bool TryHandleInput(IInputEvent args)
{
if (!(args is IKeyEvent kargs))
{
return(false);
}
if (kargs.ComplexEventType == KeyEventType.Down && kargs.EventKey == Key.Escape)
{
appModeService.SetMode(AppMode.Editing);
return(true);
}
if (kargs.ComplexEventType == KeyEventType.Down && kargs.EventKey == Key.F)
{
var layoutInstance = storyService.RootLayoutInstance;
var cameraProps = mainLayer.Camera.GetProps();
if (!hasFreeCamera)
{
if (layoutInstance.AllowsFreeCamera)
{
mainLayer.Camera = layoutInstance.CreateFreeCamera(cameraProps);
hasFreeCamera = true;
hasWarpCamera = false;
return(true);
}
}
else
{
var closestNode = layoutInstance.GetClosestNodeId(cameraProps);
navigationService.GoToSpecific(closestNode);
FocusOn(storyService.GlobalGraph.NodeObjects[closestNode].GetComponent <IFocusNodeComponent>());
hasFreeCamera = false;
}
}
if (kargs.ComplexEventType == KeyEventType.Down && kargs.EventKey == Key.K)
{
var layoutInstance = storyService.RootLayoutInstance;
var cameraProps = mainLayer.Camera.GetProps();
if (!hasWarpCamera)
{
if (layoutInstance.AllowsFreeCamera)
{
mainLayer.Camera = layoutInstance.CreateWarpCamera(cameraProps);
hasWarpCamera = true;
hasFreeCamera = false;
return(true);
}
}
else
{
var closestNode = layoutInstance.GetClosestNodeId(cameraProps);
navigationService.GoToSpecific(closestNode);
FocusOn(storyService.GlobalGraph.NodeObjects[closestNode].GetComponent <IFocusNodeComponent>());
hasWarpCamera = false;
}
}
return(false);
}
public bool TryHandleInput(IInputEvent eventArgs)
{
if (eventArgs is IMouseEvent mouseArgs)
{
return(TryHandleMouse(mouseArgs));
}
return(false);
}
public InputEventProcessResult ProcessEvent(IInputEvent args)
{
if (args is IMouseEvent mouseArgs)
{
return(ProcessMouseEvent(mouseArgs));
}
return(InputEventProcessResult.DontCare);
}
public override bool GUIView_ProcessInput(ref IInputEvent evt)
{
if (base.GUIView_ProcessInput(ref evt) == true)
{
return(true);
}
return(m_View != null?m_View.ProcessInput(ref evt) : false);
}
public override InputHandledStatus HandleInput(IInputEvent input)
{
var animator = GetComponent <Animator>();
if (this.allowInterrupt && input is CommandInput ci && ci.button.is_press && ci.targetAbility == this)
{
this.ExecuteSlash();
return(InputHandledStatus.Handled);
}
public override InputHandledStatus HandleInput(IInputEvent input)
{
if (input is CommandInput ci && ci.targetAbility == this && ci.button.is_press && !busy)
{
DoCharge(ci.button.button_name);
return(InputHandledStatus.Handled);
}
return(InputHandledStatus.Deny);
}
public override bool GUIView_ProcessInput(ref IInputEvent evt)
{
if (m_View != null)
{
return(m_View.ProcessInput(ref evt));
}
return(false);
}
// INPUTCONTROLLER INTERFACE
protected override bool OnProcess(ref IInputEvent evt)
{
if (MFGuiFader.Fading == true)
{
return(false);
}
return(base.OnProcess(ref evt));
}
public override InputHandledStatus HandleInput(IInputEvent input)
{
if (input is CommandInput c && c.button.is_press && c.targetAbility == this && !busy)
{
StartCoroutine(RunFire());
return(InputHandledStatus.Handled);
}
return(InputHandledStatus.Deny);
}
public void SetBattleMenuEnable(bool flag)
{
BattleUI.battleMapCanvas.gameObject.SetActive(flag);
canvas.gameObject.SetActive(flag);
if (flag)
{
nextMenu = this;
}
}
protected override bool OnViewProcessInput(ref IInputEvent evt)
{
if (evt.Kind == E_EventKind.Key)
{
KeyEvent key = (KeyEvent)evt;
if (key.Code == KeyCode.Escape)
{
return(true);
}
}
return(base.OnViewProcessInput(ref evt));
}
public void UpdateScene(IScene scene)
{
currentScene = scene;
if (scene is IInputEvent)
{
currentInput = scene as IInputEvent;
}
else
{
currentInput = null;
}
}
void IInputEvent.ButtonEvent(int input, IGameManager igameManager)
{
if (input == 0)
{
}
else if (input == 1)
{
nextMenu = rootMenu;
rootMenu.SetBattleMenuEnable(true);
MonoBehaviour.Destroy(canvas.gameObject);
}
}
public override InputHandledStatus HandleInput(IInputEvent input)
{
if (input is CommandInput i && i.targetAbility == this && i.button.is_press)
{
if (this.Status() != PlayerAbilityStatus.Running)
{
DoDash();
return(InputHandledStatus.Handled);
}
return(InputHandledStatus.Deny);
}
return(InputHandledStatus.Deny);
}
public void OnInputEvent(IInputEvent args)
{
if (args is IKeyEvent keyArgs)
{
CurrentKeyboardState = keyArgs.State;
CurrentKeyModifiers = keyArgs.KeyModifiers;
}
else if (args is IMouseEvent margs && margs.IsOfType(MouseEventType.Down))
{
FocusedViewport = args.Viewport;
}
eventRoutingService.FireEvent <IInteractionEvent>(args);
}
protected override bool OnViewProcessInput(ref IInputEvent evt)
{
if (base.OnViewProcessInput(ref evt) == true)
{
return(true);
}
if (m_ActiveView != null)
{
return(m_ActiveView.GUIView_ProcessInput(ref evt));
}
return(false);
}
protected override bool OnProcess(ref IInputEvent evt)
{
if (TouchControls != null && TouchControls.Process(ref evt) == true)
{
return(true);
}
#if UNITY_EDITOR || MADFINGER_KEYBOARD_MOUSE
if (PCControls != null && PCControls.Process(ref evt) == true)
{
return(true);
}
#endif
return(false);
}
public bool OnInputEvent(IInputEvent iie)
{
if (iie is MouseInputEvent mie &&
mie.Type == MouseInputEventType.Click &
mie.LeftButton)
{
if (mie.MouseX >= X && mie.MouseX < (X + Width) &&
mie.MouseY >= Y && mie.MouseY < (Y + Height))
{
Pressed?.Invoke(this);
return(true);
}
}
return(false);
}
protected override bool OnViewProcessInput(ref IInputEvent evt)
{
if (Owner == null)
{
return(false);
}
if (base.OnViewProcessInput(ref evt) == true)
{
return(true);
}
GuiScreen page = CurrentPage;
return(page != null?page.ProcessInput(ref evt) : false);
}
bool OnProcessInput(ref IInputEvent evt)
{
if (evt.Kind != E_EventKind.Touch)
{
return(false);
}
TouchEvent touch = (TouchEvent)evt;
if (touch.Phase != TouchPhase.Ended)
{
return(false);
}
return(HitTest(touch.Position));
}
public void UpdateScene(IScene scene)
{
currentScene = scene;
if (scene is IInputEvent)
currentInput = scene as IInputEvent;
else
currentInput = null;
}
