private void UpdateCountingDown()
{
if (GetPlayersInElevator() < PlayersToTriggerStart)
{
_state = ElevatorState.WaitingForPlayers;
}
_startCountdown -= Time.deltaTime;
if ((int)_startCountdown != _lastStartCountdownBeep)
{
_lastStartCountdownBeep = (int)_startCountdown;
if ((int)_startCountdown == 0)
{
_audioSync.PlayWorldSound(Sounds.CountdownFinalBeep);
}
else
{
_audioSync.PlayWorldSound(Sounds.CountdownBeep);
}
}
if (_startCountdown < 0)
{
BeginClosingBackDoor();
}
}
void FixedUpdate () {
//Check which state we are in. If ascending/descending, increment time-in-motion and check if we should stop;
//If stationary, check if we should begin moving.
if (state == ElevatorState.ASCENDING || state == ElevatorState.DESCENDING) {
timeSpentMoving++;
if (timeSpentMoving == movementTimeMax) {
GetComponent<Rigidbody2D> ().velocity = Vector2.zero;
timeSpentMoving = 0;
if (state == ElevatorState.ASCENDING) {
state = ElevatorState.STATIONARY_TOP;
} else {
state = ElevatorState.STATIONARY_BOTTOM;
}
foreach (CharacterMove move in charactersOnElevator) {
move.autoWalk = true;
}
}
foreach (CharacterMove move in charactersOnElevator) {
move.GetComponent<Rigidbody2D> ().velocity = GetComponent<Rigidbody2D> ().velocity;
}
} else if (Input.GetKeyDown (activateKey)) {
foreach (CharacterMove move in charactersOnElevator) {
move.autoWalk = false;
}
if (state == ElevatorState.STATIONARY_BOTTOM) {
state = ElevatorState.ASCENDING;
GetComponent<Rigidbody2D> ().velocity = new Vector2(0, movementSpeed);
} else {
state = ElevatorState.DESCENDING;
GetComponent<Rigidbody2D> ().velocity = new Vector2(0, -1*movementSpeed);
}
}
}
void HandleElevatorStateChanged(ElevatorState state)
{
if (state == ElevatorState.WaitingForDoorOpen)
{
controller.TrySwitchOff(elevatorController.CurrentFloorIndex);
}
}
// Change Floor.
public bool GoToFloor(int newFloor)
{
_goToFloor = newFloor;
if (_elevatorState == ElevatorState.RESTING)
{
if (_currentFloor == newFloor)
{
Console.WriteLine("Same Floor");
_elevatorState = ElevatorState.OPEN_DOORS;
}
if (_currentFloor < newFloor)
{
Console.WriteLine("Need Go Up");
_elevatorState = ElevatorState.GOING_UP;
}
if (_currentFloor > newFloor)
{
Console.WriteLine("Need Go Down");
_elevatorState = ElevatorState.GOING_DOWN;
}
return(true);
}
Console.WriteLine("Elevator In Other Action Right Now.");
return(false);
}
public bool GoToFloor(int newFloor)
{
if (_elevatorState == ElevatorState.IDLE && _currentFloor == newFloor)
{
_elevatorState = ElevatorState.OPEN_DOORS;
PrintStatus();
}
if (_elevatorState == ElevatorState.IDLE && _currentFloor != newFloor)
{
_gotoFloor = newFloor;
if (_currentFloor < newFloor)
{
_elevatorState = ElevatorState.GOING_UP;
PrintStatus();
FloorReached();
return(true);
}
if (_currentFloor > newFloor)
{
_elevatorState = ElevatorState.GOING_DOWN;
PrintStatus();
FloorReached();
return(true);
}
}
return(false);
}
private void Start()
{
state = ElevatorState.BOTTOM;
trackedTime = waitTime;
player = GameObject.FindGameObjectWithTag("Player");
}
public IEnumerator CloseDoorsDelay()
{
elevator = ElevatorState.Delay;
yield return(new WaitForSeconds(3));
elevator = ElevatorState.Closing;
}
public bool FloorReached()
{
bool IsOkFloorReached = false;
switch (_elevatorState)
{
case ElevatorState.GOING_UP:
_currentFloor = _gotoFloor;
_elevatorState = ElevatorState.OPEN_DOORS;
IsOkFloorReached = true;
break;
case ElevatorState.GOING_DOWN:
_currentFloor = _gotoFloor;
_elevatorState = ElevatorState.OPEN_DOORS;
IsOkFloorReached = true;
break;
case ElevatorState.OPEN_DOORS:
IsOkFloorReached = false;
break;
case ElevatorState.RESTING:
IsOkFloorReached = false;
break;
default:
break;
}
return(IsOkFloorReached);
}
public bool CloseDoors()
{
bool IsOkElevatorState = false;
switch (_elevatorState)
{
case ElevatorState.GOING_UP:
IsOkElevatorState = false;
break;
case ElevatorState.GOING_DOWN:
IsOkElevatorState = false;
break;
case ElevatorState.OPEN_DOORS:
_elevatorState = ElevatorState.RESTING;
IsOkElevatorState = true;
break;
case ElevatorState.RESTING:
IsOkElevatorState = false;
break;
default:
break;
}
return(IsOkElevatorState);
}
public void changeState()
{
switch (state)
{
case ElevatorState.Initing:
state = ElevatorState.Ready;
break;
case ElevatorState.Ready:
state = ElevatorState.Start_Fighting;
break;
case ElevatorState.Start_Fighting:
state = ElevatorState.Fighting;
break;
case ElevatorState.Fighting:
state = ElevatorState.End;
break;
case ElevatorState.End:
state = ElevatorState.Escape;
break;
}
}
/// <summary>
/// Move the player inside the elevator when they press "X" button
/// </summary>
/// <param name="collision"></param>
private void OnTriggerStay2D(Collider2D collision)
{
player gamer = collision.gameObject.GetComponent <player>();
if (gamer && gamer.getButtonDown("X"))
{
//Player infront of elevator and wants to enter (if not already inside)
//Player cannot enter an elevator when it is closed
if ((currentState == ElevatorState.OPEN || currentState == ElevatorState.CLOSING) && !isSpawnElevator)
{
if (!inElevator.Contains(gamer))
{
MovePlayerIntoElevator(gamer);
}
}
//Start closing the elevator (is it's not the spawn elevator)
if (currentState == ElevatorState.OPEN && !isSpawnElevator)
{
currentState = ElevatorState.CLOSING;
playerOpenCount.Clear();
playerCloseCount.Clear();
if (timeToFinish - timer >= 10)
{
timer = 0;
timeToFinish = 10;
}
else
{
timeToFinish -= timer;
timer = 0;
}
}
}
}
public bool MoveElevator(Direction direction, int destinationFloor)
{
Elevator elevator = elevators.Where(x => x.CurrentState == ElevatorState.Waiting).FirstOrDefault();
if (elevator != null)
{
return(elevator.GoTo(destinationFloor));
}
ElevatorState requiredState = (direction == Direction.Up) ? ElevatorState.GoingUp: ElevatorState.GoingDown;
elevator = elevators.Where(x => x.CurrentState == requiredState).FirstOrDefault();
if (elevator != null)
{
return(elevator.GoTo(destinationFloor));
}
requiredState = (requiredState == ElevatorState.GoingUp) ? ElevatorState.GoingDown : ElevatorState.GoingUp;
elevator = elevators.Where(x => x.CurrentState == requiredState).FirstOrDefault();
if (elevator != null)
{
return(elevator.GoTo(destinationFloor));
}
return(false);
}
void ElevatorHandle()
{
if (Elevatorstate != ElevatorState.Stop)
{
PersonCurrentPosition = Person.transform.position;
PersonCurrentPosition.y = PersonOrigin_y;
if (Elevatorstate == ElevatorState.Up)
{
ElevatorSmoothMove = Mathf.Sin(addVaule * Mathf.PI / 180);
if (addVaule < 90)
addVaule += ElevatorSpeed;
else
{
Elevatorstate = ElevatorState.Stop;
return;
}
}
else if (Elevatorstate == ElevatorState.Down)
{
ElevatorSmoothMove = Mathf.Sin(addVaule * Mathf.PI / 180);
if (addVaule > 0)
addVaule -= ElevatorSpeed;
else
{
Elevatorstate = ElevatorState.Stop;
return;
}
}
Person.transform.position = PersonCurrentPosition + new Vector3(0, ElevatorHeight * ElevatorSmoothMove, 0);
transform.position = ElevatorOriginPosition + new Vector3(0, ElevatorHeight * ElevatorSmoothMove, 0);
}
}
public bool FloorReached()
{
if (_elevatorState == ElevatorState.Going_Up)
{
_elevatorState = ElevatorState.Open_Doors;
_currentFloor = _gotoFloor;
if (FloorReachedSuccessfullyEvent != null)
{
FloorReachedSuccessfullyEvent.Invoke(this, EventArgs.Empty);
}
return(true);
}
if (_elevatorState == ElevatorState.Going_Down)
{
_elevatorState = ElevatorState.Open_Doors;
_currentFloor = _gotoFloor;
if (FloorReachedSuccessfullyEvent != null)
{
FloorReachedSuccessfullyEvent.Invoke(this, EventArgs.Empty);
}
return(true);
}
return(false);
}
public bool CloseDoors()
{
if (_elevatorState == ElevatorState.OPEN_DOORS)
{
_elevatorState = ElevatorState.CLOSE_DOORS | ElevatorState.IDLE;
}
return(true);
}
override public void Desactivate()
{
if (isActivated)
{
isActivated = false;
state = ElevatorState.MovingDown;
}
}
public void OnCloseButtonClicked()
{
if (State == ElevatorState.OpenWaiting)
{
State = ElevatorState.CloseWaiting;
ResetTimeout();
}
}
public void SetState(ElevatorState state)
{
currentState = state;
PushState(currentState);
currentState.Enter(this);
}
override public void Activate()
{
if (!isActivated)
{
isActivated = true;
state = ElevatorState.MovingUp;
}
}
private void BeginOpeningBottomAtDestination()
{
_state = ElevatorState.OpeningBottomAtDestination;
_timer = TimeToOpenBottom;
_audioSync.PlayWorldSound(Sounds.DoorMoving);
_floorRigidBody = _bottomPlatform.AddComponent <Rigidbody>();
_floorRigidBody.isKinematic = true;
}
private void OnTransitionedAction(StateMachine <ElevatorState, ElevatorTrigger> .Transition transition)
{
ElevatorTrigger trigger = transition.Trigger;
ElevatorState source = transition.Source;
ElevatorState dest = transition.Destination;
Debug.WriteLine($"Elevator:{Name}, Floor:{CurrentFloor}, Trigger: {trigger}, {source}-->{dest}");
}
void checkForElevatorUpdates(int timeOffset)
{
if (isTripComplete() || registeredElevatorBank == null)
{
return;
}
int targetFloorHeight = targetFloor * registeredElevatorBank.buildingConfiguration.heightPerFloor;
int sourceFloorHeight = sourceFloor * registeredElevatorBank.buildingConfiguration.heightPerFloor;
if (myElevator != null)
{
ElevatorState state = myElevator.State();
if (state.door.IsOpen &&
state.height == targetFloorHeight)
{
dropoffTime = timeOffset;
if (m_registrationToken != "")
{
registeredElevatorBank.
gameClock.unregisterStepAction(m_registrationToken);
}
tripStatus.wasDroppedOff = true;
tripStatus.timeToDropoff = timeOffset - tripStatus.registrationTime;
}
}
else
{
Elevator foundElevator = null;
foreach (Elevator elevator in
registeredElevatorBank.elevators)
{
ElevatorState state = elevator.State();
if (state.height == sourceFloorHeight &&
state.door.IsOpen &&
(state.overallDirection.isStopped ||
state.overallDirection.isAscending ==
(targetFloor > sourceFloor)))
{
foundElevator = elevator;
break;
}
}
if (foundElevator != null)
{
myElevator = foundElevator;
pickupTime = timeOffset;
myElevator.registerRequest(new ElevatorRequest(targetFloor,
targetFloor >
sourceFloor,
true));
tripStatus.wasPickedUp = true;
tripStatus.timeToPickup = timeOffset - tripStatus.registrationTime;
}
}
}
public override bool Traverse(SilhouetteController controller) {
// Elevator State update
if (elevatorMapping.value < 0.05f) {
elevatorState = ElevatorState.Down;
} else if (elevatorMapping.value > 0.95f) {
elevatorState = ElevatorState.Up;
} else {
elevatorState = ElevatorState.Between;
}
// Move Character
Vector3 targetOppositeEntry = link.GetEntry(link.GetOther(targetRoom));
bool characterInside = controller.transform.parent == elevator.movingRoot;
bool characterTowardsTargetLevel = Vector3.Distance(controller.transform.position, roomnet.RelativeToWorldPos(target)) < Vector3.Distance(controller.transform.position, roomnet.RelativeToWorldPos(targetOppositeEntry));
bool elevatorTowardsTargetLevel = Vector3.Distance(elevator.movingRoot.position, roomnet.RelativeToWorldPos(target)) < Vector3.Distance(elevator.movingRoot.position, roomnet.RelativeToWorldPos(targetOppositeEntry));
bool elevatorAtTargetLevel = elevatorTowardsTargetLevel && (elevatorState == ElevatorState.Up || elevatorState == ElevatorState.Down);
bool elevatorAtTargetOppositeLevel = !elevatorTowardsTargetLevel && (elevatorState == ElevatorState.Up || elevatorState == ElevatorState.Down);
Vector3 toWaypoint;
Vector3 direction;
if (characterInside) {
if (characterTowardsTargetLevel && elevatorAtTargetLevel) {
//Debug.Log("Inside - To Target");
toWaypoint = elevator.movingRoot.InverseTransformPoint(roomnet.RelativeToWorldPos(target)) - controller.transform.localPosition;
} else {
//Debug.Log("Inside - To Elevator Center");
toWaypoint = elevatorCenter.localPosition - controller.transform.localPosition;
}
} else {
if (characterTowardsTargetLevel) {
//Debug.Log("Outside - To Target");
toWaypoint = target - roomnet.WorldToRelativePos(controller.transform.position);
} else if (elevatorAtTargetOppositeLevel) {
//Debug.Log("Outside - To Elevator Center");
toWaypoint = roomnet.WorldToRelativePos(elevatorCenter.position) - roomnet.WorldToRelativePos(controller.transform.position);
} else { // Wait for elevator
//Debug.Log("Outside - Waiting");
toWaypoint = Vector3.zero;
}
}
if (toWaypoint != Vector3.zero) {
direction = toWaypoint.normalized;
if (toWaypoint.magnitude > 0.01f) {
controller.transform.localPosition += direction * controller.speed * Time.deltaTime;
controller.transform.localRotation = Quaternion.Euler(0f, Vector3.SignedAngle(Vector3.forward, direction.Flat3().normalized, Vector3.up), 0f);
}
}
// Check at target or entering elevator
if (controller.transform.parent != elevator.movingRoot && elevator.insideBox.IsInside(controller.transform.position)) {
controller.transform.SetParent(elevator.movingRoot, true);
} else if (controller.transform.parent == elevator.movingRoot && !elevator.insideBox.IsInside(controller.transform.position)) {
controller.transform.SetParent(roomnet.transform.parent, true); // TODO ugly and unsure
}
if (Vector3.Distance(target, roomnet.WorldToRelativePos(controller.transform.position)) < 0.01f) {
return true;
}
return false;
}
private void Update()
{
switch (state)
{
case ElevatorState.TOP:
if (trackedTime > 0)
{
trackedTime -= Time.deltaTime;
return;
}
else if (trackedTime < 0)
{
trackedTime = waitTime;
state = ElevatorState.DOWN;
}
break;
case ElevatorState.BOTTOM:
if (trackedTime > 0)
{
trackedTime -= Time.deltaTime;
return;
}
else if (trackedTime < 0)
{
trackedTime = waitTime;
state = ElevatorState.UP;
}
break;
case ElevatorState.UP:
if (playerActive && player.GetComponent <PlayerController>().GetMoveState() != PlayerMoveState.JUMP)
{
player.transform.Translate(Vector3.up * speed * Time.deltaTime);
}
transform.Translate(Vector3.up * speed * Time.deltaTime);
if (transform.position.y > maxHeight)
{
state = ElevatorState.TOP;
transform.position = new Vector3(transform.position.x, maxHeight, transform.position.z);
}
break;
case ElevatorState.DOWN:
transform.Translate(Vector3.up * -speed * Time.deltaTime);
if (playerActive && player.GetComponent <PlayerController>().GetMoveState() != PlayerMoveState.JUMP)
{
player.transform.Translate(Vector3.up * -speed * Time.deltaTime);
}
if (transform.position.y < groundHeight)
{
state = ElevatorState.BOTTOM;
transform.position = new Vector3(transform.position.x, groundHeight, transform.position.z);
}
break;
}
}
public Form1()
{
this.InitializeComponent();
this.init();
this.currentFloor = FirstFloorIndex;
this.elevatorState = ElevatorState.Idle;
this.label8.Text = currentFloor.ToString();
this.label4.Text = recievedData;
}
public Elevator()
{
CurrentFloor = 1;
_state = ElevatorState.Idle;
StringState = $"Лифт стоит на {CurrentFloor} этаже";
Buttons = new List <int>();
UpButtons = new SortedSet <int>();
DownButtons = new SortedSet <int>();
}
private void UpdateWaitingForPlayers()
{
if (ShouldTriggerCountdown())
{
_state = ElevatorState.CountingDown;
_startCountdown = CountdownSeconds;
_lastStartCountdownBeep = -1;
}
}
//Close Doors.
public bool CloseDoor()
{
if (_elevatorState == ElevatorState.OPEN_DOORS)
{
Console.WriteLine($"Elevator Closing The Doors");
_elevatorState = ElevatorState.RESTING;
return(true);
}
return(false);
}
public void MoveUp()
{
if (m_Receiver != null && m_Receiver.isPowered == false)
{
return;
}
if(m_CurrentState != ElevatorState.UP)
{
m_CurrentState = ElevatorState.MOVING_UP;
}
}
private void ChangeState(int request)
{
if (request > floor)
{
state = ElevatorState.Up;
}
else if (request < floor)
{
state = ElevatorState.Down;
}
}
void HandleElevatorStateChanged(ElevatorState state)
{
if (state == ElevatorState.WaitingForDoorOpen)
{
doorController.TryOpenAndLock();
}
else if (state == ElevatorState.WaitingForDoorClose && !trigger.IsActivated)
{
doorController.UnlockAndClose();
}
}
/// <summary>
/// Set the elevator to be fully closed
/// </summary>
private void SetClosed()
{
SetDoorPos(1);
doorLeftSpark.Stop();
doorRightSpark.Stop();
currentState = ElevatorState.CLOSED;
xButtonUI.SetActive(false);
bButtonUI.SetActive(false);
gradientBar.SetActive(false);
gradientBarIndicator.SetActive(false);
}
public void MoveDown()
{
if (m_Receiver != null && m_Receiver.isPowered == false)
{
return;
}
if(m_CurrentState != ElevatorState.DOWN)
{
m_CurrentState = ElevatorState.MOVING_DOWN;
}
}
public Elevator(int passengerCapacity, int weightCapacity, int elevatorIndex)
{
this.passengerCapacity = passengerCapacity;
this.weightCapacity = weightCapacity;
passengerInside = new List <Passenger>();
state = ElevatorState.Waiting;
CurrentFloorIndex = 1;
floorsToVisit = new ConcurrentBag <int>();
this.elevatorIndex = elevatorIndex;
}
public void Init(ElevatorState state, Elevator elevator)
{
SetState(state);
owner = elevator;
floorCoordinates = new Transform[] {
elevator.ElevatorButtons[0].transform,
elevator.ElevatorButtons[1].transform,
elevator.ElevatorButtons[2].transform,
};
}
private FeedbackDetails GetElevatorStateFeedback(ElevatorState elevatorState, string patternKey)
{
foreach (FeedbackDetails feedback in GetElevatorStateFeedbacks(elevatorState))
{
if (feedback.PatternKey == patternKey)
{
return(feedback);
}
}
return(null);
}
public void RunState()
{
currentState = GetCurrentState();
if (currentState != null)
{
currentState.UpdateState(owner);
if(currentState.IsStateDone())
{
PopState();
}
}
}
void OnGUI()
{
if (isOpenMenu)
{
if (GUI.Button(new Rect(Screen.width * 0.5f, Screen.height * 0.4f, Screen.width * 0.15f, Screen.height * 0.1f), "Up") && Elevatorstate == ElevatorState.Stop)
{
PersonOrigin_y = Person.transform.position.y;
Elevatorstate = ElevatorState.Up;
if(isDebugMessage)
print("Elevator is up !!");
}
if (GUI.Button(new Rect(Screen.width * 0.5f, Screen.height * 0.6f, Screen.width * 0.15f, Screen.height * 0.1f), "Down") && Elevatorstate == ElevatorState.Stop)
{
PersonOrigin_y = Person.transform.position.y - ElevatorHeight;
Elevatorstate = ElevatorState.Down;
if (isDebugMessage)
print("Elevator is down !!");
}
}
}
void FixedUpdate () {
//Check which state we are in. If ascending/descending, increment time-in-motion and check if we should stop;
//If stationary, check if we should begin moving.
if (state == ElevatorState.ASCENDING) {
timeSpentMoving++;
if (timeSpentMoving == movementTimeMax) {
state = ElevatorState.STATIONARY_TOP;
GetComponent<Rigidbody2D> ().velocity = Vector2.zero;
timeSpentMoving = 0;
}
for (int i = 0; i < heldCharacters.Count; i++) {
heldCharacters[i].GetComponent<Rigidbody2D> ().velocity = GetComponent<Rigidbody2D> ().velocity;
}
} else if (state == ElevatorState.DESCENDING) {
timeSpentMoving++;
if (timeSpentMoving == movementTimeMax) {
state = ElevatorState.STATIONARY_BOTTOM;
GetComponent<Rigidbody2D> ().velocity = Vector2.zero;
timeSpentMoving = 0;
}
for (int i = 0; i < heldCharacters.Count; i++) {
heldCharacters[i].GetComponent<Rigidbody2D> ().velocity = GetComponent<Rigidbody2D> ().velocity;
}
}
if (state == ElevatorState.STATIONARY_BOTTOM && Input.GetKeyDown (activateKey)) {
state = ElevatorState.ASCENDING;
GetComponent<Rigidbody2D> ().velocity = new Vector2(0, movementSpeed);
} else if (state == ElevatorState.STATIONARY_TOP && Input.GetKeyDown (activateKey)) {
state = ElevatorState.DESCENDING;
GetComponent<Rigidbody2D> ().velocity = new Vector2(0, -1*movementSpeed);
}
}
private void PushState(ElevatorState state)
{
stateStack.Push(state);
}
// Update is called once per frame
void Update()
{
if(m_AutoTimer > 0.0f)
{
m_Timer -= Time.deltaTime;
if(m_Timer < 0.0f)
{
m_Timer = m_AutoTimer;
if(m_CurrentState == ElevatorState.MOVING_UP || m_CurrentState == ElevatorState.UP)
{
MoveDown();
}
else if(m_CurrentState == ElevatorState.MOVING_DOWN || m_CurrentState == ElevatorState.DOWN)
{
MoveUp();
}
}
}
switch(m_CurrentState)
{
case ElevatorState.DOWN:
transform.position = m_StartPosition + m_DownPosition;
break;
case ElevatorState.UP:
transform.position = m_StartPosition + m_UpPosition;
break;
case ElevatorState.MOVING_DOWN:
m_CurrentTime -= Time.deltaTime * m_MovementSpeed;
if(m_CurrentTime < 0.0f)
{
m_CurrentState = ElevatorState.DOWN;
m_CurrentTime = 0.0f;
break;
}
transform.position = Vector3.Lerp(m_StartPosition + m_DownPosition,m_StartPosition + m_UpPosition , m_CurrentTime);
break;
case ElevatorState.MOVING_UP:
m_CurrentTime += Time.deltaTime * m_MovementSpeed;
if(m_CurrentTime > 1.0f)
{
m_CurrentState = ElevatorState.UP;
m_CurrentTime = 1.0f;
break;
}
transform.position = Vector3.Lerp(m_StartPosition + m_DownPosition, m_StartPosition + m_UpPosition, m_CurrentTime);
break;
}
}
public void StateChangedHandler(object sender, EventArgs e)
{
lock (stateHandlerLock)
{
if (elevator.State != ElevatorState.Stopped && elevator.State != moveState)
{
if (elevator.PersonList.Count == 0)
{
numberOfEmptyRides++;
}
moveState = elevator.State;
numberOfRides++;
OnStatisticsChanged(EventArgs.Empty);
}
}
}
private void SetState(ElevatorState s)
{
if (currentState != s)
{
if (currentState != ElevatorState.Stopped)
{
direction = currentState;
}
currentState = s;
OnStateChanged(EventArgs.Empty);
}
}
