/// <inheritdoc/>
public override void LostMouse(MouseScreenObjectState state)
{
if (IsMouseOver)
{
OnMouseExit(state);
}
}
/// <summary>
/// Raises the <see cref="MouseExit"/> event.
/// </summary>
/// <param name="state">Current mouse state in relation to this console.</param>
protected virtual void OnMouseExit(MouseScreenObjectState state)
{
// Force mouse off just in case
IsMouseOver = false;
MouseExit?.Invoke(this, state);
}
public override bool ProcessMouse(MouseScreenObjectState state)
{
_mouseCursor.IsVisible = state.IsOnScreenObject;
_mouseCursor.Position = state.CellPosition;
return(base.ProcessMouse(state));
}
public override bool ProcessMouse(MouseScreenObjectState state)
{
mouse.Update(state, IsMouseOver);
if (state.IsOnScreenObject)
{
//If the mouse enters the screen held but the hold started from outside the screen, we ignore it
var(x, y) = state.SurfaceCellPosition;
var colors = colorPicker.colors;
if (state.Mouse.LeftButtonDown && mouse.leftPressedOnScreen)
{
model.brush.foreground = colors[x, y];
colorPicker.foregroundPoint = new Point(x, y);
colorPicked?.Invoke();
}
if (state.Mouse.RightButtonDown && mouse.rightPressedOnScreen)
{
model.brush.background = colors[x, y];
colorPicker.backgroundPoint = new Point(x, y);
colorPicked?.Invoke();
}
}
return(base.ProcessMouse(state));
}
/// <inheritdoc/>
public override bool ProcessMouse(MouseScreenObjectState state)
{
if (IsEnabled && UseMouse)
{
bool processResult = base.ProcessMouse(state);
var controls = new List <ControlBase>(Controls);
controls.Reverse();
foreach (var control in controls)
{
var state2 = new ControlMouseState(control, state);
if (state2.IsMouseOver && state.Mouse.RightClicked)
{
System.Diagnostics.Debugger.Break();
}
if (control.ProcessMouse(state))
{
return(true);
}
}
return(processResult);
}
return(false);
}
public void Update(MouseScreenObjectState state, bool IsMouseOver)
{
prevMouseOver = nowMouseOver;
nowMouseOver = IsMouseOver;
mouseOver = !prevMouseOver ? (nowMouseOver ? MouseState.Enter : MouseState.Outside) : (nowMouseOver ? MouseState.Hover : MouseState.Exit);
prevPos = nowPos;
nowPos = state.SurfaceCellPosition;
prevLeft = nowLeft;
prevRight = nowRight;
nowLeft = state.Mouse.LeftButtonDown;
nowRight = state.Mouse.RightButtonDown;
left = !prevLeft ? (!nowLeft ? ClickState.Up : ClickState.Pressed) : (nowLeft ? ClickState.Held : ClickState.Released);
right = !prevRight ? (!nowRight ? ClickState.Up : ClickState.Pressed) : (nowRight ? ClickState.Held : ClickState.Released);
if (left == ClickState.Pressed)
{
leftPressedOnScreen = IsMouseOver;
leftPressedPos = state.SurfaceCellPosition;
}
if (right == ClickState.Pressed)
{
rightPressedOnScreen = IsMouseOver;
rightPressedPos = state.SurfaceCellPosition;
}
}
/// <inheritdoc />
public void ProcessMouse(IScreenObject host, MouseScreenObjectState state, out bool handled)
{
handled = false;
foreach (var entity in _mapEntities.ToArray())
{
handled = entity.ProcessMouse(state);
}
}
public override bool ProcessMouse(MouseScreenObjectState state)
{
mouse.Update(state, IsMouseOver);
if (state.IsOnScreenObject)
{
int index = (state.SurfaceCellPosition.X) + (state.SurfaceCellPosition.Y * Width);
if (index > -1 && index < paletteModel.palette.Count)
{
var left = mouse.leftPressedOnScreen && mouse.nowLeft;
var right = mouse.rightPressedOnScreen && mouse.nowRight;
if (left || right)
{
if (left)
{
if (paletteModel.foregroundIndex != index)
{
//Don't want the color to flash between index and transparent
if (mouse.left == ClickState.Pressed || (mouse.left == ClickState.Held && paletteModel.foregroundIndex != null))
{
paletteModel.foregroundIndex = index;
spriteModel.brush.foreground = paletteModel.palette[index];
}
}
else if (mouse.left == ClickState.Pressed)
{
//Press the same color to deselect
paletteModel.foregroundIndex = null;
spriteModel.brush.foreground = Color.Transparent;
}
}
if (right)
{
if (paletteModel.backgroundIndex != index)
{
//Don't want the color to flash between index and transparent
if (mouse.right == ClickState.Pressed || (mouse.right == ClickState.Held && paletteModel.backgroundIndex != null))
{
paletteModel.backgroundIndex = index;
spriteModel.brush.background = paletteModel.palette[index];
}
}
else if (mouse.right == ClickState.Pressed)
{
//Press the same color to deselect
paletteModel.backgroundIndex = null;
spriteModel.brush.background = Color.Transparent;
}
}
brushChanged?.Invoke();
}
}
}
return(base.ProcessMouse(state));
}
public override bool ProcessMouse(MouseScreenObjectState state)
{
// Process mouse for each console
var childState = new MouseScreenObjectState(_controlsConsole, state.Mouse);
if (childState.IsOnScreenObject)
{
return(_controlsConsole.ProcessMouse(childState));
}
return(false);
}
/// <inheritdoc/>
public override bool ProcessMouse(MouseScreenObjectState state)
{
if (!IsVisible)
{
return(false);
}
foreach (SadConsole.Components.IComponent component in ComponentsMouse.ToArray())
{
component.ProcessMouse(this, state, out bool isHandled);
if (isHandled)
{
return(true);
}
}
if (!UseMouse)
{
return(false);
}
if (state.IsOnScreenObject)
{
if (IsMouseOver != true)
{
IsMouseOver = true;
OnMouseEnter(state);
}
OnMouseMove(state);
if (state.Mouse.LeftClicked)
{
OnMouseLeftClicked(state);
}
if (state.Mouse.RightClicked)
{
OnRightMouseClicked(state);
}
return(true);
}
if (IsMouseOver)
{
IsMouseOver = false;
OnMouseExit(state);
}
return(false);
}
public override bool ProcessMouse(MouseScreenObjectState state)
{
mouse.Update(state, IsMouseOver);
if (isActive && IsMouseOver)
{
if (mouse.leftPressedOnScreen && mouse.left == ClickState.Released)
{
click();
}
}
return(base.ProcessMouse(state));
}
public override void ProcessMouse(IScreenObject host, MouseScreenObjectState state, out bool handled)
{
if (state.Mouse.IsOnScreen)
{
host.Position = state.WorldCellPosition;
handled = true;
}
else
{
handled = false;
}
}
public override void ProcessMouse(IScreenObject host, MouseScreenObjectState state, out bool handled)
{
handled = true;
var monster = _map.GetEntityAt <Monster>(state.CellPosition);
if (monster == null)
{
Game.DungeonScreen.EnemyStatsConsole.HideStats();
return;
}
Game.DungeonScreen.EnemyStatsConsole.ShowStats(monster);
}
public override bool ProcessMouse(MouseScreenObjectState state)
{
mouse.Update(state, IsMouseOver);
if (state.IsOnScreenObject && state.Mouse.LeftButtonDown && mouse.leftPressedOnScreen)
{
int index = (state.SurfaceCellPosition.X) + (state.SurfaceCellPosition.Y * Width);
if (index < 256 && spriteModel.brush.glyph != index)
{
spriteModel.brush.glyph = (char)index;
brushChanged?.Invoke();
}
}
return(base.ProcessMouse(state));
}
public override bool ProcessMouse(MouseScreenObjectState state)
{
var(x, y) = state.SurfaceCellPosition;
if (state.IsOnScreenObject)
{
mouse.Update(state, IsMouseOver);
if (state.Mouse.LeftButtonDown && mouse.leftPressedOnScreen)
{
index = x;
colorPicker.hue = index * 360d / bar.Length;
colorPicker.UpdateColors();
colorPicker.UpdateBrushPoints(paletteModel);
colorPicker.UpdatePalettePoints(paletteModel);
}
}
return(base.ProcessMouse(state));
}
/// <summary>
/// Raises the <see cref="MouseMove"/> event.
/// </summary>
/// <param name="state">Current mouse state in relation to this console.</param>
protected virtual void OnMouseMove(MouseScreenObjectState state)
{
if (state.Mouse.LeftButtonDown)
{
if (MoveToFrontOnMouseClick && Parent != null && Parent.Children.IndexOf(this) != Parent.Children.Count - 1)
{
Parent.Children.MoveToTop(this);
}
if (FocusOnMouseClick && !IsFocused)
{
IsFocused = true;
}
}
MouseMove?.Invoke(this, state);
}
public override void ProcessMouse(IScreenObject host, MouseScreenObjectState mouse, out bool handled)
{
var mousePos = mouse.CellPosition.ToPoint() + new Point(-1, -1);
if (state == InputState.Targeting)
{
trajectory = new List <Point>();
Point playerPos = player.Location;
Algorithms.Line(playerPos.X, playerPos.Y, mousePos.X, mousePos.Y, (int x, int y) => {
Point point = new Point(x, y);
if (!mapConsole.map.InBounds(point) || !mapConsole.map.IsWalkable(point))
{
trajectory.Clear();
return(false);
}
trajectory.Add(point);
return(true);
});
mapConsole.overlayPoints = trajectory.Skip(1).ToList();
if (mouse.Mouse.LeftClicked && trajectory.Any() && trajectory.Count > 1)
{
if (playerPos.X > mousePos.X || playerPos.Y > mousePos.Y)
{
trajectory.Reverse();
}
FireMissile(trajectory, player);
state = InputState.Idle;
mapConsole.overlayPoints.Clear();
}
}
var actor = actors
.SingleOrDefault(a => a.Location == mousePos && player.Fov.IsInFov(a.Location.X, a.Location.Y));
messageConsole.SetMessage(actor?.Name() ?? "");
handled = true;
}
public override bool ProcessMouse(MouseScreenObjectState state)
{
int deltaScroll = state.Mouse.ScrollWheelValueChange / 60;
if (deltaScroll != 0)
{
scroll.index += deltaScroll;
UpdateListing();
}
mouse.Update(state, IsMouseOver);
if (mouse.left == ClickState.Held && mouse.leftPressedOnScreen)
{
var deltaY = mouse.prevPos.Y - mouse.nowPos.Y;
if (deltaY != 0)
{
scroll.index += deltaY;
}
}
return(base.ProcessMouse(state));
}
public override bool ProcessMouse(MouseScreenObjectState state)
{
if (state.IsOnScreenObject)
{
int index = (state.SurfaceCellPosition.X) + (state.SurfaceCellPosition.Y * Width);
if (index > -1 && index < tileModel.tiles.Count)
{
bool pressLeft = !prevLeft && state.Mouse.LeftButtonDown;
if (pressLeft)
{
if (spriteModel.brush.cell != tileModel.tiles[index])
{
spriteModel.brush.cell = tileModel.tiles[index];
}
brushChanged?.Invoke();
}
}
}
prevLeft = state.Mouse.LeftButtonDown;
return(base.ProcessMouse(state));
}
/// <summary>
/// Processes the mouse on each control hosted by this control.
/// </summary>
/// <param name="state">The mouse state based on the parent screen object.</param>
/// <returns><see langword="true"/> when a control processes the mouse; otherwise <see langword="false"/>.</returns>
public override bool ProcessMouse(MouseScreenObjectState state)
{
if (IsEnabled && UseMouse)
{
bool processResult = base.ProcessMouse(state);
var controls = new List <ControlBase>(Controls);
controls.Reverse();
foreach (var control in controls)
{
if (control.ProcessMouse(state))
{
return(true);
}
}
return(processResult);
}
return(false);
}
public override void ProcessMouse(IScreenObject host, MouseScreenObjectState state, out bool handled)
{
handled = false;
WorldPlay world = (WorldPlay)host;
state = new MouseScreenObjectState(world.GameBoard, state.Mouse);
if (state.IsOnScreenObject)
{
if (state.Mouse.LeftButtonDown)
{
if (!world.GameBoard.GetObjectsAtPosition(state.CellPosition, out _))
{
//world.GameBoard.PlayerControlledObject = obj;
world.GameBoard.CreateGameObject(state.CellPosition, "pusher-east", Factories.GameObjectConfig.Empty);
}
}
if (state.Mouse.RightClicked)
{
if (world.GameBoard.GetObjectsAtPosition(state.CellPosition, out var objects))
{
if (objects[0].HasComponent <ObjectComponents.Pusher>())
{
objects[0].RemoveComponent(objects[0].GetComponent <ObjectComponents.Pusher>());
}
var pusher = new ObjectComponents.Pusher();
pusher.Direction = Direction.Types.Down;
objects[0].AddComponent(pusher);
}
}
handled = true;
}
}
public override bool ProcessMouse(SadConsole.Input.MouseScreenObjectState info)
{
var worldLocation = info.Mouse.ScreenPosition.PixelLocationToSurface(FontSize.X, FontSize.Y);
var consoleLocation = new Point(worldLocation.X - Position.X, worldLocation.Y - Position.Y);
// Check if mouse is within the upper/lower bounds of the console
if (Surface.View.Contains(info.SurfaceCellPosition))
{
bool isHexRow = info.SurfaceCellPosition.Y % 2 == 1;
var newMouse = info.Mouse.Clone();
// Check if mouse is on an alternating row
if (isHexRow)
{
newMouse.ScreenPosition = (newMouse.ScreenPosition.X - FontSize.X / 2, newMouse.ScreenPosition.Y);
}
var newInfo = new MouseScreenObjectState(this, newMouse);
if (info.ScreenObject == this)
{
FillHexes(lastCell, 176, lastCellHexRow);
lastCell = info.SurfaceCellPosition.ToIndex(Surface.Width);
lastCellHexRow = isHexRow;
FillHexes(lastCell, 45, isHexRow);
IsDirty = true;
return(true);
}
}
//base.ProcessMouse(info);
FillHexes(lastCell, 176, lastCellHexRow);
return(true);
}
public override bool ProcessMouse(MouseScreenObjectState state)
{
if (state.IsOnScreenObject)
{
Rectangle mouseArea = _surfaceView.MouseArea;
mouseArea = mouseArea.Translate(_surfaceView.Position);
if (mouseArea.Contains(state.SurfaceCellPosition))
{
_cellTrackOnControl = true;
Point pos = state.SurfaceCellPosition - _surfaceView.Position;
if (_surfaceView.MouseArea.Contains(pos))
{
SetEditCell(_surfaceView.Surface[pos.X, pos.Y]);
}
}
else if (_cellTrackOnControl)
{
_cellTrackOnControl = false;
SetEditCell(null);
}
}
return(base.ProcessMouse(state));
}
void IComponent.ProcessMouse(IScreenObject host, MouseScreenObjectState state, out bool handled) => handled = false;
/// <summary> /// Raises the <see cref="MouseButtonClicked"/> event. /// </summary> /// <param name="state">Current mouse state in relation to this console.</param> protected virtual void OnRightMouseClicked(MouseScreenObjectState state) => MouseButtonClicked?.Invoke(this, state);
/// <summary> /// Called when IsMouse is true /// </summary> /// <param name="host">The "Parent" if you're using RogueLikeEntity</param> /// <param name="state">The state of the mouse</param> /// <param name="handled">Whether or not we are done handling mouse input</param> public virtual void ProcessMouse(IScreenObject host, MouseScreenObjectState state, out bool handled) => handled = false;
public void ProcessMouse(IScreenObject host, MouseScreenObjectState state, out bool handled) => throw new System.NotImplementedException();
public override bool ProcessMouse(MouseScreenObjectState state)
{
return(base.ProcessMouse(state));
}
public override bool ProcessMouse(MouseScreenObjectState state)
{
return(false);
}
/// <summary> /// Raises the <see cref="MouseEnter"/> event. /// </summary> /// <param name="state">Current mouse state in relation to this console.</param> protected virtual void OnMouseEnter(MouseScreenObjectState state) => MouseEnter?.Invoke(this, state);
