Start the rewrite

src/server/main/Elevators/Otis1960/Doors.lua

@@ -17,18 +17,17 @@ local SoundEnums = require(Main:WaitForChild("Enums"):WaitForChild("Sounds"))
 type DoorSensors = {
 	[string]: BasePart
 }
-type CustomTween<T,U> = Tween.TweenClass<T,U>
 
-type ClassConstructor<T,U> = typeof(setmetatable({} :: Constructor_Return_Props<T,U>, {} :: Impl_Constructor))
+type ClassConstructor = typeof(setmetatable({} :: Constructor_Return_Props, {} :: Impl_Constructor))
 type Impl_Constructor = {
     __index: Impl_Constructor,
     constructor: Constructor_Fun,
     --Class functions
-    __DetectSensorHit:        <T,U>(self: ClassConstructor<T,U>, DoorTween1: Tween, DoorTween2: Tween) -> RBXScriptConnection,
+    __DetectSensorHit:        (self: ClassConstructor, DoorTween1: Tween, DoorTween2: Tween) -> RBXScriptConnection,
-    ToggleElevatorDoorsAsync: <T,U>(self: ClassConstructor<T,U>, opening: boolean, floor: number) -> ()
+    ToggleElevatorDoorsAsync: (self: ClassConstructor, opening: boolean, floor: number) -> ()
 } & Impl_Static_Props
 
