public GuiSystem(ViewportAdapter viewportAdapter, IGuiRenderer renderer)
{
_viewportAdapter = viewportAdapter;
_renderer = renderer;
_mouseListener = new MouseListener(viewportAdapter);
_mouseListener.MouseMoved += (s, e) => OnPointerMoved(GuiPointerEventArgs.FromMouseArgs(e));
_mouseListener.MouseDown += (s, e) => OnPointerDown(GuiPointerEventArgs.FromMouseArgs(e));
_mouseListener.MouseUp += (s, e) => OnPointerUp(GuiPointerEventArgs.FromMouseArgs(e));
_mouseListener.MouseWheelMoved += (s, e) => _focusedControl?.OnScrolled(e.ScrollWheelDelta);
_touchListener = new TouchListener(viewportAdapter);
_touchListener.TouchStarted += (s, e) => OnPointerDown(GuiPointerEventArgs.FromTouchArgs(e));
_touchListener.TouchMoved += (s, e) => OnPointerMoved(GuiPointerEventArgs.FromTouchArgs(e));
_touchListener.TouchEnded += (s, e) => OnPointerUp(GuiPointerEventArgs.FromTouchArgs(e));
_keyboardListener = new KeyboardListener();
_keyboardListener.KeyTyped += (sender, args) => _focusedControl?.OnKeyTyped(this, args);
_keyboardListener.KeyPressed += (sender, args) => _focusedControl?.OnKeyPressed(this, args);
Screens = new GuiScreenCollection(this)
{
ItemAdded = InitializeScreen
};
}
public InputHandler(Game game)
{
MouseListener = new MouseListener();
KeyboardListener = new KeyboardListener();
_inputListener = new InputListenerComponent(game, MouseListener, KeyboardListener);
}
public virtual void AddMouseListener(MouseListener listener)
{
if (!_mouseListeners.Contains(listener))
{
_mouseListeners.Add(listener);
}
}
// Use this for initialization
public void Start()
{
//loads main menu
MyScreen1.Start();
DataController.Start();
Application.targetFrameRate = 60;
//ProfilerHere();
ClassContainer = General.Create(Root.classesContainer);
BuildsContainer = General.Create(Root.classesContainer, name: "BuildsContainer");
PersonObjectContainer = General.Create(Root.classesContainer, name: "PersonObjectsContainer");
MeshBatchContainer = General.Create(Root.classesContainer, name: "MeshBatchContainer");
if (Application.loadedLevelName == "Lobby")
{
//Settings.PlayMusic();
}
else
{
if (gameScene == null)
{
gameScene = (GameScene)General.Create(Root.gameScene, container: ClassContainer.transform);
InputMain = (InputMain)General.Create(Root.inputMain, container: ClassContainer.transform);
}
}
MouseListener.Start();
ManagerReport.Start();
AudioCollector.RedoGame();
}
// Start is called before the first frame update
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonDown(0))
{
MouseListener mouseListener = GetMouseListener();
if (mouseListener != null)
{
mouseListener?.OnLMBDown(Input.mousePosition);
_activeMouseListener?.OnMouseMissed(Input.mousePosition);
_activeMouseListener = mouseListener;
}
else
{
_activeMouseListener?.OnMouseMissed(Input.mousePosition);
_prevMouseListener?.OnMouseMissed(Input.mousePosition);
_activeMouseListener = null;
}
}
else if (Input.GetMouseButton(0) && _activeMouseListener != null)
{
_activeMouseListener?.OnMousePositionChanged(Input.mousePosition);
}
else if (Input.GetMouseButtonUp(0))
{
MouseListener mouseListener = GetMouseListener();
mouseListener?.OnLMBUp(Input.mousePosition);
if (mouseListener != _activeMouseListener)
{
_activeMouseListener?.OnMouseMissed(Input.mousePosition);
}
_prevMouseListener = _activeMouseListener;
_activeMouseListener = null;
}
}
void RotateToMousePosition(Vector3 mousePos)
{
if (!_isRotationActive)
{
return;
}
if (!MouseListener.IsMouseOnScreen())
{
return;
}
var relativeMousePos = transform.InverseTransformPoint(mousePos);
var isMouseInDeadZone =
relativeMousePos.x > 0f - rotationDeadZone && relativeMousePos.x < 0f + rotationDeadZone;
if (isMouseInDeadZone)
{
return;
}
if (relativeMousePos.x < 0f)
{
_rb.MoveRotation(_rb.rotation + rotationSpeed * Time.fixedDeltaTime);
}
else if (relativeMousePos.x > 0f)
{
_rb.MoveRotation(_rb.rotation + -rotationSpeed * Time.fixedDeltaTime);
}
}
public GuiInputService(InputListenerComponent inputListener)
{
inputListener.Listeners.Add(KeyboardListener = new KeyboardListener());
inputListener.Listeners.Add(MouseListener = new MouseListener());
inputListener.Listeners.Add(GamePadListener = new GamePadListener());
inputListener.Listeners.Add(TouchListener = new TouchListener());
}
internal virtual void ProcessMouseEvent(MouseEvent e)
{
MouseListener listener = MouseListener;
if (listener != null)
{
int id = e.ID;
switch (id)
{
case MouseEvent.MOUSE_PRESSED:
listener.MousePressed(e);
break;
case MouseEvent.MOUSE_RELEASED:
listener.MouseReleased(e);
break;
case MouseEvent.MOUSE_CLICKED:
listener.MouseClicked(e);
break;
default:
return;
}
}
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
if (SpecificWindowMode)
{
this.Size = BackgroundImage.Size;
mhook = new MouseListener();
mhook.Click += (sender, loc) => {
if (loc.X > Location.X && loc.X < Location.X + Size.Width && loc.Y > Location.Y && loc.Y < Location.Y + Size.Height)
{
return;
}
DialogResult = DialogResult.Abort;
SystemSounds.Beep.Play();
this.Close();
mhook.Stop();
};
mhook.Start();
return;
}
//full screen mode:
MultiScreenSize m_MultiScreenSize = FindMultiScreenSize();
this.Size = new Size(m_MultiScreenSize.maxRight - m_MultiScreenSize.minX, m_MultiScreenSize.maxBottom - m_MultiScreenSize.minY);
Graph.CopyFromScreen(m_MultiScreenSize.minX, m_MultiScreenSize.minY, 0, 0, BitmapSize);
}
public override void Initialize()
{
_inputListenerManager = new InputListenerComponent(Game);
Game.Components.Add(_inputListenerManager);
_mouseListener = new MouseListener();
_inputListenerManager.Listeners.Add(_mouseListener);
_mouseListener.MouseMoved += Mouse_MouseMoved;
_mouseListener.MouseDown += Mouse_MouseDownOrUp;
_mouseListener.MouseUp += Mouse_MouseDownOrUp;
_mouseListener.MouseWheelMoved += Mouse_MouseScroll;
_keyboardListener = new KeyboardListener();
_inputListenerManager.Listeners.Add(_keyboardListener);
_keyboardListener.KeyPressed += Keyboard_KeyDown;
_keyboardListener.KeyReleased += Keyboard_KeyUp;
GamePadListener.CheckControllerConnections = true;
GamePadListener.ControllerConnectionChanged += GamePad_ConnectionChanged;
EventManager.Instance.RegisterListener <GamePadConnectedEvent>(this);
EventManager.Instance.RegisterListener <GamePadDisconnectedEvent>(this);
base.Initialize();
}
protected override void Initialize()
{
// Settings
Settings.Instance.Load();
Mouse.WindowHandle = Window.Handle;
IsMouseVisible = true;
_inputListenerManager = new InputListenerComponent(this);
Components.Add(_inputListenerManager);
_mouseListener = new MouseListener();
_inputListenerManager.Listeners.Add(_mouseListener);
_mouseListener.MouseMoved += Mouse_MouseMoved;
_mouseListener.MouseDown += Mouse_MouseDownOrUp;
_mouseListener.MouseUp += Mouse_MouseDownOrUp;
_gamePadListener = new GamePadListener();
_inputListenerManager.Listeners.Add(_gamePadListener);
GamePadListener.CheckControllerConnections = true;
GamePadListener.ControllerConnectionChanged += GamePad_ControllerConnectionChanged;
base.Initialize();
}
private void fireInputEnd(InputDeviceType inputType, GamePadState gpdState, KeyboardState keyState, MouseState mosState, Keys keyBtn, GamepadCode gpdBtn, MouseCode mosBtn)
{
InputObject input = new InputObject(inputType, gpdState, mosState, keyBtn, gpdBtn, mosBtn);
//General
for (int i = 0; i < generalListeners.Count; i++)
{
GeneralInputListener listener = generalListeners[i];
listener.InputEnded(input);
switch (inputType)
{
case (InputDeviceType.Gamepad):
listener.GamepadInputEnded(input);
break;
case (InputDeviceType.Keyboard):
listener.KeyboardInputEnded(input);
break;
case (InputDeviceType.Mouse):
listener.MouseInputEnded(input);
break;
}
}
//Others
switch (inputType)
{
case (InputDeviceType.Gamepad):
for (int i = 0; i < gamepadListeners.Count; i++)
{
GamepadListener listener = gamepadListeners[i];
listener.InputEnded(input);
}
break;
case (InputDeviceType.Keyboard):
for (int i = 0; i < keyboardListeners.Count; i++)
{
KeyboardListener listener = keyboardListeners[i];
listener.InputEnded(input);
}
if (keyboardBinds.ContainsKey(keyBtn))
{
keyboardBinds[keyBtn].Ended();
}
break;
case (InputDeviceType.Mouse):
for (int i = 0; i < mouseListeners.Count; i++)
{
MouseListener listener = mouseListeners[i];
listener.InputEnded(input);
}
break;
default:
break;
}
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
inputManager = new InputManager(this, keyboardListener = new KeyboardInputListener(),
gamepadListeners = new GamepadInputListener[]
{
new GamepadInputListener(PlayerIndex.One),
new GamepadInputListener(PlayerIndex.Two),
new GamepadInputListener(PlayerIndex.Three),
new GamepadInputListener(PlayerIndex.Four)
},
mouseListener = new MouseListener());
scriptEngine = new ScriptEngine(this, "scripteng.cfg")
{
LoggingMethod = LoggingMethod.Console
};
windowManager = new WindowManager(this)
{
DrawOrder = 0
};
stateManager = new GameStateManager(this)
{
DrawOrder = 1
};
stateManager.GameStateChanging += stateManager_GameStateChanging;
stateManager.OnGameStatePushing += stateManager_OnGameStatePushing;
stateManager.OnGameStatePopping += stateManager_OnGameStatePopping;
world = new World(this, new BruteForceBroadphase(), new SeparatingAxisTheorem());
Components.Add(inputManager);
Components.Add(windowManager);
Components.Add(stateManager);
Components.Add(scriptEngine);
base.Initialize();
camera = new Camera(Vector2.Zero, this.GraphicsDevice.Viewport);
scriptEngine.CompileAll();
objectCreators.Add(new ObjectCreator("ObjectFiles\\Maps.xml"));
objectCreators.Add(new ObjectCreator("ObjectFiles\\Entities.xml"));
string[] objectFiles = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory + "ObjectFiles\\")
.Where(f => f.EndsWith(".xml"))
.ToArray();
for (int i = 0; i < objectFiles.Length; i++)
{
objectCreators.Add(new ObjectCreator(objectFiles[i]));
}
//stateManager.(new GameplayState("City1.xml"));
stateManager.ChangeState(new SplashMenuState());
}
private void UnHookMouse()
{
if (_mouseListener != null)
{
_mouseListener.Dispose();
_mouseListener = null;
}
}
/// <summary>
/// Constructs the <see cref="BoundHandler"/> class.
/// </summary>
public static void Initialize()
{
MouseListener = new MouseListener();
MouseListener.MouseClicked += MouseListener_MouseClicked;
MouseListener.MouseDoubleClicked += MouseListener_MouseDoubleClicked;
MouseListener.MouseWheelMoved += MouseListener_MouseWheelMoved;
MouseListener.MouseDrag += MouseListner_MouseDrag;
}
public static void Load(KeyboardListener kbd, MouseListener mouse, Game game)
{
_game = game;
Keyboard = kbd;
Mouse = mouse;
Graphics = game.GraphicsDevice;
View = new GameViewport(game);
}
public ControlSystem(SharedState sharedState, MouseListener mouseListener,
Random random, GraphicsDeviceManager graphics, Sprites sprites) : base(Aspect.All(typeof(Transform2),
typeof(EntityInfo)))
{
this.sharedState = sharedState;
this.random = random;
this.graphics = graphics;
this.sprites = sprites;
mouseListener.MouseClicked += OnMouseClicked;
}
public PauseStateGameController()
{
this.keyboardListener = new KeyboardListener();
this.mouseListener = new MouseListener();
this.keyboardListener.KeyReleased += OnKeyReleased;
this.keyboardListener.KeyPressed += OnKeyPressed;
this.mouseListener.MouseClicked += OnMouseClick;
}
private void OnDisable()
{
MouseListener mouseListener = GetComponent <MouseListener>();
if (mouseListener)
{
mouseListener.RemoveMouseDown(ClickedOn);
}
orderedBy = null;
}
private void HookMouse()
{
if (_settings.Get <bool>(_names.EnableMouseHook) && _mouseListener == null)
{
_mouseListener = new MouseListener();
_mouseListener.OnLeftMouseDown += _mouseListener_OnLeftMouseDown;
_mouseListener.OnRightMouseDown += MouseListener_OnRightMouseDown;
_mouseListener.Hook();
_logger.Log(">Mouse hooked!", LogLevel.Debug);
}
}
/// <summary>
/// Removes the specified mouse listener. Calling this method with
/// <code>null</code> or an invalid value has no effect.
/// <para>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
/// >AWT Threading Issues</a> for details on AWT's threading model.
///
/// </para>
/// </summary>
/// <param name="listener"> the mouse listener </param>
/// <seealso cref= java.awt.event.MouseEvent </seealso>
/// <seealso cref= java.awt.event.MouseListener </seealso>
/// <seealso cref= #addMouseListener(MouseListener) </seealso>
/// <seealso cref= #getMouseListeners </seealso>
public virtual void RemoveMouseListener(MouseListener listener)
{
lock (this)
{
if (listener == null)
{
return;
}
MouseListener = AWTEventMulticaster.Remove(MouseListener, listener);
}
}
public MouseInputBuffer(MouseListener listener)
{
this.listener = listener;
funcs[0] = (state) => state.LeftButton;
funcs[1] = (state) => state.RightButton;
funcs[2] = (state) => state.MiddleButton;
funcs[3] = (state) => state.XButton1;
funcs[4] = (state) => state.XButton2;
current = new List <MouseButtons>();
old = current;
}
/// <summary>Initializes a new input capturer using the specified input service</summary>
/// <param name="inputService">Input service the capturer will subscribe to</param>
public DefaultInputCapturer(IGuiInputService inputService)
{
_inputService = inputService;
_inputReceiver = new DummyInputReceiver();
_keyboardListener = inputService.KeyboardListener;
_mouseListener = inputService.MouseListener;
_gamePadListener = inputService.GamePadListener;
SubscribeInputDevices();
}
public KBMousePlayerController()
{
this.keyboardListener = new KeyboardListener();
this.mouseListener = new MouseListener();
this.keyboardListener.KeyReleased += OnKeyReleased;
this.keyboardListener.KeyPressed += OnKeyPressed;
this.mouseListener.MouseDown += OnMouseDown;
this.mouseListener.MouseWheelMoved += OnMouseWheelMoved;
this.mouseListener.MouseDrag += OnMouseDrag;
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
var mouseListener = new MouseListener(new MouseListenerSettings());
Components.Add(new InputListenerComponent(this, mouseListener));
mouseListener.MouseClicked += (sender, args) => SelectTile(args);
mouseListener.MouseDoubleClicked += (sender, args) => RotateTile(args);
mouseListener.MouseDown += (sender, args) => SelectTile(args);
base.Initialize();
}
private MouseListener GetMouseListener()
{
var target = m_MouseListenerCache;
if (target != null)
{
return(target);
}
target = CreateMouseListener();
m_MouseListenerCache = target;
return(target);
}
private void InitHooks()
{
KListener = new KeyboardListener();
MListener = new MouseListener();
KListener.KeyDown += new RawKeyEventHandler(KListener_KeyDown);
KListener.KeyUp += new RawKeyEventHandler(KListener_KeyUp);
MListener.LeftDown += new RawMouseEventHandler(MListener_LeftDown);
MListener.LeftUp += new RawMouseEventHandler(MListener_LeftUp);
MListener.RightDown += new RawMouseEventHandler(MListener_RightDown);
MListener.RightUp += new RawMouseEventHandler(MListener_RightUp);
MListener.MouseMove += new RawMouseEventHandler(MListener_MouseMove);
MListener.MouseWheel += new RawMouseEventHandler(MListener_MouseWheel);
}
/// <summary>
/// Initialization
/// </summary>
private void Start()
{
if (Instance != null)
{
Logger.Instance.Error("Start called multiple times");
}
Instance = this;
Transparent_Building.SetActive(false);
tile_under_cursor = null;
highlighted_tiles = new List <Tile>();
highlight_color = new Color(0.1f, 0.5f, 0.1f, 0.5f);
highlighted_connected_building_tiles = new List <Tile>();
highlight_connected_color = new Color(0.1f, 0.1f, 0.5f, 0.5f);
}
void CastMouseRay()
{
if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out RaycastHit hitInfo))
{
if (hitInfo.transform.gameObject)
{
MouseListener mouseListener = hitInfo.transform.GetComponent <MouseListener>();
if (mouseListener)
{
mouseListener.MouseOver(hitInfo);
}
}
}
}
/// <summary>
/// Creates a new player cursor controller.
/// </summary>
/// <param name="grid">The grid that this controller is relative to.</param>
/// <param name="mouse">The mouse listener that this controller uses.</param>
/// <param name="camera">The camera that this controller is relative to.</param>
public PlayerCursorController(TileGrid grid, MouseListener mouse, Camera camera)
: base(grid)
{
this.camera = camera;
this.mouse = mouse;
UpdateContext.Update += OnUpdate;
// Bubble events from the mouse listener.
// TODO this setup seems not pog; maybe
// a better way to route events here.
mouse.LeftClicked += ConvertPrimaryClicked;
mouse.LeftReleased += ConvertPrimaryReleased;
mouse.RightClicked += ConvertSecondaryClicked;
mouse.RightReleased += ConvertSecondaryReleased;
}
/// <summary>
/// Removes the specified mouse listener so that it no longer
/// receives mouse events from this component.
/// </summary>
public void removeMouseListener(MouseListener @l)
{
}
public void AddMouseListener(MouseListener listener)
{
if (!_mouseListeners.Contains(listener))
_mouseListeners.Add(listener);
}
public virtual void addMouseListener(MouseListener l)
{
((Component) this.glassPane).addMouseListener(l);
((Component) this.backPane).addMouseListener(l);
}
public void removeMouseListener(MouseListener listener)
{
_mouseListeners.Remove(listener);
}
void Start()
{
gameController = GameObject.FindGameObjectWithTag(Tags.gameController);
mouseListener = gameController.GetComponent<MouseListener>();
moveNodes = gameController.GetComponent<MoveNodes>();
}
public void addMouseListener(MouseListener mouseListener)
{
lock (mouseListeners)
{
mouseListeners.Add(mouseListener);
}
}
protected void PushMouseListener(MouseListener element)
{
mouseListeners.Push(element);
}
/// <summary>
/// Adds the specified mouse listener to receive mouse events from
/// this component.
/// </summary>
public void addMouseListener(MouseListener @l)
{
}
