internal void Reset(WorldFile worldFile)
{
Position = worldFile.KarelStartPosition;
Direction = worldFile.KarelStartDirection;
PositionChanged.Invoke(this);
DirectionChanged.Invoke(this);
}
private void Update()
{
if (Input.touchCount == 0)
{
DirectionChanged?.Invoke(Vector2Int.up);
return;
}
Touch directionTouch = Input.touches[0];
if (directionTouch.phase == TouchPhase.Began)
{
TouchData touchData = new TouchData(directionTouch.position, Time.time);
_directionTouch = touchData;
if (IsDoubleClicked(directionTouch))
{
DoubleClicked?.Invoke();
}
}
else if (directionTouch.phase == TouchPhase.Stationary && Time.time - _directionTouch.Time > 0.1f)
{
int direction = (int)Mathf.Sign(_directionTouch.Position.x - Camera.main.pixelWidth / 2);
DirectionChanged?.Invoke(Vector2Int.left * direction);
}
if (Input.touchCount > 1)
{
Touch lastTouch = Input.touches[Input.touchCount - 1];
if (IsDoubleClicked(lastTouch))
{
DoubleClicked?.Invoke();
}
}
}
/// <summary>
/// Callback on internal implementation state changed to synchronize the cached state of this wrapper.
/// </summary>
/// <param name="negotiatedDirection">Current negotiated direction of the transceiver</param>
/// <param name="desiredDirection">Current desired direction of the transceiver</param>
internal void OnStateUpdated(Direction?negotiatedDirection, Direction desiredDirection)
{
_desiredDirection = desiredDirection;
if (negotiatedDirection == NegotiatedDirection)
{
return;
}
bool hadSendBefore = HasSend(NegotiatedDirection);
bool hasSendNow = HasSend(negotiatedDirection);
bool hadRecvBefore = HasRecv(NegotiatedDirection);
bool hasRecvNow = HasRecv(negotiatedDirection);
NegotiatedDirection = negotiatedDirection;
if (hadSendBefore != hasSendNow)
{
_localTrack?.OnMute(!hasSendNow);
}
if (hadRecvBefore != hasRecvNow)
{
_remoteTrack?.OnMute(!hasRecvNow);
}
DirectionChanged?.Invoke(this);
}
public void OnStartMoving()
{
movingDirection = GetDirectionToRequestedFloor(currRequest.FloorNum);
DirectionChanged.Invoke(movingDirection);
nextFloorNum = movingDirection == ElevatorDirection.up ? currFloorNum + 1 : currFloorNum - 1;
nextFloorNum = Mathf.Clamp(nextFloorNum, 1, Floors.Count);
}
public async Task TurnLeft()
{
await _program.AwaitNextStep();
Direction = Direction.RotateCounterClockwise();
DirectionChanged?.Invoke(this);
}
public static void OnDirectionChanged()
{
#if DEBUG
Debug.Log($"[RCSBA EVENT]: Direction changed to {RCSBuildAid.Direction}");
#endif
DirectionChanged?.Invoke(RCSBuildAid.Direction);
}
private void controllerPictureBox_MouseMove(object sender, MouseEventArgs e)
{
if (changing)
{
angle = (float)Atan2(e.Y - Width / 2, e.X - Height / 2);
g.Clear(Color.Transparent);
Draw();
DirectionChanged?.Invoke(angle);
}
}
protected override Task OnParametersSetAsync()
{
if (IsRemovable &&
Direction != SortDirection.Ascending &&
Direction != SortDirection.Descending)
{
Direction = SortDirection.Ascending;
return(DirectionChanged.InvokeAsync(Direction));
}
return(Task.CompletedTask);
}
protected override void OnUpdate()
{
base.OnUpdate();
if (!UIUtil.IsMouseOverUI() && DirectionRule.Execute())
{
DirectionChanged?.Invoke(this);
}
if (!UIUtil.IsMouseOverUI() && SpinRule.Execute())
{
}
}
private void Update()
{
if (Input.GetMouseButtonDown(0))
{
tapPosition = Input.mousePosition;
}
if (Input.GetMouseButton(0))
{
DirectionChanged?.Invoke(Input.mousePosition - tapPosition);
}
if (Input.GetMouseButtonUp(0))
{
PointerUp?.Invoke();
}
}
public async Task SetNewSortAsync(string sortId, MatSortDirection direction)
{
SortId = sortId;
Direction = direction;
await SortIdChanged.InvokeAsync(sortId);
await DirectionChanged.InvokeAsync(direction);
await SortChanged.InvokeAsync(new MatSortChangedEvent()
{
SortId = sortId,
Direction = direction
});
this.StateHasChanged();
}
protected override Task OnToggle()
{
if (IsStatic)
{
return(Task.CompletedTask);
}
Direction = Direction switch
{
SortDirection.Ascending => SortDirection.Descending,
SortDirection.Descending => IsRemovable ? SortDirection.Ascending : SortDirection.None,
_ => SortDirection.Ascending
};
return(DirectionChanged.InvokeAsync(Direction));
}
/// <summary>
/// Kääntyy.
/// </summary>
/// <param name="direction">Suunta</param>
public void Turn(Direction direction)
{
if (direction == FacingDirection || (direction != Direction.Left && direction != Direction.Right))
{
return;
}
TextureWrapSize = new Vector(-TextureWrapSize.X, TextureWrapSize.Y);
if (Weapon != null)
{
Weapon.TextureWrapSize = new Vector(1, direction.GetVector().X);
Weapon.Angle = Angle.Supplement(Weapon.Angle);
}
_facingDirection = direction;
DirectionChanged?.Invoke(direction);
}
private void Update()
{
if (Input.GetKeyDown(KeyCode.LeftArrow))
{
DirectionChanged?.Invoke(Vector2Int.right);
}
if (Input.GetKeyDown(KeyCode.RightArrow))
{
DirectionChanged?.Invoke(Vector2Int.left);
}
if (Input.GetKeyUp(KeyCode.LeftArrow) || Input.GetKeyUp(KeyCode.RightArrow))
{
DirectionChanged?.Invoke(Vector2Int.up);
}
if (Input.GetKeyDown(KeyCode.Space))
{
DoubleClicked?.Invoke();
}
}
/// <summary>
/// Kääntyy.
/// </summary>
/// <param name="direction">Suunta</param>
public void Turn(Direction direction)
{
if (direction == FacingDirection || (direction != Direction.Left && direction != Direction.Right))
{
return;
}
walkSteps = 0;
TextureWrapSize = new Vector(-TextureWrapSize.X, TextureWrapSize.Y);
if (Weapon != null)
{
Weapon.X *= -1;
Weapon.TextureWrapSize = new Vector(1, -Weapon.TextureWrapSize.Y);
Weapon.Angle = Angle.Supplement(Weapon.Angle);
}
_curDirection = direction;
DirectionChanged?.Invoke(direction);
}
protected virtual void OnDirectionChanged(string dir)
{
DirectionEvent de = new DirectionEvent();
de.Direction = dir;
DirectionChanged?.Invoke(this, de);
}
protected virtual void OnDirectionChanged(Direction dir)
{
DirectionEventArgs de = new DirectionEventArgs(dir);
DirectionChanged?.Invoke(this, de);
}
private void OnDirectionChanged(Direction direction)
{
CurDirection = direction;
DirectionChanged?.Invoke(direction);
InnerOnDirectionChanged(direction);
}
/// <summary>
/// Occurs when direction changed
/// </summary>
/// <param name="direction"></param>
protected virtual void OnDirectionChanged(Direction direction)
{
DirectionChanged?.Invoke(this, direction);
OnLookChanged(new EventArgs());
}
protected virtual void OnDirectionChanged()
{
DirectionChanged?.Invoke();
}