private void Update()
{
switch (status)
{
case DragStatus.Align:
{
alignStep += Time.deltaTime * alignRatio;
alignNext = Vector2.Lerp(alignPosition, center, alignStep);
alignVector = alignNext - alignPosition;
alignPosition = alignNext;
Shift(alignVector);
if (alignStep > 1)
{
status = DragStatus.Idle;
}
}
break;
default: break;
}
}
private void ProcessDrag(DragStatus status, Vector3 position, Vector3 last)
{
if (OnDragEvent != null)
{
OnDragEvent(status, position, last);
}
}
protected override bool OnDragEnd(InputState state)
{
Trace.Assert(dragStatus != DragStatus.None, "We should never receive OnDragEnd if we are not dragging.");
dragStatus = DragStatus.None;
if (averageDragTime <= 0.0)
{
return(true);
}
double velocity = averageDragDelta / averageDragTime;
// Detect whether we halted at the end of the drag and in fact should _not_
// perform a flick event.
const double velocity_cutoff = 0.1;
if (Math.Abs(Math.Pow(0.95, Time.Current - lastDragTime) * velocity) < velocity_cutoff)
{
velocity = 0;
}
// Differentiate f(t) = distance * (1 - exp(-t)) w.r.t. "t" to obtain
// velocity w.r.t. time. Then rearrange to solve for distance given velocity.
double distance = velocity / (1 - Math.Exp(-DistanceDecayDrag));
offset((float)distance, true, DistanceDecayDrag);
return(true);
}
private void Finish()
{
bool spring = false;
switch (direction)
{
case Direction.Horizontal:
spring = Math.Abs(delta.x) < cell.x / 2 && Math.Abs(delta.x) > this.spring;
break;
case Direction.Vertical:
spring = Math.Abs(delta.y) < cell.y / 2 && Math.Abs(delta.y) > this.spring;
break;
}
for (int i = 0; i < items.Count; i++)
{
if (Between(items[i].Position, center))
{
alignPosition = items[i].Position;
break;
}
}
if (spring)
{
switch (direction)
{
case Direction.Horizontal:
if (delta.x > 0)
{
Front();
}
else
{
Back();
}
break;
case Direction.Vertical:
if (delta.y > 0)
{
Back();
}
else
{
Front();
}
break;
}
}
else
{
alignStep = 0;
status = DragStatus.Align;
Finish(center);
}
}
protected override bool OnDragStart(InputState state)
{
if (dragStatus != DragStatus.None)
{
return(false);
}
lastDragTime = Time.Current;
averageDragDelta = averageDragTime = 0;
dragStatus = shouldPerformRelativeDrag(state) ? DragStatus.Relative : DragStatus.Absolute;
return(true);
}
public void Back()
{
if (status == DragStatus.Align && alignStep < 0.1f)
{
return;
}
alignPosition += cell;
alignStep = 0;
status = DragStatus.Align;
Finish(center + alignPosition);
}
private void OnDrag(DragStatus status, Vector3 position, Vector3 last)
{
switch (status)
{
case DragStatus.Begin:
m_points.Add(position);
m_trailRenderer = GameObject.Instantiate(m_pointRenderer);
m_trailRenderer.transform.position = Camera.main.ScreenToWorldPoint(new Vector3(position.x, position.y, 10));
break;
case DragStatus.Moving:
m_points.Add(position);
m_trailRenderer.transform.position = Camera.main.ScreenToWorldPoint(new Vector3(position.x, position.y, 10));
break;
case DragStatus.End:
m_points.Add(position);
ProcessPoints();
break;
}
}
public void HandleDrag(DragStatus status, Vector3 position, Vector3 last)
{
if (status == DragStatus.Begin)
{
Ray ray = _mainCamera.ScreenPointToRay(position);
var hit = Physics2D.Raycast(ray.origin, ray.direction, 10000);
if (hit.transform)
{
var shipVisual = hit.transform.GetComponent <ShipVisual>();
if (shipVisual)
{
_dragShipVisual = shipVisual;
_dragOriginalPosition = hit.point;
_dragOriginalShipPosition = shipVisual.transform.position;
_dragOffset = new Vector3(hit.point.x, hit.point.y, hit.transform.position.z) - hit.transform.position;
}
}
}
else if (status == DragStatus.Moving)
{
if (_dragShipVisual != null)
{
Ray ray = _mainCamera.ScreenPointToRay(position);
Vector3 newPos = new Vector3(ray.origin.x, ray.origin.y, _dragOriginalPosition.z);
_dragShipVisual.transform.position = _dragOriginalShipPosition + (newPos - _dragOriginalPosition);
}
}
else if (status == DragStatus.End)
{
if (_dragShipVisual != null)
{
MoveShip(_dragShipVisual.Data, _dragOriginalShipPosition, _dragShipVisual.transform.position);
_dragShipVisual = null;
}
}
}
// Start is called before the first frame update
void Start()
{
dragStatus = DragStatus.None;
pointerStatus = PointerStatus.None;
EventTrigger.Entry entry;
entry = new EventTrigger.Entry();
entry.eventID = EventTriggerType.BeginDrag;
entry.callback.AddListener((data) =>
{
dragStatus = DragStatus.Begin;
});
trigger.triggers.Add(entry);
entry = new EventTrigger.Entry();
entry.eventID = EventTriggerType.EndDrag;
entry.callback.AddListener((data) =>
{
dragStatus = DragStatus.End;
});
trigger.triggers.Add(entry);
entry = new EventTrigger.Entry();
entry.eventID = EventTriggerType.PointerEnter;
entry.callback.AddListener((data) =>
{
pointerStatus = PointerStatus.Enter;
});
trigger.triggers.Add(entry);
entry = new EventTrigger.Entry();
entry.eventID = EventTriggerType.PointerExit;
entry.callback.AddListener((data) =>
{
pointerStatus = PointerStatus.Exit;
});
trigger.triggers.Add(entry);
}
private static void PostUpdate(float dt)
{
Reset();
if (TouchEnabled) //if touch screen is enabled
{
TouchPoints = TouchPanel.GetState();
GestureSample gs; //tmp varialbe for the gestors
while (TouchPanel.IsGestureAvailable) //if the is a gesture to process
{
gs = TouchPanel.ReadGesture(); //get the gesture
switch (gs.GestureType) //check the type
{
case GestureType.DoubleTap:
DoubleTap = true;
break;
case GestureType.Tap:
_lButtonClick = true; //set clicked flag to true
_position = gs.Position; //set the mouse pos
LiteralPosition = _position;
_position = _position / _scaleBy;
LbuttonDown = true;
break;
case GestureType.FreeDrag:
_drag = new DragEvent(gs.Delta, gs.Position, true);
break;
case GestureType.Flick:
if (Math.Abs(gs.Delta.X) > Math.Abs(gs.Delta.Y)) //if horizontal flick
{
if (gs.Delta.X > 0) //if right
{
FlickRight = true;
}
else
{
FlickLeft = true;
}
}
else //if vertical flick
{
if (gs.Delta.Y > 0) //if up
{
FlickUp = true;
}
else
{
FlickDown = true;
}
}
break;
}
}
}
if (LbuttonDown)
{
if (OnLeftMouseDown != null)
{
OnLeftMouseDown(Position);
}
}
if (MouseS.LeftButton == ButtonState.Released && LastMouseS.LeftButton == ButtonState.Pressed)
{
if (OnLeftMouseRelease != null)
{
OnLeftMouseRelease(Position);
}
}
if (MouseS.LeftButton == ButtonState.Released || _lmouse.LeftButton == ButtonState.Released)
{
_dragStatus = DragStatus.None; //reset the drag as there is no drag
}
if (_dragStatus == DragStatus.DetectedHold)
{
//if (_mouse.Position != _lmouse.Position)
_drag = new DragEvent((_mouse.Position - _lmouse.Position).ToVector2(), _lmouse.Position.ToVector2(), true);
}
//first start left click detection
if (_mouse.LeftButton == ButtonState.Pressed && _lmouse.LeftButton == ButtonState.Released)
{
_lClickTimer = 0;
_initalClickPosition = _position;
}
if (_mouse.LeftButton == ButtonState.Pressed && LastMouseS.LeftButton == ButtonState.Pressed)
{
_lClickTimer += dt;
_leftButtonHold = true;
}
//on release
if (_mouse.LeftButton == ButtonState.Released && _lmouse.LeftButton == ButtonState.Pressed)
{
if (_lClickTimer < ClickDetectionInterval && !_rightButtonHold && !_drag.Active)
{
if (Vector2.Distance(_position, _initalClickPosition) < 8)
{
_lButtonClick = true;
}
}
}
if (_mouse.RightButton == ButtonState.Pressed && _lmouse.RightButton == ButtonState.Released && _mouse.LeftButton == ButtonState.Released)
{
_rButtonClick = true;
}
LeftButtonReleased = _mouse.LeftButton == ButtonState.Released && _lmouse.LeftButton == ButtonState.Pressed;
if (_mouse.LeftButton == ButtonState.Pressed && _lmouse.LeftButton == ButtonState.Pressed)
{
_leftButtonHold = true;
if (_dragStatus == DragStatus.None) //if start of drag
{
_dragStatus = DragStatus.DetectedHold;
}
}
if (_mouse.RightButton == ButtonState.Pressed && _lmouse.RightButton == ButtonState.Pressed)
{
_rightButtonHold = true;
}
RButtonReleased = _mouse.RightButton == ButtonState.Released && _lmouse.RightButton == ButtonState.Pressed;
MButtonClick = _mouse.MiddleButton == ButtonState.Pressed && _lmouse.MiddleButton == ButtonState.Released;
MButtonDown = _mouse.MiddleButton == ButtonState.Pressed && _lmouse.MiddleButton == ButtonState.Pressed;
MButtonRelesed = _mouse.MiddleButton == ButtonState.Released && _lmouse.MiddleButton == ButtonState.Pressed;
if (_mouse.ScrollWheelValue != _lmouse.ScrollWheelValue)
{
_scrollAmount = (_mouse.ScrollWheelValue - _lmouse.ScrollWheelValue) / 120;
if (OnMouseScroll != null)
{
OnMouseScroll(_mouse.ScrollWheelValue - _lmouse.ScrollWheelValue);
}
}
}
public virtual void SetDragStatus(DragStatus status)
{
createInstance();
BaseEntity.SetDragStatus(status);
tr.Dispose();
}
public virtual void SetDragStatus(DragStatus status)
{
createInstance();
BaseEntity.SetDragStatus(status);
tr.Dispose();
}
private void OnBeginDrag()
{
status = DragStatus.Drag;
}
private void OnDragEvent(DragStatus status, Vector3 position, Vector3 last)
{
Debug.LogWarning("OnDragEvent: " + status + " : " + position + " : " + last);
}
private void OnBeginDrag()
{
this.delta = Vector2.zero;
status = DragStatus.Drag;
}
