internal override bool MouseMoved(IGameViewport viewport, MessageMouseArgs args)
{
ClearResults();
SetResultLocationFromMouse(args);
if (Picker.flagsTarget.HasFlag(UiPickerFlagsTarget.Radius))
{
TrimRangeOfPicker(Result.location);
using var rayPkt = CreateRaycast(Result.location);
rayPkt.Raycast();
foreach (var resultItem in rayPkt)
{
if (resultItem.obj != null)
{
if (Result.objList == null)
{
Result.objList = new List <GameObject>();
}
Result.objList.Add(resultItem.obj);
}
}
if (Result.objList != null)
{
Result.flags |= PickerResultFlags.PRF_HAS_MULTI_OBJ;
}
}
Picker.DoExclusions();
return(true);
}
internal override bool MouseMoved(IGameViewport viewport, MessageMouseArgs args)
{
ClearResults();
PickerStatusFlags |= PickerStatusFlags.Invalid;
var raycastFlags = PickerState.GetFlagsFromExclusions();
GameSystems.Raycast.PickObjectOnScreen(viewport, args.X, args.Y, out var target, raycastFlags);
PickerState.Target = target;
if (target != Picker.caster)
{
return(false);
}
PickerStatusFlags &= ~PickerStatusFlags.Invalid;
if (!Picker.flagsTarget.HasFlag(UiPickerFlagsTarget.Radius))
{
Picker.SetSingleTgt(target);
}
else
{
Picker.SetAreaTargets(target.GetLocationFull());
}
return(false);
}
internal override bool MouseMoved(IGameViewport viewport, MessageMouseArgs args)
{
var sourceLocation = Picker.caster.GetLocationFull();
var radius = Picker.caster.GetRadius();
var targetLocation = GameViews.Primary.ScreenToTile(args.X, args.Y);
PickerStatusFlags &= ~(PickerStatusFlags.Invalid | PickerStatusFlags.OutOfRange);
if (Picker.flagsTarget.HasFlag(UiPickerFlagsTarget.Range))
{
var distance = sourceLocation.DistanceTo(targetLocation) - radius;
if (distance > Picker.range)
{
PickerStatusFlags |= PickerStatusFlags.OutOfRange;
}
}
if (Picker.modeTarget.HasFlag(UiPickerType.LocIsClear))
{
if (!IsTargetLocationClear(targetLocation))
{
PickerStatusFlags |= PickerStatusFlags.Invalid;
}
}
return(true);
}
internal override bool LeftMouseButtonReleased(IGameViewport viewport, MessageMouseArgs args)
{
ClearResults();
var targetLocation = GameViews.Primary.ScreenToTile(args.X, args.Y);
var distance = Picker.caster.GetLocationFull().DistanceTo(targetLocation);
// TODO: This seems like a bug, since range seems to be in feet, but the distance is in inches
// TODO: Second bug: Radius of caster is ignored (see MouseMove)
if (distance >= Picker.range)
{
return(true);
}
if (Picker.modeTarget.HasFlag(UiPickerType.LocIsClear))
{
if (!IsTargetLocationClear(targetLocation))
{
return(true);
}
}
SetResultLocation(targetLocation);
return(FinalizePicker());
}
internal override bool LeftMouseButtonReleased(IGameViewport viewport, MessageMouseArgs args)
{
MouseMoved(viewport, args);
if (WallState == WallState.StartPoint)
{
WallState = WallState.EndPoint;
Result.flags |= PickerResultFlags.PRF_HAS_LOCATION;
}
else if (WallState == WallState.EndPoint)
{
var mouseLoc = GameViews.Primary.ScreenToTile(args.X, args.Y);
var mouseLocTrim =
GameSystems.Location.TrimToLength(Result.location, mouseLoc, Picker.trimmedRangeInches);
_wallEndPoint = mouseLocTrim;
return(FinalizePicker());
}
else if (WallState == WallState.CenterPoint)
{
WallState = WallState.Radius;
}
else if (WallState == WallState.Radius)
{
return(FinalizePicker());
}
return(true);
}
internal override bool MouseMoved(IGameViewport viewport, MessageMouseArgs args)
{
var location = GameViews.Primary.ScreenToTile(args.X, args.Y);
Picker.SetConeTargets(location);
return(false);
}
public override bool HandleMouseMessage(MessageMouseArgs msg)
{
// Forward scroll wheel messages to the scrollbar.
if ((msg.flags & MouseEventFlag.ScrollWheelChange) != 0)
{
_scrollbar.HandleMouseMessage(msg);
return(true);
}
return(base.HandleMouseMessage(msg));
}
internal override bool MouseMoved(IGameViewport viewport, MessageMouseArgs args)
{
if (HandleClickInUnexploredArea(args.X, args.Y))
{
return(false);
}
var raycastFlags = PickerState.GetFlagsFromExclusions();
if (!GameSystems.Raycast.PickObjectOnScreen(viewport, args.X, args.Y, out var target, raycastFlags))
{
PickerStatusFlags &= ~(PickerStatusFlags.Invalid | PickerStatusFlags.OutOfRange);
PickerState.Target = null;
return(true);
}
PickerState.Target = target;
if (Picker.flagsTarget.HasFlag(UiPickerFlagsTarget.Exclude1st))
{
if (!Picker.TargetValid(target))
{
PickerStatusFlags |= PickerStatusFlags.Invalid;
}
}
if (!Picker.CheckTargetVsIncFlags(target))
{
PickerStatusFlags |= PickerStatusFlags.Invalid;
}
if (!Picker.flagsTarget.HasFlag(UiPickerFlagsTarget.LosNotRequired) && Picker.LosBlocked(target))
{
PickerStatusFlags |= PickerStatusFlags.Invalid;
}
if (Picker.flagsTarget.HasFlag(UiPickerFlagsTarget.Range))
{
// TODO: This distance check seems bugged too (feet vs. inch, no radius considered)
var dist = Picker.caster.GetLocationFull().DistanceTo(target.GetLocationFull());
if (dist > Picker.range)
{
PickerStatusFlags |= PickerStatusFlags.OutOfRange;
}
}
return(true);
}
internal override bool MouseMoved(IGameViewport viewport, MessageMouseArgs args)
{
PickerStatusFlags &= ~PickerStatusFlags.Invalid;
if (HandleClickInUnexploredArea(args.X, args.Y))
{
return(false);
}
// The picker may allow picking an object directly (which will be the basis of the area effect)
if (Picker.modeTarget.HasFlag(UiPickerType.AreaOrObj))
{
var flags = PickerState.GetFlagsFromExclusions();
if (GameSystems.Raycast.PickObjectOnScreen(viewport, args.X, args.Y, out var target, flags))
{
if ((Picker.flagsTarget.HasFlag(UiPickerFlagsTarget.LosNotRequired) || !Picker.LosBlocked(target)) &&
Picker.CheckTargetVsIncFlags(target) &&
Picker.TargetValid(target))
{
ClearResults();
Picker.SetAreaTargets(target.GetLocationFull());
Result.flags |= PickerResultFlags.PRF_HAS_SELECTED_OBJECT;
// Sort the primary focus of selection to the beginning of the list,
// But don't insert it if it isn't in the list already
if (Result.objList.Remove(target))
{
Result.objList.Insert(0, target);
}
return(false);
}
}
}
var targetLoc = GameViews.Primary.ScreenToTile(args.X, args.Y);
// Even when the picked object above is not valid, targeting the location underneath is a valid alternative
if (!Picker.flagsTarget.HasFlag(UiPickerFlagsTarget.LosNotRequired) &&
!HasLineOfSight(Picker.caster, targetLoc))
{
ClearResults();
PickerStatusFlags |= PickerStatusFlags.Invalid;
return(false);
}
Picker.SetAreaTargets(targetLoc);
return(false);
}
public override bool HandleMouseMessage(MessageMouseArgs msg)
{
if (base.HandleMouseMessage(msg))
{
return(true);
}
if (msg.flags.HasFlag(MouseEventFlag.ScrollWheelChange))
{
var curPos = mScrollBar.GetValue();
var newPos = curPos - msg.wheelDelta / 10;
mScrollBar.SetValue(newPos);
}
return(true);
}
public override bool HandleMouseMessage(MessageMouseArgs msg)
{
if (Globals.UiManager.GetMouseCaptureWidget() == this)
{
if (msg.flags.HasFlag(MouseEventFlag.PosChange))
{
int curY = mDragY + msg.Y - mDragGrabPoint;
int scrollRange = mScrollBar.GetScrollRange();
var vPercent = (curY - mScrollBar.mUpButton.Height) / (float)scrollRange;
if (vPercent < 0)
{
vPercent = 0;
}
else if (vPercent > 1)
{
vPercent = 1;
}
var newVal = mScrollBar.mMin + (mScrollBar._max - mScrollBar.mMin) * vPercent;
mScrollBar.SetValue((int)newVal);
}
if (msg.flags.HasFlag(MouseEventFlag.LeftReleased))
{
Globals.UiManager.UnsetMouseCaptureWidget(this);
}
}
else
{
if (msg.flags.HasFlag(MouseEventFlag.LeftClick))
{
Globals.UiManager.SetMouseCaptureWidget(this);
mDragGrabPoint = msg.Y;
mDragY = Y;
}
else if ((msg.flags & MouseEventFlag.ScrollWheelChange) != 0)
{
// Forward scroll wheel message to parent
mScrollBar.HandleMouseMessage(msg);
}
}
return(true);
}
public override bool HandleMouseMessage(MessageMouseArgs msg)
{
if (Globals.UiManager.GetMouseCaptureWidget() == this)
{
if (msg.flags.HasFlag(MouseEventFlag.PosChange))
{
int curX = _dragX + msg.X - _dragGrabPoint;
var hPercent = (curX - TrackStart) / (float)_slider.GetTrackWidth();
if (hPercent < 0)
{
hPercent = 0;
}
else if (hPercent > 1)
{
hPercent = 1;
}
var newVal = _slider.mMin + (_slider.mMax - _slider.mMin) * hPercent;
_slider.SetValue((int)Math.Round(newVal));
}
if (msg.flags.HasFlag(MouseEventFlag.LeftReleased))
{
Globals.UiManager.UnsetMouseCaptureWidget(this);
}
}
else
{
if (msg.flags.HasFlag(MouseEventFlag.LeftHeld))
{
Globals.UiManager.SetMouseCaptureWidget(this);
_dragGrabPoint = msg.X;
_dragX = X;
}
else if ((msg.flags & MouseEventFlag.ScrollWheelChange) != 0)
{
// Forward scroll wheel message to parent
_slider.HandleMouseMessage(msg);
}
}
return(true);
}
private bool OnMouseMove(MessageMouseArgs arg)
{
if (_rotationMode == 1)
{
_rotationMode = 2;
_rotationPivot = arg.X;
return(true);
}
else if (_rotationMode == 2)
{
int deltaX = arg.X - _rotationPivot;
_rotation -= deltaX * Angles.ToRadians(1.8f);
_rotationPivot = arg.X;
return(true);
}
return(false);
}
} // gets width of usable track area
public override bool HandleMouseMessage(MessageMouseArgs msg)
{
if ((msg.flags & MouseEventFlag.ScrollWheelChange) != 0)
{
if (msg.wheelDelta > 0)
{
SetValue(GetValue() - Quantum);
}
else if (msg.wheelDelta < 0)
{
SetValue(GetValue() + Quantum);
}
return(true);
}
return(base.HandleMouseMessage(msg));
}
internal override bool MouseMoved(IGameViewport viewport, MessageMouseArgs args)
{
ClearResults();
if (WallState == WallState.StartPoint || WallState == WallState.CenterPoint)
{
// get startpoint location from mouse
SetResultLocationFromMouse(args);
return(true);
}
var mouseLoc = GameViews.Primary.ScreenToTile(args.X, args.Y);
Trace.Assert(Result.HasLocation);
var maxRange = (float)(Picker.range * locXY.INCH_PER_FEET);
var dist = Result.location.DistanceTo(mouseLoc);
if (maxRange > dist)
{
maxRange = dist;
}
if (WallState == WallState.EndPoint)
{
// get radius and range up to mouse (trimmed by walls and such)
var radiusInch = Picker.radiusTarget * locXY.INCH_PER_FEET / 2.0f;
Picker.GetTrimmedRange(Result.location, mouseLoc, radiusInch, maxRange, locXY.INCH_PER_FEET * 5.0f);
// TODO: the 2.35 might be unneeded
Picker.degreesTarget =
2.3561945f -
Result.location.RotationTo(mouseLoc); // putting this in radians, unlike the usual usage
Picker.GetTargetsInPath(Result.location, mouseLoc, radiusInch);
Picker.DoExclusions();
return(true);
}
else if (WallState == WallState.Radius)
{
// todo
}
return(false);
}
internal override bool LeftMouseButtonReleased(IGameViewport viewport, MessageMouseArgs args)
{
if (HandleClickInUnexploredArea(args.X, args.Y))
{
return(false);
}
ClearResults();
var raycastFlags = PickerState.GetFlagsFromExclusions();
if (!GameSystems.Raycast.PickObjectOnScreen(viewport, args.X, args.Y, out var objFound, raycastFlags))
{
return(false);
}
if (!PickerState.Picker.flagsTarget.HasFlag(UiPickerFlagsTarget.LosNotRequired) &&
PickerState.Picker.LosBlocked(objFound))
{
return(false);
}
if (PickerState.Picker.flagsTarget.HasFlag(UiPickerFlagsTarget.Exclude1st) &&
!PickerState.Picker.TargetValid(objFound))
{
return(false);
}
if (!PickerState.Picker.CheckTargetVsIncFlags(objFound))
{
return(false);
}
Result.flags = PickerResultFlags.PRF_HAS_SINGLE_OBJ;
Result.handle = objFound;
SetResultLocation(objFound);
return(FinalizePicker());
}
internal override bool RightMouseButtonReleased(IGameViewport viewport, MessageMouseArgs args)
{
ClearResults();
if (WallState == WallState.StartPoint || WallState == WallState.CenterPoint)
{
Result.flags = PickerResultFlags.PRF_CANCELLED;
Picker.callback?.Invoke(ref Result, PickerState.CallbackArgs);
return(true);
}
if (WallState == WallState.EndPoint)
{
WallState = WallState.StartPoint;
_wallEndPoint = LocAndOffsets.Zero;
}
else if (WallState == WallState.Radius)
{
WallState = WallState.CenterPoint;
}
return(true);
}
internal override bool LeftMouseButtonReleased(IGameViewport viewport, MessageMouseArgs args)
{
ClearResults();
var raycastFlags = PickerState.GetFlagsFromExclusions();
if (!GameSystems.Raycast.PickObjectOnScreen(viewport, args.X, args.Y, out var target, raycastFlags) ||
target != Picker.caster)
{
return(true);
}
if (!Picker.flagsTarget.HasFlag(UiPickerFlagsTarget.Radius))
{
Picker.SetSingleTgt(target);
}
else
{
Picker.SetAreaTargets(target.GetLocationFull());
}
return(FinalizePicker());
}
public void TestMouseWheelZoom()
{
TakeScreenshot("before_zoom");
IGameViewport gv = UiSystems.GameView;
gv.Zoom.Should().Be(1.0f);
var initialCenter = gv.CenteredOn.ToInches2D(); // Remember where it's centered now
// One "pip" of scroll-wheel -> 10% zoom
var msg = new MessageMouseArgs(0, 0, 1, MouseEventFlag.ScrollWheelChange);
UiSystems.GameView.HandleMouseMessage(msg);
TakeScreenshot("after_zoom1");
gv.Zoom.Should().BeApproximately(1.1f, 0.001f);
UiSystems.GameView.HandleMouseMessage(msg);
TakeScreenshot("after_zoom2");
gv.Zoom.Should().BeApproximately(1.2f, 0.001f);
// Check that the camera stays centered on the original center
var centerAfterZoom = gv.CenteredOn.ToInches2D();
var distanceFromInitialCenter = Vector2.Subtract(initialCenter, centerAfterZoom).Length();
distanceFromInitialCenter.Should().BeLessOrEqualTo(3);
// Initiate and immediately release MMB scrolling because previously the state would get de-synched
// and cause the view to jerk around
UiSystems.GameView.HandleMouseMessage(new MessageMouseArgs(0, 0, 0, MouseEventFlag.MiddleClick));
UiSystems.GameView.HandleMouseMessage(new MessageMouseArgs(1, 0, 0, MouseEventFlag.PosChange));
UiSystems.GameView.HandleMouseMessage(new MessageMouseArgs(-1, 0, 0, MouseEventFlag.PosChange));
UiSystems.GameView.HandleMouseMessage(new MessageMouseArgs(0, 0, 0, MouseEventFlag.MiddleReleased));
var centerAfterMove = gv.CenteredOn.ToInches2D();
Vector2.Subtract(centerAfterZoom, centerAfterMove).Length().Should().BeLessOrEqualTo(3);
}
public override bool HandleMouseMessage(MessageMouseArgs msg)
{
var area = GetContentArea();
// Iterate in reverse order since this list is ordered in ascending z-order
for (var i = mChildren.Count - 1; i >= 0; i--)
{
var child = mChildren[i];
int x = msg.X - area.X;
int y = msg.Y - area.Y + GetScrollOffsetY();
if (child.Visible & x >= child.X && y >= child.Y && x < child.X + child.Width &&
y < child.Y + child.Height)
{
if (child.HandleMouseMessage(msg))
{
return(true);
}
}
}
return(base.HandleMouseMessage(msg));
}
internal override bool LeftMouseButtonClicked(IGameViewport viewport, MessageMouseArgs args)
{
return(true);
}
private bool HandleMouseMessage(MessageMouseArgs msg)
{
if (msg.flags.HasFlag(MouseEventFlag.LeftReleased))
{
if (UiSystems.CharSheet.State == CharInventoryState.CastingSpell)
{
UiSystems.CharSheet.CallItemPickCallback(CurrentItem);
return(true);
}
var droppedOn = Globals.UiManager.GetWidgetAt(msg.X, msg.Y);
var item = UiSystems.CharSheet.Inventory.DraggedObject;
if (item == null || droppedOn == _slotWidget)
{
return(true);
}
if (droppedOn is PaperdollSlotWidget targetSlotWidget)
{
Insert(ActingCritter, CurrentItem, targetSlotWidget);
}
else if (droppedOn == UiSystems.CharSheet.Inventory.UseItemWidget)
{
UseItem(ActingCritter, CurrentItem);
}
else if (droppedOn == UiSystems.CharSheet.Inventory.DropItemWidget)
{
DropItem(ActingCritter, CurrentItem);
}
else if (UiSystems.CharSheet.State == CharInventoryState.Looting &&
UiSystems.CharSheet.Looting.TryGetInventoryIdxForWidget(droppedOn, out var lootingInvIdx))
{
InsertIntoLootContainer(ActingCritter, CurrentItem, lootingInvIdx);
}
else if (UiSystems.CharSheet.State == CharInventoryState.Bartering &&
UiSystems.CharSheet.Looting.TryGetInventoryIdxForWidget(droppedOn, out var barterInvIdx))
{
InsertIntoBarterContainer(ActingCritter, CurrentItem, barterInvIdx);
}
else if (UiSystems.Party.TryGetPartyMemberByWidget(droppedOn, out var partyMember))
{
InsertIntoPartyPortrait(ActingCritter, CurrentItem, partyMember);
}
else if (UiSystems.CharSheet.Inventory.TryGetInventoryIdxForWidget(droppedOn, out var invIdx))
{
InsertIntoInventorySlot(ActingCritter, CurrentItem, invIdx);
}
UiSystems.CharSheet.Inventory.DraggedObject = null;
Tig.Mouse.ClearDraggedIcon();
}
else if (msg.flags.HasFlag(MouseEventFlag.RightReleased))
{
var critter = ActingCritter;
var item = CurrentItem;
if (item != null)
{
// If the item is in another container, then we'll simply try to take it
if (GameSystems.Item.GetParent(item) != critter)
{
}
// If the item is currently equipped, unequip it,
else if (GameSystems.Item.IsEquipped(item))
{
UnequipItem(item, critter);
}
// otherwise equip it
else
{
EquipItem(item, critter);
}
}
return(true);
}
return(true);
}
internal override bool LeftMouseButtonReleased(IGameViewport viewport, MessageMouseArgs args)
{
MouseMoved(viewport, args);
return(FinalizePicker());
}
public Message(MessageMouseArgs mouseArgs) : this(MessageType.MOUSE)
{
MouseArgs = mouseArgs;
}
private bool AbilityScoreMouseHandler(MessageMouseArgs msg, AbilityScoreValueWidget widget)
{
if (Globals.UiManager.GetMouseCaptureWidget() == widget)
{
if ((msg.flags & MouseEventFlag.LeftReleased) != 0)
{
Tig.Mouse.SetCursorDrawCallback(null);
Globals.UiManager.UnsetMouseCaptureWidget(widget);
widget.IsDragging = false;
var widgetUnderCursor = Globals.UiManager.GetWidgetAt(msg.X, msg.Y);
if (widgetUnderCursor is AbilityScoreValueWidget otherAbilityScoreValue)
{
// Swap the two values
var tmp = otherAbilityScoreValue.Value;
otherAbilityScoreValue.Value = widget.Value;
widget.Value = tmp;
OnAbilityScoresChanged();
}
}
return(true);
}
if (widget.Value == -1)
{
// Do not allow interaction with unassigned ability scores
return(true);
}
// Allow quickly swapping values between the two columns, but only when we actually have rolled values
// (not in point buy mode)
if (!_pkt.isPointbuy && (msg.flags & MouseEventFlag.RightClick) != 0)
{
var destinationPool = widget.IsAssigned ? charGenRolledStats : _pkt.abilityStats;
for (var i = 0; i < destinationPool.Length; i++)
{
if (destinationPool[i] == -1)
{
destinationPool[i] = widget.Value;
widget.Value = -1;
OnAbilityScoresChanged();
return(true);
}
}
}
else if ((msg.flags & MouseEventFlag.LeftHeld) != 0)
{
if (!Globals.UiManager.SetMouseCaptureWidget(widget))
{
// Something else has the mouse capture right now (how are we getting this message then...?)
return(true);
}
// Figure out where in the widget we got clicked so we can draw the dragged text with the proper offset
var globalContentArea = widget.GetContentArea(true);
var localX = msg.X - globalContentArea.X;
var localY = msg.Y - globalContentArea.Y;
_draggedAbilityScoreLabel.Text = widget.Value.ToString();
widget.IsDragging = true;
// This will draw the ability score being dragged under the mouse cursor
Tig.Mouse.SetCursorDrawCallback((x, y, arg) =>
{
var point = new Point(x, y);
point.Offset(-localX, -localY);
var contentArea = new Rectangle(point, widget.GetSize());
_draggedAbilityScoreLabel.SetBounds(contentArea);
_draggedAbilityScoreLabel.Render();
});
}
return(true);
}