-type Constructor_Fun = <T,U>(FloorDoorsTags: Tags.LandingTags, ElevatorBox: BasePart, ElevatorDoor1: BasePart, ElevatorDoor2: BasePart, ElevatorDoorSensor: Folder) -> ClassConstructor<T,U>
+type Constructor_Fun = (FloorDoorsTags: Tags.LandingTags, ElevatorBox: BasePart, ElevatorDoor1: BasePart, ElevatorDoor2: BasePart, ElevatorDoorSensor: Folder) -> ClassConstructor
 type Impl_Static_Props = {
 	Sensors:           boolean,
 	Door1Stopped_X:    Vector3,
@@ -40,10 +39,8 @@ type Impl_Static_Props = {
 	Attributes: {} & RelayAttributes
 }
 
-type Constructor_Return_Props<T,U> = {
+type Constructor_Return_Props = {
 	FloorDoorsTags:   Tags.LandingTags,
-	DoorTween1:       CustomTween<T,U>,
-	DoorTween2:       CustomTween<T,U>,
 	DoorSensor:       DoorSensors,
 	ElevatorBox:      BasePart,
 	ElevatorDoor1:    BasePart,
@@ -62,7 +59,7 @@ export type RelayAttributes = {
 	}
 }
 
-export type DoorConstructor<T,U> = ClassConstructor<T,U>
+export type DoorConstructor = ClassConstructor
 
 local Doors = {} :: Impl_Constructor
 Doors.__index = Doors
@@ -84,8 +81,6 @@ Doors.Attributes.Relay.Open.Value = false
 local Attributes = Doors.Attributes
 
 function Doors.constructor(FloorDoorsTags, ElevatorBox, ElevatorDoor1, ElevatorDoor2, ElevatorDoorSensor)
-	local DoorTween1 = Tween.constructor(nil, ElevatorDoor1)
-	local DoorTween2 = Tween.constructor(nil, ElevatorDoor2)
 	local DoorSensor: DoorSensors = {
 		Start = ElevatorDoorSensor:WaitForChild("Start") :: BasePart,
 		End   = ElevatorDoorSensor:WaitForChild("End") :: BasePart
@@ -98,8 +93,6 @@ function Doors.constructor(FloorDoorsTags, ElevatorBox, ElevatorDoor1, ElevatorD
 
 	return setmetatable({
 		FloorDoorsTags   = FloorDoorsTags,
-		DoorTween1       = DoorTween1,
-		DoorTween2       = DoorTween2,
 		DoorSensor       = DoorSensor,
 		ElevatorBox      = ElevatorBox,
 		ElevatorDoor1    = ElevatorDoor1,
@@ -175,7 +168,7 @@ local function DoorsAnimationFloor(FloorDoors: {Instance?}, Floor: number, openi
 	return Door1Tween_Floor, Door2Tween_Floor
 end
 
-local function ElevatorDoorsAnimationAsync<T,U>(self: ClassConstructor<T,U>, opening: boolean, activated_via_censor: boolean?)
+local function ElevatorDoorsAnimationAsync(self: ClassConstructor, opening: boolean, activated_via_censor: boolean?)
 	--Roblox physics will freak out
 	self.ElevatorDoor1.CanCollide = false
 	self.ElevatorDoor2.CanCollide = false
@@ -189,7 +182,7 @@ local function ElevatorDoorsAnimationAsync<T,U>(self: ClassConstructor<T,U>, ope
 	if opening then
 		while task.wait() do
 			local Time = Algebra.LinearElapse(StartTime, Timing)
-			local Ease = Algebra.Easing.InOutQuad(Time)
+			local Ease = Algebra.Easing.InOutQuart(Time)
 
 			local ElevatorBoxY = Vector3.new(0, self.ElevatorBox.Position.Y, 0)
 			local Door1Vector  = Vector3.new(ElevatorDoor1_P.X, 0, ElevatorDoor1_P.Z)
@@ -205,7 +198,7 @@ local function ElevatorDoorsAnimationAsync<T,U>(self: ClassConstructor<T,U>, ope
 	else
 		while task.wait() do
 			local Time = Algebra.LinearElapse(StartTime, Timing)
-			local Ease = Algebra.Easing.InOutQuad(Time)
+			local Ease = Algebra.Easing.InOutQuart(Time)
 
 			local ElevatorBoxY = Vector3.new(0, self.ElevatorBox.Position.Y, 0)
 			local Door1Vector  = Vector3.new(ElevatorDoor1_P.X, 0, ElevatorDoor1_P.Z)
@@ -234,7 +227,7 @@ for n: number = 1, #workspace_items do
 	end
 end
 
-function Doors:__DetectSensorHit<T,U>(DoorTween1, DoorTween2)
+function Doors:__DetectSensorHit(DoorTween1, DoorTween2)
 	local Step = nil
 
 	if Doors.Sensors and Attributes.Relay.Open.Value then
@@ -256,7 +249,7 @@ function Doors:__DetectSensorHit<T,U>(DoorTween1, DoorTween2)
 	return Step
 end
 
-function Doors:ToggleElevatorDoorsAsync<T,U>(opening, floor)
+function Doors:ToggleElevatorDoorsAsync(opening, floor)
 	--short circuiting central
 	if opening then
 		if Attributes.Relay.Open.Value then

src/server/main/Elevators/Otis1960/Leveling.lua

@@ -15,7 +15,7 @@ local Leveling: {number} = {
 	[10] = 239.245,
 }
 
---Mainly used for the lanterns
+--Primarily used for the lanterns
 local LevelingBetween: {number} = {}
 
 --Calculate between leveling

src/server/main/Elevators/Otis1960/Moving.lua

@@ -0,0 +1,233 @@
+--!optimize 2
+--!native
+--!strict
+
+local Dir          = script.Parent
+local ElevatorsDir = Dir.Parent
+
+local Lanterns       = require(ElevatorsDir:WaitForChild("Lanterns"))
+local TractionRopes  = require(ElevatorsDir:WaitForChild("TractionRopes"))
+local MovingObjects  = require(Dir:WaitForChild("MovingObjects"))
+local LevelingModule = require(Dir:WaitForChild("Leveling"))
+local PhysicalRelays = require(Dir:WaitForChild("PhysicalRelay"))
+local RelayAlgorithm = require(Dir:WaitForChild("RelayAlgorithm"))
+local ElevatorDoors  = require(Dir:WaitForChild("Doors"))
+
+type ClassConstructor = typeof(setmetatable({} :: Constructor_Return_Props, {} :: Impl_Constructor))
+type Impl_Constructor = {
+    __index: Impl_Constructor,
+    constructor: Constructor_Fun,
+    --Class functions
+    Start: (self: ClassConstructor, GoingUp: boolean, RequestedLevel: number, ElevatorBox_1960: BasePart, BoxAlignPosition: AlignPosition) -> (),
+}
+
+type Constructor_Fun = (
+	ElevatorAttributes:        ElevatorAttributes,
+	LanternsConstructor:       Lanterns.LanternsConstructor,
+	TractionRopesConstructor:  TractionRopes.TractionRopesConstructor, 
+	MovingObjectsConstructor:  MovingObjects.MovingObjectsConstructor,
+	PhysicalRelaysConstructor: PhysicalRelays.PhysicalRelayConstructor,
+	RelayAlgorithmConstructor: RelayAlgorithm.RelayAlgorithmConstructor,
+	ElevatorDoorsConstructor:  ElevatorDoors.DoorConstructor
+) -> ClassConstructor
+
+type Constructor_Return_Props = {
+	LanternsConstructor:       Lanterns.LanternsConstructor,
+	ElevatorAttributes:        ElevatorAttributes,
+	TractionRopesConstructor:  TractionRopes.TractionRopesConstructor,
+	MovingObjectsConstructor:  MovingObjects.MovingObjectsConstructor,
+	PhysicalRelaysConstructor: PhysicalRelays.PhysicalRelayConstructor,
+	RelayAlgorithmConstructor: RelayAlgorithm.RelayAlgorithmConstructor,
+
+	__Connections: {
+		Moving: RBXScriptConnection?
+	}
+}
+
+type ElevatorAttributes = {
+	CurrentFloor:                IntValue,
+	Moving:                      BoolValue,
+	GoingUp:                     BoolValue,
+	FloorLevelingDistance:       number,
+	LeveledDistance:             number,
+	DoorOpeningDistance:         number,
+	FloorLeveling3PhaseDistance: number,
+	QueueWaitTime:               number,
+
+	Relay: {
+		Goal:           IntValue,
+		ReadyForMoving: BoolValue
+	}
+}
+
+export type MovingConstructor = ClassConstructor
+
+local Moving = {} :: Impl_Constructor
+Moving.__index = Moving
+
+local RS = game:GetService("RunService")
+
+local DoorsOpeningDebounce = false
+
+function Moving.constructor(
+	ElevatorAttributes,
+	LanternsConstructor,
+	TractionRopesConstructor,
+	MovingObjectsConstructor,
+	PhysicalRelaysConstructor,
+	RelayAlgorithmConstructor,
+	ElevatorDoorsConstructor
+)
+	return setmetatable({
+		ElevatorAttributes        = ElevatorAttributes,
+		LanternsConstructor       = LanternsConstructor,
+		TractionRopesConstructor  = TractionRopesConstructor,
+		MovingObjectsConstructor  = MovingObjectsConstructor,
+		PhysicalRelaysConstructor = PhysicalRelaysConstructor,
+		RelayAlgorithmConstructor = RelayAlgorithmConstructor,
+		ElevatorDoorsConstructor  = ElevatorDoorsConstructor,
+
+		__Connections = {}
+	}, Moving)
+end
+
+local function ElevatorGoingUpDirection(CurrentFloor: number, RequestedFloor: number): boolean
+	return CurrentFloor<RequestedFloor
+end
+
+local function Leveled(self: ClassConstructor, RequestedLevel: number)
+	(self.__Connections.Moving :: RBXScriptConnection):Disconnect()
+	self.ElevatorAttributes.Moving.Value       = false
+	self.ElevatorAttributes.CurrentFloor.Value = RequestedLevel
+	--self.BoxAlignPosition.MaxVelocity = 0
+
+	self.LanternsConstructor:Reset(self.ElevatorAttributes.CurrentFloor.Value)
+	self.PhysicalRelaysConstructor:SetState("UP",    false, false)
+	self.PhysicalRelaysConstructor:SetState("DOWN",  false, false)
+	self.PhysicalRelaysConstructor:SetState("440 V", false, false)
+	self.PhysicalRelaysConstructor:SetState("240 V", false, false)
+
+	task.wait(self.ElevatorAttributes.QueueWaitTime)
+
+	local ElevatorGoingUp = ElevatorGoingUpDirection(self.ElevatorAttributes.CurrentFloor.Value, self.ElevatorAttributes.Relay.Goal.Value)
+
+	local NextLevel = self.RelayAlgorithmConstructor:Check(ElevatorGoingUp)
+	if NextLevel then
+		
+	else
+		--The elevator is at a full park now
+		self.ElevatorAttributes.Relay.ReadyForMoving.Value = false
+	end
+end
+
+local function Leveling(self: ClassConstructor, RequestedLevel: number)
+	self.PhysicalRelaysConstructor:SetState("440 V", false, true)
+
+	self.BoxAlignPosition.MaxVelocity = 1
+	self.LanternsConstructor:Toggle(true, RequestedLevel)
+end
+
+local function Leveling3Phase(self: ClassConstructor, RequestedLevel: number)
+	self.BoxAlignPosition.MaxVelocity = .4
+end
+
+local function FloorPassingUp(self: ClassConstructor, ElevatorPositionY: number, RequestedLevel: number)
+	local NextLevelBetweenFloors: number? = LevelingModule.LevelingBetween[self.ElevatorAttributes.CurrentFloor.Value+1]
+
+	if NextLevelBetweenFloors and ElevatorPositionY>=NextLevelBetweenFloors then
+		self.ElevatorAttributes.CurrentFloor.Value+=1
+
+		self.LanternsConstructor:Toggle(true, self.ElevatorAttributes.CurrentFloor.Value)
+		self.LanternsConstructor:Toggle(false, self.ElevatorAttributes.CurrentFloor.Value-1)
+	end
+end
+
+local function FloorPassingDown(self: ClassConstructor, ElevatorPositionY: number, RequestedLevel: number)
+	local NextLevelBetweenFloors: number? = LevelingModule.LevelingBetween[self.ElevatorAttributes.CurrentFloor.Value-1]
+
+	if NextLevelBetweenFloors and ElevatorPositionY<=NextLevelBetweenFloors then
+		self.ElevatorAttributes.CurrentFloor.Value-=1
+
+		self.LanternsConstructor:Toggle(true, self.ElevatorAttributes.CurrentFloor.Value)
+		self.LanternsConstructor:Toggle(false, self.ElevatorAttributes.CurrentFloor.Value+1)
+	end
+end
+
+local function UpDirection(self: ClassConstructor, ElevatorPositionY: number, BoxAlignY: number, RequestedLevel: number)
+	FloorPassingUp(self, ElevatorPositionY, self.ElevatorAttributes.Relay.Goal.Value)
+
+	if ElevatorPositionY>=BoxAlignY-self.ElevatorAttributes.FloorLevelingDistance then
+		Leveling(self, self.ElevatorAttributes.Relay.Goal.Value)
+
+		if ElevatorPositionY>=BoxAlignY-self.ElevatorAttributes.FloorLeveling3PhaseDistance then				
+			Leveling3Phase(self, RequestedLevel)	
+
+			if not DoorsOpeningDebounce and ElevatorPositionY>=BoxAlignY-self.ElevatorAttributes.DoorOpeningDistance then
+				DoorsOpeningDebounce = true
+				self.ElevatorDoorsConstructor:ToggleElevatorDoorsAsync(true, self.ElevatorAttributes.Relay.Goal.Value)
+			end
+		end
+	end
+	
+	if ElevatorPositionY>=BoxAlignY-self.ElevatorAttributes.LeveledDistance then
+		Leveled(self, self.ElevatorAttributes.Relay.Goal.Value)
+	end
+end
+
+local function DownDirection(self: ClassConstructor, ElevatorPositionY: number, BoxAlignY: number, RequestedLevel: number)
+	FloorPassingDown(self, ElevatorPositionY, self.ElevatorAttributes.Relay.Goal.Value)
+
+	if ElevatorPositionY<=BoxAlignY+self.ElevatorAttributes.FloorLevelingDistance then
+		Leveling(self, self.ElevatorAttributes.Relay.Goal.Value)
+
+		if ElevatorPositionY<=BoxAlignY+self.ElevatorAttributes.FloorLeveling3PhaseDistance then
+			Leveling3Phase(self, RequestedLevel)
+
+			if not DoorsOpeningDebounce and ElevatorPositionY<=BoxAlignY+self.ElevatorAttributes.DoorOpeningDistance then
+				DoorsOpeningDebounce = true
+				self.ElevatorDoorsConstructor:ToggleElevatorDoorsAsync(true, self.ElevatorAttributes.Relay.Goal.Value)
+			end
+		end
+	end
+
+	if ElevatorPositionY<=BoxAlignY+self.ElevatorAttributes.LeveledDistance then
+		Leveled(self, self.ElevatorAttributes.Relay.Goal.Value)
+	end
+end
+
+function Moving:Start(GoingUp, RequestedLevel, ElevatorBox_1960, BoxAlignPosition)
+	local MovingDelta = 0
+
+	self.ElevatorAttributes.GoingUp.Value    = GoingUp
+	self.ElevatorAttributes.Relay.Goal.Value = RequestedLevel
+	self.ElevatorAttributes.Moving.Value     = true
+	
+	self.PhysicalRelaysConstructor:SetState(GoingUp and "UP" or "DOWN", true, false)
+	self.PhysicalRelaysConstructor:SetState("240 V", true, false)
+	self.PhysicalRelaysConstructor:SetState("440 V", true, false)
+	
+	self.MovingObjectsConstructor:UpdateCFrame()
+	
+	if self.__Connections.Moving and self.__Connections.Moving.Connected then
+		self.__Connections.Moving:Disconnect()
+	end
+	self.__Connections.Moving = RS.Heartbeat:Connect(function(_)
+		MovingDelta+=1
+
+		local ElevatorPosition  = ElevatorBox_1960.Position
+		local ElevatorPositionY = ElevatorPosition.Y
+		local ElevatorVelocityY = ElevatorBox_1960:GetVelocityAtPosition(ElevatorPosition).Y
+		local BoxAlignY         = BoxAlignPosition.Position.Y
+
+		self.TractionRopesConstructor:Move(27, ElevatorPosition)
+		self.MovingObjectsConstructor:FramePullies(MovingDelta, ElevatorVelocityY)
+
+		if self.ElevatorAttributes.GoingUp.Value then
+			UpDirection(self, ElevatorPositionY, BoxAlignY, RequestedLevel)
+		else
+			DownDirection(self, ElevatorPositionY, BoxAlignY, RequestedLevel)
+		end
+	end)
+end
+
+return Moving

src/server/main/Elevators/Otis1960/MovingObjects.lua

@@ -8,8 +8,8 @@ type Impl_Constructor = {
 	constructor: Constructor_Fun,
 	--Class functions
 	UpdateCFrame:   (self: ClassConstructor) -> (),
-	Frame_Pullies:  (self: ClassConstructor, Delta: number, ElevatorVelocity_Y: number) -> (),
+	FramePullies:  (self: ClassConstructor, Delta: number, ElevatorVelocity_Y: number) -> (),
-	Frame_PiePlate: (self: ClassConstructor, Delta: number, ElevatorVelocity_Y: number) -> ()
+	FramePiePlate: (self: ClassConstructor, Delta: number, ElevatorVelocity_Y: number) -> ()
 }
 
 type Constructor_Fun = (InstanceTree: InstanceTree) -> ClassConstructor
@@ -69,7 +69,7 @@ function MovingObjects:UpdateCFrame()
 	self.MachineRoom._CFrame.PieplateSelectorCFrame = self.MachineRoom.PiePlateSelector.CFrame
 end
 
-function MovingObjects:Frame_Pullies(Delta, ElevatorVelocity_Y)
+function MovingObjects:FramePullies(Delta, ElevatorVelocity_Y)
 	local MR   = self.MachineRoom
 	local MR_C = MR._CFrame
 
@@ -84,7 +84,7 @@ function MovingObjects:Frame_Pullies(Delta, ElevatorVelocity_Y)
 	MR.PiePlatePulley.CFrame   = MR_C.PieplatePulleyCFrame  *CFrame.Angles(PullAngle_2,  0, 0)
 end
 
-function MovingObjects:Frame_PiePlate(Delta, ElevatorVelocity_Y)
+function MovingObjects:FramePiePlate(Delta, ElevatorVelocity_Y)
 	local MR   = self.MachineRoom
 	local MR_C = MR._CFrame
 

src/server/main/Elevators/Otis1960/PhysicalRelay.lua

@@ -158,7 +158,7 @@ local function OtimRelayAnimation(Relay: Tags.RelayProperties, State: boolean)
 
 	if State then
 		--If .Inst is present then it is safe to be calling these
-		(Relay.PhysicalSound.Activated :: Sound):Play() --Theres a small start delay to the sound... oops, im not a pro at audio editing
+		(Relay.PhysicalSound.Activated :: Sound):Play()
 	else
 		RelayAnimation.Completed:Once(function()
 			(Relay.PhysicalSound.DeActivated :: Sound):Play()

src/server/main/Elevators/Otis1960/init.lua

@@ -379,71 +379,8 @@ function Elevator.constructor(TagsConstructor, ButtonsTags, LanternsTags, Landin
 	return ClassConstructor
 end
 
-local function Leveled(self: ClassConstructor, RequestedLevel: number)
-	(self.__Connections.Moving :: RBXScriptConnection):Disconnect()
-	Attributes.Moving.Value       = false
-	Attributes.CurrentFloor.Value = RequestedLevel
-	--self.BoxAlignPosition.MaxVelocity = 0
-
-	self.LanternsConstructor:Reset(Attributes.CurrentFloor.Value)
-	self.PhysicalRelays:SetState("UP",    false, false)
-	self.PhysicalRelays:SetState("DOWN",  false, false)
-	self.PhysicalRelays:SetState("440 V", false, false)
-	self.PhysicalRelays:SetState("240 V", false, false)
-
-	task.wait(Elevator.QueueWaitTime)
-
-	local ElevatorGoingUp = ElevatorGoingUpDirection(Attributes.CurrentFloor.Value, Attributes.Relay.Goal.Value)
-
-	print("CurrentFloor=",Attributes.CurrentFloor.Value,"Goal=",Attributes.Relay.Goal.Value)
-	local NextLevel = self.RelayAlgorithmConstructor:Check(ElevatorGoingUp)
-	if NextLevel then
-		--More floors in the queue
-		print(self.RelayAlgorithmConstructor.__FloorQueue)
-		--self:__MoveToAsync(ElevatorGoingUp, NextLevel)
-	else
-		--The elevator is at a full park now
-		Attributes.Relay.ReadyForMoving.Value = false
-	end
-end
-
-local function Leveling(self: ClassConstructor, RequestedLevel: number)
-	self.PhysicalRelays:SetState("440 V", false, true)
-
-	self.BoxAlignPosition.MaxVelocity = 1
-	self.LanternsConstructor:Toggle(true, RequestedLevel)
-end
-
-local function Leveling3Phase(self: ClassConstructor, RequestedLevel: number)
-	self.BoxAlignPosition.MaxVelocity = .4
-end
-
-local function FloorPassingUp(self: ClassConstructor, ElevatorPositionY: number, RequestedLevel: number)
-	local NextLevelBetweenFloors: number? = LevelingModule.LevelingBetween[Attributes.CurrentFloor.Value+1]
-
-	if NextLevelBetweenFloors and ElevatorPositionY>=NextLevelBetweenFloors then
-		Attributes.CurrentFloor.Value+=1
-
-		self.LanternsConstructor:Toggle(true, Attributes.CurrentFloor.Value)
-		self.LanternsConstructor:Toggle(false, Attributes.CurrentFloor.Value-1)
-	end
-end
-
-local function FloorPassingDown(self: ClassConstructor, ElevatorPositionY: number, RequestedLevel: number)
-	local NextLevelBetweenFloors: number? = LevelingModule.LevelingBetween[Attributes.CurrentFloor.Value-1]
-
-	if NextLevelBetweenFloors and ElevatorPositionY<=NextLevelBetweenFloors then
-		Attributes.CurrentFloor.Value-=1
-
-		self.LanternsConstructor:Toggle(true, Attributes.CurrentFloor.Value)
-		self.LanternsConstructor:Toggle(false, Attributes.CurrentFloor.Value+1)
-	end
-end
-
 function Elevator:__MovingHeartbeat(GoingUp, RequestedLevel)
-	if self.__Connections.Moving and self.__Connections.Moving.Connected then
+
-		self.__Connections.Moving:Disconnect()
-	end
 
 	local GoingTo_Y_Level = LevelingModule.Leveling[RequestedLevel]
 	if not GoingTo_Y_Level then
@@ -453,7 +390,6 @@ function Elevator:__MovingHeartbeat(GoingUp, RequestedLevel)
 	end
 
 	local Delta                = 0
-	local DoorsOpeningDebounce = false
 	
 	Attributes.GoingUp.Value    = GoingUp
 	Attributes.Relay.Goal.Value = RequestedLevel
@@ -475,54 +411,6 @@ function Elevator:__MovingHeartbeat(GoingUp, RequestedLevel)
 	self.__Connections.Moving = RS.Heartbeat:Connect(function(_dt)
 		Delta+=1
 
-		local ElevatorPosition  = self.ElevatorBox_1960.Position
-		local ElevatorPositionY = ElevatorPosition.Y
-		local BoxAlignY         = self.BoxAlignPosition.Position.Y
-		local ElevatorVelocityY = self.ElevatorBox_1960:GetVelocityAtPosition(ElevatorPosition).Y
-
-		self.TractionRopesConstructor:Move(27, ElevatorPosition)
-		self.MOConstructor:Frame_Pullies(Delta, ElevatorVelocityY)
-
-		--Kill the connection
-		if Attributes.GoingUp.Value then
-			FloorPassingUp(self, ElevatorPositionY, Attributes.Relay.Goal.Value)
-
-			if ElevatorPositionY>=BoxAlignY-Elevator.FloorLevelingDistance then
-				Leveling(self, Attributes.Relay.Goal.Value)
-
-				if ElevatorPositionY>=BoxAlignY-Elevator.FloorLeveling3PhaseDistance then				
-					Leveling3Phase(self, RequestedLevel)	
-
-					if not DoorsOpeningDebounce and ElevatorPositionY>=BoxAlignY-Elevator.DoorOpeningDistance then
-						DoorsOpeningDebounce = true
-						self.ElevatorDoorsConstructor:ToggleElevatorDoorsAsync(true, Attributes.Relay.Goal.Value)
-					end
-				end
-			end
-			
-			if ElevatorPositionY>=BoxAlignY-Elevator.LeveledDistance then
-				Leveled(self, Attributes.Relay.Goal.Value)
-			end
-		else
-			FloorPassingDown(self, ElevatorPositionY, Attributes.Relay.Goal.Value)
-
-			if ElevatorPositionY<=BoxAlignY+Elevator.FloorLevelingDistance then
-				Leveling(self, Attributes.Relay.Goal.Value)
-
-				if ElevatorPositionY<=BoxAlignY+Elevator.FloorLeveling3PhaseDistance then
-					Leveling3Phase(self, RequestedLevel)
-
-					if not DoorsOpeningDebounce and ElevatorPositionY<=BoxAlignY+Elevator.DoorOpeningDistance then
-						DoorsOpeningDebounce = true
-						self.ElevatorDoorsConstructor:ToggleElevatorDoorsAsync(true, Attributes.Relay.Goal.Value)
-					end
-				end
-			end
-
-			if ElevatorPositionY<=BoxAlignY+Elevator.LeveledDistance then
-				Leveled(self, Attributes.Relay.Goal.Value)
-			end
-		end
 	end)
 end
 

src/shared/Algebra.lua

@@ -32,6 +32,11 @@ export type Easing = {
 	InOutQuart: Ease,
 }
 
+export type MathStatic = {
+	acosPI: number,
+	E:      number
+}
+
 export type Math = {
 	Easing:         Easing,
 	IsOdd:          (n: number) -> boolean,
@@ -41,12 +46,15 @@ export type Math = {
 	LinearElapse:   (StartTime: number, Timing: number) -> number,
 	maxmin:         (min: number, n: number, max: number) -> number,
 	minmax:         (min: number, n: number, max: number) -> number
-}
+} & MathStatic
 
 local Math = {
 	Easing = {}
 } :: Math
 
+Math.acosPI = math.acos(-1)
+Math.E      = 2.71828182845905
+
 function Math.IsOdd(n)
 	return bit32.btest(bit32.band(n, 1))
 end
@@ -58,7 +66,6 @@ end
 function Math.maxmin(min, n, max)
     return math.max(min, math.min(n, max))
 end
-
 Math.minmax = Math.maxmin
 
 function Math.RotationMatrix(X, Y, Z)