Sounds and working

src/server/main/Elevators/Map/Haughton/Buttons.luau

@@ -20,54 +20,73 @@ type Impl_Constructor = {
 	__index: Impl_Constructor,
 	constructor: Constructor_Fun,
 	--Class functions
-	Hook: (self: ClassConstructor) -> ()
+	InitForElevator: (self: ClassConstructor, MaxActivationDistance: number?, AddedOffset: Vector3?) -> ()
 }
 
-type Constructor_Fun = (ElevatorModel: Enums.ElevatorValues, ButtonTags: Tags.ElevatorButtons, CurrentFloor: IntValue) -> ClassConstructor
+type Constructor_Fun = (
-type Constructor_Return_Props = {
 	ElevatorModel: Enums.ElevatorValues,
 	ButtonTags: Tags.ElevatorButtons,
 	CurrentFloor: IntValue
+) -> ClassConstructor
+
+type Constructor_Return_Props = {
+	ElevatorModel: Enums.ElevatorValues,
+	ButtonTags: Tags.ElevatorButtons,
+	CurrentFloor: IntValue,
+	Events: Events
+}
+
+export type Events = {
+	FloorButtonActivated: RBXScriptSignal<boolean, number | string, Tags.ButtonPropertiesSafe>,
+	__eventInstances__: {
+		FloorButtonActivated: BindableEvent
+	}
 }
 
 local Buttons = {} :: Impl_Constructor
 Buttons.__index = Buttons
 
 function Buttons.constructor(ElevatorModel, ButtonTags, CurrentFloor)
+	local ButtonActivated = Instance.new("BindableEvent")
+
 	return setmetatable({
 		ElevatorModel = ElevatorModel,
 		ButtonTags = ButtonTags,
 		CurrentFloor = CurrentFloor,
+
+		Events = {
+			FloorButtonActivated = ButtonActivated.Event,
+			__eventInstances__ = {
+				FloorButtonActivated = ButtonActivated
+			}
+		}
 	}, Buttons)
 end
 
-local function CarButtonActivated(ButtonFloor: number | string)
+function Buttons:InitForElevator(MaxActivationDistance, AddedOffset)
-	print("Activated", ButtonFloor)
+	MaxActivationDistance = MaxActivationDistance or ButtonTags.DefaultMaxActivationDistance
-end
+	AddedOffset = AddedOffset or Vector3.zero
 
-local function CarButtonFallback(ButtonFloor: number | string)
-	--Fires when the button is pressed at its own floor
-	print("Already at floor:", ButtonFloor)
-end
-
-function Buttons:Hook()
 	local ButtonManagerConstructor = ButtonManager.constructor(self.CurrentFloor)
 	local ButtonTagsConstructor = ButtonTags.constructor(self.ButtonTags, self.ElevatorModel)
 	local Prompt = ButtonTagsConstructor:CreatePromptButtons()
 
---
 	local CarButtonPrompts = Prompt[self.ElevatorModel].Car
 
 	for PromptType, PromptProperties in CarButtonPrompts do
 		if PromptProperties.Attachment and PromptProperties.Inst and PromptProperties.Prompt then
-				PromptProperties.Prompt.MaxActivationDistance = 2
+			PromptProperties.Prompt.MaxActivationDistance = MaxActivationDistance :: number
-				PromptProperties.Attachment.Position-=Vector3.new(.05,0,0)
+			PromptProperties.Attachment.Position+=AddedOffset :: Vector3
-				ButtonManagerConstructor:CarButton(PromptType, PromptProperties, CarButtonActivated, CarButtonFallback)
+
+			ButtonManagerConstructor:CarButton(PromptType, PromptProperties, function(ButtonFloor: number | string)
+				self.Events.__eventInstances__.FloorButtonActivated:Fire(true, ButtonFloor, PromptProperties :: Tags.ButtonPropertiesSafe)
+			end, function(ButtonFloor: number | string)
+				self.Events.__eventInstances__.FloorButtonActivated:Fire(false, ButtonFloor, PromptProperties :: Tags.ButtonPropertiesSafe)
+			end)
 		else
 			warn()
 		end
 	end
---	end
 end
 
 return Buttons

src/server/main/Elevators/Map/Haughton/Events.luau

@@ -0,0 +1,131 @@
+--!optimize 2
+--!native
+--!strict
+
+local ParentDir = script.Parent
+local ElevatorsDir = ParentDir.Parent.Parent
+local MainDir = ElevatorsDir.Parent
+
+local StorageService = game:GetService("ReplicatedStorage")
+
+local Enums         = require(StorageService:WaitForChild("Enums"))
+local InitElevator  = require(ElevatorsDir:WaitForChild("System"))
+local Buttons       = require(ParentDir:WaitForChild("Buttons"))
+local MovingObjects = require(ParentDir:WaitForChild("MovingObjects"))
+local TagsModule    = require(MainDir:WaitForChild("Map"):WaitForChild("Load"):WaitForChild("Tags"))
+local ElevatorTypes = require(MainDir:WaitForChild("Types"):WaitForChild("Elevator"))
+
+type ClassConstructor = typeof(setmetatable({} :: Constructor_Return_Props, {} :: Impl_Constructor))
+
+type Impl_Constructor = {
+	__index: Impl_Constructor,
+	constructor: Constructor_Fun,
+	--Class functions
+	Elevator: (self: ClassConstructor) -> (),
+	Buttons: (self: ClassConstructor) -> ()
+}
+
+type Constructor_Fun = (
+	InitElevatorConstructor: InitElevator.constructor,
+	ElevatorConfig: ElevatorTypes.ElevatorConfigurationTable,
+	ElevatorEvents: InitElevator.Events,
+	ElevatorAttributes: InitElevator.Attributes,
+	ButtonEvents: Buttons.Events,
+	ElevatorBoxModel: BasePart,
+	Leveling: {number},
+	MovingObjectsConstructor: MovingObjects.constructor
+) -> ClassConstructor
+
+type Constructor_Return_Props = {
+	InitElevatorConstructor: InitElevator.constructor,
+	ElevatorConfig: ElevatorTypes.ElevatorConfigurationTable,
+	ElevatorEvents: InitElevator.Events,
+	ElevatorAttributes: InitElevator.Attributes,
+	ButtonEvents: Buttons.Events,
+	ElevatorBoxModel: BasePart,
+	Leveling: {number},
+	MovingObjectsConstructor: MovingObjects.constructor
+}
+
+local Events = {} :: Impl_Constructor
+Events.__index = Events
+
+function Events.constructor(InitElevatorConstructor, ElevatorConfig, ElevatorEvents, ElevatorAttributes, ButtonEvents, ElevatorBoxModel, Leveling, MovingObjectsConstructor)
+	return setmetatable({
+		InitElevatorConstructor = InitElevatorConstructor,
+		ElevatorConfig = ElevatorConfig,
+		ElevatorEvents = ElevatorEvents,
+		ElevatorAttributes = ElevatorAttributes,
+		ButtonEvents = ButtonEvents,
+		ElevatorBoxModel = ElevatorBoxModel,
+		Leveling = Leveling,
+		MovingObjectsConstructor = MovingObjectsConstructor
+	}, Events)
+end
+
+function Events:Elevator()
+	self.ElevatorEvents.Traveling:Connect(function(_DeltaTime: number, CabPosition: Vector3)
+		local CabVelocity = self.ElevatorBoxModel:GetVelocityAtPosition(CabPosition)
+		local TravelingUpwards = self.ElevatorAttributes.TravelingUpwards.Value
+
+		self.MovingObjectsConstructor:RotatePulleyWheel(TravelingUpwards, CabVelocity.Y)
+		self.MovingObjectsConstructor:RotateRotodials(CabVelocity.Y)
+	end)
+	self.ElevatorEvents.Progression:Connect(function(previousFloor: number, CurrentFloor: number, NextFloor: number)
+
+	end)
+	self.ElevatorEvents.Leveling:Connect(function()
+		self.MovingObjectsConstructor:RotateRelayCogs2Async()
+	end)
+	self.ElevatorEvents.Leveling3Phase:Connect(function()
+
+	end)
+	self.ElevatorEvents.ManualTravelRequested:Connect(function()
+		self.MovingObjectsConstructor:ControllerStartAsync()
+		task.wait(1)
+		self.MovingObjectsConstructor:RotateRelayCogs1Async().Completed:Wait()
+		self.InitElevatorConstructor:StartTraveling()
+	end)
+	self.ElevatorEvents.TravelStart:Connect(function()
+
+	end)
+	self.ElevatorEvents.Parked:Connect(function()
+		self.MovingObjectsConstructor:RotateRelayCogs3()
+	end)
+end
+
+local function ElevatorGoingUpDirection(CurrentFloor: number, RequestedFloor: number): boolean
+	return CurrentFloor<RequestedFloor
+end
+
+function Events:Buttons()
+	self.ButtonEvents.FloorButtonActivated:Connect(function(Success: boolean, Floor: number | string, Properties: TagsModule.ButtonPropertiesSafe)
+		Properties.Prompt.Enabled = false
+		(Properties.Inst :: BasePart).Color = self.ElevatorConfig.Colors.ButtonActivated.Color;
+		(Properties.Inst :: BasePart).Material = self.ElevatorConfig.Colors.ButtonActivated.Material
+
+		if Success then
+			local CorrectFloor: number = 0
+			if type(Floor) == "string" then
+				if Floor == "B" then
+					CorrectFloor = 1
+				end
+			else
+				-- CorrectFloor = Floor~=#self.Leveling and Floor+1 or Floor
+				CorrectFloor = Floor
+			end
+			if CorrectFloor ~= 0 then
+				local Direction = ElevatorGoingUpDirection(self.ElevatorAttributes.CurrentFloor.Value, CorrectFloor) and Enums.ElevatorCallDirection.Up or Enums.ElevatorCallDirection.Down
+				task.spawn(function()
+					self.InitElevatorConstructor:RequestLevelAsync(CorrectFloor, Direction :: Enums.ElevatorCallDirectionValues)
+				end)
+			else
+				warn(`[{self.ElevatorConfig.Name}]: The floor index was 0. Call={Floor}`)
+			end
+		else
+
+		end
+	end)
+end
+
+return Events

src/server/main/Elevators/Map/Haughton/Leveling.luau

@@ -3,12 +3,12 @@
 --!strict
 
 return {
-	["B"] = 1.163,
+	[1] = 1.163, --Basement
-	[1] = 19.163,
+	[2] = 19.163,
-	[2] = 37.507,
+	[3] = 37.507,
-	[3] = 55.464,
+	[4] = 55.464,
-	[4] = 73.383,
+	[5] = 73.383,
-	[5] = 91.301,
+	[6] = 91.301,
-	[6] = 109.24,
+	[7] = 109.243,
-	[7] = 127.185,
+	[8] = 127.185,
 }

src/server/main/Elevators/Map/Haughton/MovingObjects.luau

@@ -13,11 +13,12 @@ type Impl_Constructor = {
 	__index: Impl_Constructor,
 	constructor: Constructor_Fun,
 	--Class functions
-	RotateRelayCogs1Async: (self: ClassConstructor) -> (),
+	RotateRelayCogs1Async: (self: ClassConstructor) -> Tween,
 	RotateRelayCogs2Async: (self: ClassConstructor) -> (),
 	RotateRelayCogs3: (self: ClassConstructor) -> (),
 	RotateRotodials: (self: ClassConstructor, Elevator_Y_Velocity: number) -> (),
 	RotatePulleyWheel: (self: ClassConstructor, TravelingUpwards: boolean, Elevator_Y_Velocity: number) -> (),
+	ControllerStartAsync: (self: ClassConstructor) -> (),
 } & Impl_Static_Props
 
 type Impl_Static_Props = {
@@ -35,6 +36,12 @@ type Constructor_Return_Props = {
 	Relay_Close: Sound,
 	Relay_FullOpen: Sound,
 	Relay_Open: Sound,
+	Controller_Start: Sound,
+	Controller_Hum: Sound,
+	Controller_End: Sound,
+	Controller_Clicks: Sound,
+	Pulley_Start: Sound,
+	Pulley_Moving: Sound,
 	MagnetCog_Row1: BasePart,
 	MagnetCog_Row2: BasePart,
 	MagnetCog_Row3: BasePart,
@@ -53,6 +60,8 @@ type Constructor_Return_Props = {
 	Rotodials: {Instance}
 }
 
+export type constructor = ClassConstructor
+
 local TS = game:GetService("TweenService")
 
 local MovingObjects = {} :: Impl_Constructor
@@ -72,6 +81,13 @@ function MovingObjects.constructor(TagsConstructor)
 	local Haughton_Relay_Close    = TagsConstructor:Request("Haughton_Relay_Close") :: Sound
 	local Haughton_Relay_FullOpen = TagsConstructor:Request("Haughton_Relay_FullOpen") :: Sound
 	local Haughton_Relay_Open     = TagsConstructor:Request("Haughton_Relay_Open") :: Sound
+	local Controller_Start        = TagsConstructor:Request("Haughton_Controller_Start") :: Sound
+	local Controller_Hum          = TagsConstructor:Request("Haughton_Controller_Hum") :: Sound
+	local Controller_End          = TagsConstructor:Request("Haughton_Controller_End") :: Sound
+	local Controller_Clicks       = TagsConstructor:Request("Haughton_Controller_Clicks") :: Sound
+	local Pulley_Moving           = TagsConstructor:Request("Haughton_Pulley_Moving") :: Sound
+	local Pulley_Start            = TagsConstructor:Request("Haughton_Pulley_Start") :: Sound
+	Controller_Hum.Looped = true
 
 	local MagnetCog_Row1     = TagsConstructor:Request("Haughton_MagnetCog_Row1") :: BasePart
 	local MagnetCog_Row2     = TagsConstructor:Request("Haughton_MagnetCog_Row2") :: BasePart
@@ -101,6 +117,12 @@ function MovingObjects.constructor(TagsConstructor)
 		Relay_Close = Haughton_Relay_Close,
 		Relay_FullOpen = Haughton_Relay_FullOpen,
 		Relay_Open = Haughton_Relay_Open,
+		Controller_Start = Controller_Start,
+		Controller_Hum = Controller_Hum,
+		Controller_End = Controller_End,
+		Controller_Clicks = Controller_Clicks,
+		Pulley_Moving = Pulley_Moving,
+		Pulley_Start = Pulley_Start,
 		MagnetCog_Row1 = MagnetCog_Row1,
 		MagnetCog_Row2 = MagnetCog_Row2,
 		MagnetCog_Row3 = MagnetCog_Row3,
@@ -153,13 +175,29 @@ local function ElectricalFlash(Flash: PointLight)
 	end)
 end
 
+function MovingObjects:ControllerStartAsync()
+	if math.random(1,30) == 1 then
+		self.Controller_Start.SoundId = "rbxassetid://108739293674278"
+	else
+		self.Controller_Start.SoundId = "rbxassetid://75136143926200"
+	end
+	self.Controller_Start:Play()
+	self.Controller_Start.Ended:Wait()
+	self.Controller_Hum:Play()
+end
+
 function MovingObjects:RotateRelayCogs1Async()
 	self.Relay_Close:Play()
 	RotateRelayCogs(true, false, self.MagnetCog_Row3, self.Cog2_Row3, self.Row3_CounterWeight, self.Row3_RelayDown)
 	task.wait(.30)
 	RotateRelayCogs(true, false, self.MagnetCog_Row2, self.Cog2_Row2, self.Row2_CounterWeight, self.Row2_Relays)
 	task.wait(.30)
-	RotateRelayCogs(true, true, self.MagnetCog_Row4, self.Cog2_Row4, self.Row4_CounterWeight, self.Row4_Relays)
+	self.Pulley_Start:Play()
+	task.spawn(function()
+		self.Pulley_Start.Ended:Wait()
+		self.Pulley_Moving:Play()
+	end)
+	return RotateRelayCogs(true, true, self.MagnetCog_Row4, self.Cog2_Row4, self.Row4_CounterWeight, self.Row4_Relays)
 end
 
 function MovingObjects:RotateRelayCogs2Async()
@@ -171,6 +209,9 @@ function MovingObjects:RotateRelayCogs2Async()
 	task.wait(.1)
 	RotateRelayCogs(false, true,self.MagnetCog_Row4, self.Cog2_Row4, self.Row4_CounterWeight, self.Row4_Relays)
 	ElectricalFlash(self.Row4_Flash)
+	self.Pulley_Moving:Stop()
+	task.wait(2)
+	self.Controller_Clicks:Play()
 end
 
 function MovingObjects:RotateRelayCogs3()
@@ -179,6 +220,9 @@ function MovingObjects:RotateRelayCogs3()
 
 	RotateRelayCogs(false, false, self.MagnetCog_Row3, self.Cog2_Row3, self.Row3_CounterWeight, self.Row3_RelayDown)
 	self.Relay_FullOpen:Play()
+	self.Controller_Hum:Stop()
+	task.wait(3)
+	self.Controller_End:Play()
 end
 
 function MovingObjects:RotateRotodials(Elevator_Y_Velocity)

src/server/main/Elevators/Map/Haughton/init.luau

@@ -7,6 +7,7 @@ local ElevatorsDir = ParentDir.Parent
 local MainDir = ElevatorsDir.Parent
 
 local InitElevator  = require(ElevatorsDir:WaitForChild("System"))
+local Events        = require(script:WaitForChild("Events"))
 local Config        = require(script:WaitForChild("Config"))
 local Buttons       = require(script:WaitForChild("Buttons"))
 local Leveling      = require(script:WaitForChild("Leveling"))
@@ -14,37 +15,18 @@ local MovingObjects = require(script:WaitForChild("MovingObjects"))
 local TagsModule    = require(MainDir:WaitForChild("Map"):WaitForChild("Load"):WaitForChild("Tags"))
 
 return function(TagsConstructor: TagsModule.TagsConstructor, ButtonTags: TagsModule.ElevatorButtons, LanternTags: TagsModule.Lanterns, LandingDoorTags: TagsModule.LandingTags)
-
 	local ElevatorModel = TagsConstructor:Request("Elevator_Haughton") :: Model
 	local ElevatorBoxModel = ElevatorModel:WaitForChild("Mover") :: BasePart
 
 	local Elevator = InitElevator.constructor(ElevatorBoxModel, Config, Leveling)
-
 	local MovingObjectsConstructor = MovingObjects.constructor(TagsConstructor)
 	local ButtonsConstructor = Buttons.constructor(Config.Name, ButtonTags, Elevator.Attributes.CurrentFloor)
+	local EventsConstructor = Events.constructor(Elevator, Config, Elevator.Events, Elevator.Attributes, ButtonsConstructor.Events, ElevatorBoxModel, Leveling, MovingObjectsConstructor)
 
-	Elevator.Events.Traveling:Connect(function(_DeltaTime: number, CabPosition: Vector3)
+	EventsConstructor:Elevator()
-		local CabVelocity = ElevatorBoxModel:GetVelocityAtPosition(CabPosition)
+	EventsConstructor:Buttons()
-		local TravelingUpwards = Elevator.Attributes.TravelingUpwards.Value
+	ButtonsConstructor:InitForElevator(2, Vector3.new(-.05,0,0))
 
-		MovingObjectsConstructor:RotatePulleyWheel(TravelingUpwards, CabVelocity.Y)
+	-- task.wait(3)
-		MovingObjectsConstructor:RotateRotodials(CabVelocity.Y)
+	-- Elevator:RequestLevelAsync(7, "Down")
-	end)
-
-	Elevator.Events.Progression:Connect(function(previousFloor: number, CurrentFloor: number, NextFloor: number)
-		warn("previousFloor=",previousFloor,"CurrentFloor=", CurrentFloor, "NextFloor=",NextFloor)
-	end)
-
-	Elevator.Events.Leveling:Connect(function()
-		MovingObjectsConstructor:RotateRelayCogs2Async()
-	end)
-
-	Elevator.Events.Parked:Connect(function()
-		MovingObjectsConstructor:RotateRelayCogs3()
-	end)
-
-	ButtonsConstructor:Hook()
-
-	-- MovingObjectsConstructor:RotateRelayCogs1Async()
-	-- Elevator:StartTraveling()
 end

src/server/main/Elevators/System/init.luau

@@ -75,18 +75,24 @@ export type Attributes = {
 export type Events = {
 	Progression: RBXScriptSignal<number, number, number>,
 	Traveling: RBXScriptSignal<number, Vector3>,
+	TravelStart: RBXScriptSignal,
+	ManualTravelRequested: RBXScriptSignal,
 	Parked: RBXScriptSignal,
 	Leveling: RBXScriptSignal,
 	Leveling3Phase: RBXScriptSignal,
 	__eventInstances__: {
 		Progression: BindableEvent,
 		Traveling: BindableEvent,
+		TravelStart: BindableEvent,
+		ManualTravelRequested: BindableEvent,
 		Parked: BindableEvent,
 		Leveling: BindableEvent,
 		Leveling3Phase: BindableEvent,
 	}
 }
 
+export type constructor = ClassConstructor
+
 local Elevator = {} :: Impl_Constructor
 Elevator.__index = Elevator
 
@@ -147,6 +153,8 @@ function Elevator.constructor(ElevatorBoxModel, ElevatorConfigurationTable, Floo
 
 	local CabProgression = Instance.new("BindableEvent") :: BindableEvent
 	local CabTraveling = Instance.new("BindableEvent") :: BindableEvent
+	local CabTravelStart = Instance.new("BindableEvent") :: BindableEvent
+	local ManualTravelRequested = Instance.new("BindableEvent") :: BindableEvent
 	local Parked = Instance.new("BindableEvent") :: BindableEvent
 	local Leveling = Instance.new("BindableEvent") :: BindableEvent
 	local Leveling3Phase = Instance.new("BindableEvent") :: BindableEvent
@@ -178,15 +186,20 @@ function Elevator.constructor(ElevatorBoxModel, ElevatorConfigurationTable, Floo
 			AlignPosition      = BoxAlignPosition,
 			Configuration      = ElevatorConfigurationTable,
 		},
+
 		Events = {
 			Progression = CabProgression.Event,
 			Traveling = CabTraveling.Event,
+			TravelStart = CabTravelStart.Event,
+			ManualTravelRequested = ManualTravelRequested.Event,
 			Parked = Parked.Event,
 			Leveling = Leveling.Event,
 			Leveling3Phase = Leveling3Phase.Event,
 			__eventInstances__ = {
 				Progression = CabProgression,
 				Traveling = CabTraveling,
+				TravelStart = CabTravelStart,
+				ManualTravelRequested = ManualTravelRequested,
 				Parked = Parked,
 				Leveling = Leveling,
 				Leveling3Phase = Leveling3Phase,
@@ -377,6 +390,7 @@ end
 
 function Elevator:__TravelToFloorAsync(Level_Int, LEVEL_VEC3_Y_WRAP)
 	if self.Elevator.Configuration.Functions.ManualTravelStart then
+		self.Events.__eventInstances__.ManualTravelRequested:Fire()
 		self.__functionEvents.StartTraveling.Event:Wait()
 	end
 	if self.__Connections.Moving and self.__Connections.Moving.Connected then
@@ -384,6 +398,7 @@ function Elevator:__TravelToFloorAsync(Level_Int, LEVEL_VEC3_Y_WRAP)
 	end
 
 	assert(not self.Elevator.BoxModel.Anchored, "The elevator cannot move! Its box model is Anchored.")
+	self.Events.__eventInstances__.TravelStart:Fire()
 
 	local ElevatorTravelingUpwards = ElevatorGoingUpDirection(self.Attributes.CurrentFloor.Value, Level_Int)
 	self.Attributes.Goal.Value = Level_Int
@@ -405,10 +420,14 @@ function Elevator:RequestLevelAsync(RequestedLevel, Direction)
 	local Level = self:GetLevel(RequestedLevel)
 
 	if Level then
-		if (RequestedLevel == 1 and Direction == Enums.ElevatorCallDirection.Down) or (RequestedLevel == #self.FloorLevelingPositions and Direction == Enums.ElevatorCallDirection.Up) then
+		if (RequestedLevel == 1 and Direction == Enums.ElevatorCallDirection.Down) then
-			self.ewarn(`Impossible direction requested, Direction={Direction}, RequestedLevel={Level}`)
+			self.ewarnStudio(`Impossible direction requested, Direction={Direction}, RequestedLevel={RequestedLevel}. correcting...`)
-			return false
+			Direction = Enums.ElevatorCallDirection.Up
-		else
+		elseif (RequestedLevel == #self.FloorLevelingPositions and Direction == Enums.ElevatorCallDirection.Up) then
+			self.ewarnStudio(`Impossible direction requested, Direction={Direction}, RequestedLevel={RequestedLevel}. correcting...`)
+			Direction = Enums.ElevatorCallDirection.Down
+		end
+
 		local DirectionQueue = Direction == Enums.ElevatorCallDirection.Up and self.RelayAlgorithm.FloorQueue.Up or self.RelayAlgorithm.FloorQueue.Down
 	--	local OppositeQueue = Direction == Enums.ElevatorCallDirection.Up and self.RelayAlgorithm.FloorQueue.Down or self.RelayAlgorithm.FloorQueue.Up
 
@@ -416,7 +435,6 @@ function Elevator:RequestLevelAsync(RequestedLevel, Direction)
 		if #DirectionQueue == 1 then
 			self:__TravelToFloorAsync(RequestedLevel, Level)
 		end
-		end
 		return true
 	end
 	self.ewarn(`Requested floor: "{RequestedLevel}" does not exist for this elevator`)

src/server/main/Types/Elevator.luau

@@ -9,11 +9,26 @@ local StorageService = game:GetService("ReplicatedStorage")
 local Enums      = require(StorageService:WaitForChild("Enums"))
 local SoundEnums = require(EnumsDir:WaitForChild("Sounds"))
 
-type ButtonProperties =  {
+export type ButtonProperties =  {
 	Color: Color3,
 	Material: Enum.Material
 }
 
+export type Colors = {
+	ButtonActivated: ButtonProperties,
+	ButtonDeactivated: ButtonProperties,
+	LanternIndicator: {
+		On: {
+			Up: ButtonProperties,
+			Down: ButtonProperties
+		},
+		Off: {
+			Up: ButtonProperties,
+			Down: ButtonProperties
+		}
+	},
+}
+
 export type ElevatorConfigurationTable = {
 	Name: Enums.ElevatorValues,
 	Responsiveness: number,
@@ -31,20 +46,7 @@ export type ElevatorConfigurationTable = {
 		LanternChimeDirection: SoundEnums.ElevatorSoundValues,
 		LanternChimeLanding: SoundEnums.ElevatorSoundValues,
 	},
-	Colors: {
+	Colors: Colors,
-		ButtonActivated: ButtonProperties,
-		ButtonDeactivated: ButtonProperties,
-		LanternIndicator: {
-			On: {
-				Up: ButtonProperties,
-				Down: ButtonProperties
-			},
-			Off: {
-				Up: ButtonProperties,
-				Down: ButtonProperties
-			}
-		},
-	},
 }
 
 return nil