static void Main(string[] args)
{
building = new Building.Building(10, 4);
building.ElevaterAssigned += Building_ElevaterAssigned;
building.ElevaterServed += Building_ElevaterServed;
building.ElevaterReAssigned += Building_ElevaterReAssigned;
// The code provided will print ‘Hello World’ to the console.
// Press Ctrl+F5 (or go to Debug > Start Without Debugging) to run your app.
for (int i = 0; i < 10; i++)
{
bool direction = rand.Next(2) == 1;
int currentFloor = rand.Next(building.Floors); // currentFloor floor from where user is requesting the elevator
var request = new ElevatorRequest()
{
Direction = direction,
Floor = currentFloor
};
building.SignalElivatorFromOutside(request);
Console.WriteLine($"Elevator requested from {request.Floor} Floor towards direction " + ((request.Direction) ? "UP" : "Down"));
Thread.Sleep(5000);
}
Console.ReadKey();
}
void Awake()
{
requests = new Queue <ElevatorRequest>();
currentRequest = new ElevatorRequest(-1, false); // no request
numRequests = 0;
wait = 0;
}
public void CreateMessageShouldCreateCorrectMessage(Elevator elevator, ElevatorRequest request, string expectedMessage)
{
var logger = new FakeLogMovementService();
var actualMessage = logger.FakeCreateMessage(elevator, request);
Assert.Equal(expectedMessage, actualMessage);
}
public void DirectionShouldBeCorrect(int fromFloor, int toFloor, Direction expected)
{
var actual = new ElevatorRequest {
FromFloor = fromFloor, ToFloor = toFloor
};
Assert.Equal(expected, actual.Direction);
}
public async Task MoveDownAsync(ElevatorRequest request, CancellationToken cancellationToken = default)
{
for (var currentFloor = request.FromFloor; currentFloor >= request.ToFloor; currentFloor--)
{
SetElevatorCurrentFloorTo(currentFloor);
_logger.LogMovement(Elevator, request);
await _waiterService.WaitForSecondsAsync(1, cancellationToken);
}
}
private static void Building_ElevaterServed(ElevatorRequest request)
{
if (request.FromInside)
{
Console.WriteLine($"Elevator Intenally served by Elevator Id: {request.ElevatorId} to {request.Floor} Floor");
}
else
{
Console.WriteLine($"Elevator served by Elevator Id: {request.ElevatorId}");
int requestedFloor = rand.Next(building.Floors - 1);
building.SignalElevatorFromInside(request.ElevatorId, requestedFloor);
Console.WriteLine($"Elevator requested from {request.ElevatorId} for {requestedFloor} Floor");
}
}
public void Serve_Up_Request_Test()
{
var request = new ElevatorRequest()
{
CurrentFloor = 5, Direction = Status.Up
};
var servingElevator = new Core.Elevator()
{
Direction = Status.Up
};
servingElevator.EnqueueRequest(request);
Assert.IsTrue(servingElevator.IsRequestsEmpty());
}
public async Task HandleRequestsAsyncShouldMoveElevatorToCorrectFloor(ElevatorRequest request)
{
_queue.Setup(q => q.ReadAllAsync(It.IsAny <CancellationToken>()))
.Returns(GetRequestAsAsyncEnumerable(request));
var elevatorMover = new ElevatorMover(
new Elevator(), _movementLogger.Object, _waiterService.Object
);
var requestHandler = new ElevatorRequestHandler(
_queue.Object,
elevatorMover
);
await requestHandler.HandleRequestsAsync();
Assert.Equal(request.ToFloor, elevatorMover.Elevator.CurrentFloor);
}
public void HasToMoveToAnotherFloorToPickUpPassengerShouldBeTrueIfHasToMove()
{
var request = new ElevatorRequest()
{
FromFloor = 5, ToFloor = 0
};
var elevator = new Elevator()
{
CurrentFloor = 0
};
var elevatorMover = new ElevatorMover(
elevator,
_movementLogger.Object,
_waiterService.Object
);
Assert.True(elevatorMover.HasToMoveToAnotherFloorToPickUpPassengerFor(request));
}
void Update()
{
if (currentRequest.floor < 0)
{
if (numRequests > 0)
{
currentRequest = requests.Dequeue();
numRequests--;
wait = 30; // wait for 30 frames
}
}
else
{
if (wait > 0)
{
wait--;
return;
}
float targetY = currentRequest.floor * 2.0f - transform.parent.localPosition.y;
// Move to request
if (Mathf.Abs(targetY - transform.localPosition.y) <= speed)
{
transform.localPosition = new Vector3(transform.localPosition.x,
targetY,
transform.localPosition.z);
currentRequest.floor = -1;
}
else
{
if (targetY > transform.localPosition.y)
{
transform.Translate(new Vector3(0.0f, speed, 0.0f));
}
else
{
transform.Translate(new Vector3(0.0f, -speed, 0.0f));
}
}
}
}
public async Task MoveUpAsyncShouldMoveElevatorUpwards()
{
var request = new ElevatorRequest {
FromFloor = 0, ToFloor = 5
};
var elevator = new Elevator
{
CurrentFloor = 0,
Name = nameof(MoveDownAsyncShouldMoveElevatorDownwards)
};
var elevatorMover = new ElevatorMover(
elevator,
_movementLogger.Object,
_waiterService.Object
);
await elevatorMover.MoveUpAsync(request);
Assert.Equal(request.ToFloor, elevator.CurrentFloor);
}
public async Task MoveDownAsyncShouldAbortIfCanceled()
{
var cts = new CancellationTokenSource();
var request = new ElevatorRequest {
FromFloor = 5, ToFloor = 0
};
var elevator = new Elevator
{
CurrentFloor = 5,
Name = nameof(MoveDownAsyncShouldMoveElevatorDownwards)
};
var elevatorMover = new ElevatorMover(
elevator,
_movementLogger.Object,
new WaiterService()
);
cts.Cancel();
await Assert.ThrowsAsync <TaskCanceledException>(() =>
elevatorMover.MoveDownAsync(request, cts.Token)
);
}
public void RegisterElevatorRequest(ElevatorRequest request)
{
m_openRequests.Add(request);
}
private static void Building_ElevaterReAssigned(ElevatorRequest request)
{
Console.WriteLine($"Reassigned Elevator id {request.ElevatorId}");
}
public void addGoal(ElevatorRequest request)
{
m_goals.Add(request);
}
public void AddRequest(ElevatorRequest request) => _requests.Add(request);
// The
void proceedToNextState(int stepNumber)
{
try
{
System.Diagnostics.Debug.WriteLine("Elevator: "
+ m_elevator.name
+ " At height: "
+ m_state.height.ToString()
+ " action: "
+ m_action.actionName);
if (m_action.actionName == ElevatorAction.Opening)
{
m_state.door = DoorState.Open();
int floorNumber = m_state.height / building.heightPerFloor;
m_goals.RemoveAll((request) =>
request.floorNumber == floorNumber);
m_action.duration -= 1;
if (m_action.duration <= 0)
{
m_action = new ElevatorAction(ElevatorAction.Stopped, 2);
}
return;
}
if (m_action.actionName == ElevatorAction.Stopping)
{
ElevatorState nextState = m_state;
nextState.movement = ElevatorMovement.Stopped();
nextState.height = m_action.terminalHeight;
m_state = nextState;
m_action = new ElevatorAction(ElevatorAction.Opening,
m_state.height);
return;
}
if (m_action.actionName == ElevatorAction.Move_Up)
{
HandleMovementUp(stepNumber);
return;
}
if (m_action.actionName == ElevatorAction.Move_Down)
{
HandleMovementUp(stepNumber);
return;
}
//Fallback: Act as if the elevator is stopped.
ElevatorRequest toExecute = getNextGoal();
if (toExecute != null)
{
int targetHeight = toExecute.floorNumber * building.heightPerFloor;
if (targetHeight == m_state.height)
{
m_action = new ElevatorAction(ElevatorAction.Opening, targetHeight);
}
else if (targetHeight > m_state.height)
{
m_action = new ElevatorAction(ElevatorAction.Move_Up,
targetHeight);
}
else
{
m_action = new ElevatorAction(ElevatorAction.Move_Down,
targetHeight);
}
}
}
catch (Exception exc)
{
System.Diagnostics.Debug.WriteLine(exc.ToString());
}
}
public override void LogMovement(Elevator elevator, ElevatorRequest request) => _logger.LogInformation(CreateMessage(elevator, request));
public override void LogMovement(Elevator elevator, ElevatorRequest request) => Console.WriteLine(CreateMessage(elevator, request));
public async Task MoveToFloorAsyncShouldMoveUpIfDirectionIsUp(Elevator elevator, ElevatorRequest request)
{
var elevatorMover = new ElevatorMover(
elevator,
_movementLogger.Object,
_waiterService.Object
);
await elevatorMover.MoveToFloorAsync(request);
Assert.Equal(request.ToFloor, elevator.CurrentFloor);
}
internal string FakeCreateMessage(Elevator elevator, ElevatorRequest request) => CreateMessage(elevator, request);
public Task MoveToFloorAsync(ElevatorRequest request, CancellationToken cancellationToken = default) =>
request.Direction == Direction.Up
? MoveUpAsync(request, cancellationToken)
: MoveDownAsync(request, cancellationToken);
protected string CreateMessage(Elevator elevator, ElevatorRequest request) =>
$"{elevator.Name}: {CreateSymbolForDirection(request.Direction)} Current: {elevator.CurrentFloor} [Request: from {request.FromFloor} -> to {request.ToFloor}]";
public bool HasToMoveToAnotherFloorToPickUpPassengerFor(ElevatorRequest request) => Elevator.CurrentFloor != request.FromFloor;
public abstract void LogMovement(Elevator elevator, ElevatorRequest request);
public override void LogMovement(Elevator elevator, ElevatorRequest request)
{
throw new System.NotImplementedException();
}
public static async IAsyncEnumerable <ElevatorRequest> GetRequestAsAsyncEnumerable(ElevatorRequest request)
{
yield return(request);
await Task.CompletedTask;
}
