Working landing doors, cab doors attempt

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

@@ -70,7 +70,7 @@ local DoorsConfig: ElevatorTypes.DoorsConfig = {
 	Landing = {
 		Type = DoorEnums.Door.SingleSpeed,
 		Time = 4,
-		Goal = Vector3.new(4.15,0,0)
+		Goal = Vector3.new(4.221,0,0)
 	}
 }
 

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

@@ -21,21 +21,16 @@ type Impl_Constructor = {
 	__index: Impl_Constructor,
 	constructor: Constructor_Fun,
 	--Class functions
-	OpenCabAsync: (self: ClassConstructor, ObjectSpaceDistance: Vector3) -> (),
+	OpenCabAsync: (self: ClassConstructor) -> (),
-	CloseCabAsync: (self: ClassConstructor, ObjectSpaceDistance: Vector3) -> (),
+	CloseCabAsync: (self: ClassConstructor) -> (),
 	OpenAtFloorAsync: (self: ClassConstructor, Floor: number) -> (),
 	CloseAtFloorAsync: (self: ClassConstructor, Floor: number) -> (),
 }
 
-type CabDoorsTree = {
-	[number]: {BasePart}
-}
-
 type Constructor_Fun = (
 	DoorConfig: ElevatorEnums.DoorsConfig,
 	ElevatorBox: BasePart,
-	CabDoorsTree: {BasePart},
+	DoorsTree: Tags.LandingTags
-	LandingDoorsTree: Tags.LandingTags
 ) -> ClassConstructor
 
 type Attributes = {
@@ -51,8 +46,7 @@ type Events = {
 type Constructor_Return_Props = {
 	DoorConfig: ElevatorEnums.DoorsConfig,
 	ElevatorBox: BasePart,
-	CabDoorsTree: {BasePart},
+	DoorsTree: Tags.LandingTags,
-	LandingDoorsTree: Tags.LandingTags,
 	Attributes: Attributes,
 
 	__Connections: {
@@ -63,15 +57,14 @@ type Constructor_Return_Props = {
 local Doors = {} :: Impl_Constructor
 Doors.__index = Doors
 
-function Doors.constructor(DoorConfig, ElevatorBox, CabDoorsTree, LandingDoorsTree)
+function Doors.constructor(DoorConfig, ElevatorBox, LandingDoorsTree)
 	local HallOpen = Instance.new("BoolValue") :: BoolValue
 	HallOpen.Value = true
 
 	return setmetatable({
 		DoorConfig = DoorConfig,
 		ElevatorBox = ElevatorBox,
-		CabDoorsTree = CabDoorsTree,
+		DoorsTree = LandingDoorsTree,
-		LandingDoorsTree = LandingDoorsTree,
 
 		Attributes = {
 			Hall = {
@@ -106,7 +99,7 @@ type DoorAnimationsMap = {
 		DoubleSpeed: DoorAnimationCallback<Vector3, Vector3, Vector3, Vector3>,
 		TripleSpeed: DoorAnimationCallback<Vector3, Vector3, Vector3, Vector3, Vector3, Vector3>,
 	},
-	Floor: {
+	Landing: {
 		SingleSpeed: DoorAnimationCallback<number, Vector3, Vector3>,
 		DoubleSpeed: DoorAnimationCallback<number, Vector3, Vector3, Vector3>,
 		TripleSpeed: DoorAnimationCallback<number, Vector3, Vector3, Vector3, Vector3>,
@@ -114,101 +107,135 @@ type DoorAnimationsMap = {
 }
 local DoorAnimations = {
 	Cab = {},
-	Floor = {}
+	Landing = {}
 } :: DoorAnimationsMap
 
 --Cab doors--
 function DoorAnimations.Cab.SingleSpeed(self, AnimationTime, Door1Position, OpenToVec1)
 	local ElevatorY = Vector3.new(0, self.ElevatorBox.Position.Y, 0)
 	local ElevatorDoor1_Goal = Vector3.new(OpenToVec1.X, 0, OpenToVec1.Z)
+	local CabDoor1 = self.DoorsTree.Cab[1] :: BasePart
 
-	self.CabDoorsTree[1].Position = ElevatorY+self.CabDoorsTree[1].Position:Lerp(OpenToVec1+ElevatorDoor1_Goal, Algebra.Easing.InOutQuart(AnimationTime))
+	CabDoor1.Position = ElevatorY+CabDoor1.Position:Lerp(OpenToVec1+ElevatorDoor1_Goal, Algebra.Easing.OutQuad(AnimationTime))
 end
 
 function DoorAnimations.Cab.DoubleSpeed(self, AnimationTime, Door1Position, Door2Position, OpenToVec1, OpenToVec2)
+	local OutQuad = Algebra.Easing.OutQuad(AnimationTime)
+	local ElevatorY = Vector3.new(0, self.ElevatorBox.Position.Y, 0)
+	local ElevatorDoor1_Goal = Vector3.new(OpenToVec1.X, 0, OpenToVec1.Z)
+	local ElevatorDoor2_Goal = Vector3.new(OpenToVec2.X, 0, OpenToVec2.Z)
+	local CabDoor1 = self.DoorsTree.Cab[1] :: BasePart
+	local CabDoor2 = self.DoorsTree.Cab[2] :: BasePart
 
+	CabDoor1.Position = ElevatorY+CabDoor1.Position:Lerp(ElevatorDoor1_Goal, OutQuad)
+	CabDoor2.Position = ElevatorY+CabDoor2.Position:Lerp(ElevatorDoor2_Goal, OutQuad)
 end
 
 function DoorAnimations.Cab.TripleSpeed(self, AnimationTime, Door1Position, Door2Position, Door3Position, OpenToVec1, OpenToVec2, OpenToVec3)
+	local OutQuad = Algebra.Easing.OutQuad(AnimationTime)
+	local ElevatorY = Vector3.new(0, self.ElevatorBox.Position.Y, 0)
+	local ElevatorDoor1_Goal = Vector3.new(OpenToVec1.X, 0, OpenToVec1.Z)
+	local ElevatorDoor2_Goal = Vector3.new(OpenToVec2.X, 0, OpenToVec2.Z)
+	local ElevatorDoor3_Goal = Vector3.new(OpenToVec3.X, 0, OpenToVec3.Z)
+	local CabDoor1 = self.DoorsTree.Cab[1] :: BasePart
+	local CabDoor2 = self.DoorsTree.Cab[2] :: BasePart
+	local CabDoor3 = self.DoorsTree.Cab[3] :: BasePart
 
+	CabDoor1.Position = ElevatorY+CabDoor1.Position:Lerp(ElevatorDoor1_Goal, OutQuad)
+	CabDoor2.Position = ElevatorY+CabDoor2.Position:Lerp(ElevatorDoor2_Goal, OutQuad)
+	CabDoor3.Position = ElevatorY+CabDoor3.Position:Lerp(ElevatorDoor3_Goal, OutQuad)
 end
 ----
 
 --Floor doors--
-function DoorAnimations.Floor.SingleSpeed(self, Floor, AnimationTime, Door1Position, OpenToVec1)
+function DoorAnimations.Landing.SingleSpeed(self, Floor, AnimationTime, Door1Position, OpenToVec1)
-	(self.LandingDoorsTree[Floor][1] :: BasePart).Position = Door1Position:Lerp(OpenToVec1, Algebra.Easing.OutQuad(AnimationTime))
+	(self.DoorsTree.Hall[Floor][1] :: BasePart).Position = Door1Position:Lerp(OpenToVec1, Algebra.Easing.OutQuad(AnimationTime))
 end
 ---
 
 --Goofy ahh function
-local function OpenVecTuple(self: ClassConstructor, FloorWithDoors: Tags.LandingDoors, Opening: boolean, Type: DoorEnums.DoorEnumValues): ...Vector3?
+local function OpenVecTuple(self: ClassConstructor, Opening: boolean, Type: DoorEnums.DoorLocationValues, HallFloor: number?): ...Vector3?
-	if Type == DoorEnums.Door.SingleSpeed then
+	if Type == DoorEnums.DoorLocation.Landing and not HallFloor then
-		local P = (FloorWithDoors[1] :: BasePart).Position
+		warn("Hall/landing doors were called but no HallFloor number was received")
+		return nil
+	end
+	local DoorsType: {Instance} = Type == DoorEnums.DoorLocation.Cab and self.DoorsTree.Cab or self.DoorsTree.Hall[HallFloor :: number]
+	local ConfType = Type == DoorEnums.DoorLocation.Cab and self.DoorConfig.Cab or self.DoorConfig.Landing
+
+	if ConfType.Type == DoorEnums.Door.SingleSpeed then
+		local P = (DoorsType[1] :: BasePart).Position
+		local Direction = Opening and -ConfType.Goal or ConfType.Goal
 		return table.unpack({
 			P,
-			P+(Opening and -self.DoorConfig.Cab.Goal or self.DoorConfig.Cab.Goal)
+			P+Direction
 		})
-	elseif Type == DoorEnums.Door.DoubleSpeed then
+	elseif ConfType.Type == DoorEnums.Door.DoubleSpeed then
-		local P = (FloorWithDoors[1] :: BasePart).Position
+		local P = (DoorsType[1] :: BasePart).Position
-		local P2 = (FloorWithDoors[2] :: BasePart).Position
+		local P2 = (DoorsType[2] :: BasePart).Position
+		local Direction = Opening and -ConfType.Goal or ConfType.Goal
 		return table.unpack({
 			P,
 			P2,
-			P+(Opening and -self.DoorConfig.Cab.Goal or self.DoorConfig.Cab.Goal),
+			P+Direction,
-			(P2+(Opening and -self.DoorConfig.Cab.Goal or self.DoorConfig.Cab.Goal))/2
+			(P2+Direction)/2
 		})
-	elseif Type == DoorEnums.Door.TripleSpeed then
+	elseif ConfType.Type == DoorEnums.Door.TripleSpeed then
 		--idk man
-		local P = (FloorWithDoors[1] :: BasePart).Position
+		local P = (DoorsType[1] :: BasePart).Position
-		local P2 = (FloorWithDoors[2] :: BasePart).Position
+		local P2 = (DoorsType[2] :: BasePart).Position
-		local P3 = (FloorWithDoors[3] :: BasePart).Position
+		local P3 = (DoorsType[3] :: BasePart).Position
+		local Direction = Opening and -ConfType.Goal or ConfType.Goal
 		return table.unpack({
 			P,
 			P2,
 			P3,
-			P+(Opening and -self.DoorConfig.Cab.Goal or self.DoorConfig.Cab.Goal),
+			P+Direction,
-			(P2+(Opening and -self.DoorConfig.Cab.Goal or self.DoorConfig.Cab.Goal))/1.5,
+			(P2+Direction)/1.5,
-			(P3+(Opening and -self.DoorConfig.Cab.Goal or self.DoorConfig.Cab.Goal))/2,
+			(P3+Direction)/2,
 		})
 	end
 	return nil
 end
 
-function Doors:OpenCabAsync(ObjectSpaceDistance)
-	-- local OpenFromVecTuple = self.CabDoorsTree[1].Position+ObjectSpaceDistance
-	-- --local Open = OpenVecTuple(self, DoorEnums.DoorLocation.Cab)
-
-	-- DoorAnimationRuntime(self, self.DoorConfig.Cab.Time, function(self, AnimationTime)
-	-- 	DoorAnimations.Cab[self.DoorConfig.Cab.Type](self, AnimationTime, OpenFromVecTuple)
-	-- end)
-end
-
-function Doors:CloseCabAsync(ObjectSpaceDistance)
-
-end
-
 --this module is built off my insanity
-local function ToggleFloorDoors(self: ClassConstructor, Floor: number, Opening: boolean)
+local function ToggleDoors(self: ClassConstructor, Type: DoorEnums.DoorLocationValues, Opening: boolean, Floor: number?): boolean
-	local FloorWithDoors = self.LandingDoorsTree[Floor]
+	local Config: ElevatorEnums.DoorsConfigProperties? = Type == DoorEnums.DoorLocation.Cab and self.DoorConfig.Cab or self.DoorConfig.Landing
-	if FloorWithDoors then
+	if Config then
-		local OpenFromVecTuple = OpenVecTuple(self, FloorWithDoors, Opening, self.DoorConfig.Landing.Type)
+		local P1, P2, P3, P4, P5, P6 = OpenVecTuple(self, Opening, Type, Floor)
-		assert(OpenFromVecTuple)
+		if P1 then
-
+			if Type == DoorEnums.DoorLocation.Cab then
-		DoorAnimationRuntime(self, self.DoorConfig.Landing.Time, function(self, AnimationTime)
+				DoorAnimationRuntime(self, Config.Time, function(self, AnimationTime)
-			DoorAnimations.Floor[self.DoorConfig.Landing.Type](self, Floor, AnimationTime, OpenFromVecTuple)
+					DoorAnimations.Cab[Config.Type](self, AnimationTime, P1, P2, P3, P4, P5, P6)
 				end)
 			else
-		warn(`Could not open the door at floor: {Floor}, it does not exist in the landing doors tree.`)
+				DoorAnimationRuntime(self, Config.Time, function(self, AnimationTime)
+					DoorAnimations.Landing[Config.Type](self, Floor, AnimationTime, P1, P2, P3, P4, P5, P6)
+				end)
 			end
+		else
+			return false
+		end
+	else
+		warn("Could not open the elevator doors", debug.traceback())
+		return false
+	end
+	return true
+end
+
+function Doors:OpenCabAsync()
+	ToggleDoors(self, DoorEnums.DoorLocation.Cab, true)
+end
+
+function Doors:CloseCabAsync()
+	ToggleDoors(self, DoorEnums.DoorLocation.Cab, false)
 end
 
 function Doors:CloseAtFloorAsync(Floor)
-	ToggleFloorDoors(self, Floor, false)
+	ToggleDoors(self, DoorEnums.DoorLocation.Landing, false, Floor)
 end
 
 function Doors:OpenAtFloorAsync(Floor)
-	ToggleFloorDoors(self, Floor, true)
+	ToggleDoors(self, DoorEnums.DoorLocation.Landing, true, Floor)
 end
 
-
 return Doors

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

@@ -17,7 +17,6 @@ local MovingObjects = require(script:WaitForChild("MovingObjects"))
 local TractionRopes = require(script:WaitForChild("TractionRopes"))
 local Doors         = require(script:WaitForChild("Doors"))
 local TagsModule    = require(MainDir:WaitForChild("Map"):WaitForChild("Load"):WaitForChild("Tags"))
-local DoorEnums     = require(MainDir:WaitForChild("Types"):WaitForChild("Enums"):WaitForChild("Doors"))
 
 return function(TagsConstructor: TagsModule.TagsConstructor, ButtonTags: TagsModule.ElevatorButtons, LanternTags: TagsModule.Lanterns, LandingDoorTags: TagsModule.LandingTags)
 	local ElevatorModel = TagsConstructor:Request("Elevator_Haughton") :: Model
@@ -25,16 +24,13 @@ return function(TagsConstructor: TagsModule.TagsConstructor, ButtonTags: TagsMod
 	local PulleyRopesObject = TagsConstructor:Request("Haughton_Rope_Pulley") :: BasePart
 	local ElevatorBoxModel = ElevatorModel:WaitForChild("Mover") :: BasePart
 
-	--TEMP
-	local CabDoorsTree = {} :: {BasePart}
-
 	local Elevator = InitElevator.constructor(ElevatorBoxModel, Config.Elevator, Leveling)
 	local MovingObjectsConstructor = MovingObjects.constructor(TagsConstructor)
 	local ButtonsConstructor = Buttons.constructor(Config.Elevator.Name, ButtonTags, Elevator.Attributes.CurrentFloor)
 	ButtonsConstructor:InitForElevator(2, ButtonPromptsDistance)
 
 	local TractionRopesConstructor = TractionRopes.constructor(CabRopesObject, PulleyRopesObject)
-	local DoorsConstructor = Doors.constructor(Config.Doors, ElevatorBoxModel, CabDoorsTree, LandingDoorTags)
+	local DoorsConstructor = Doors.constructor(Config.Doors, ElevatorBoxModel, LandingDoorTags)
 	local EventsConstructor = Events.constructor(
 		Elevator,
 		Config.Elevator,
@@ -47,5 +43,7 @@ return function(TagsConstructor: TagsModule.TagsConstructor, ButtonTags: TagsMod
 	EventsConstructor:InitButtons()
 
 	task.wait(2)
-	DoorsConstructor:CloseAtFloorAsync(1)
+	DoorsConstructor:OpenCabAsync()
+	task.wait(5)
+	DoorsConstructor:CloseCabAsync()
 end

src/server/main/Map/Load/Tags/init.luau

@@ -140,9 +140,15 @@ export type ExportedTags = {
 }
 
 export type LandingDoors = {Instance}
+export type CabDoors = {
+	[number]: Instance
+}
 
 export type LandingTags = {
+	Cab: CabDoors,
+	Hall: {
 		[number]: LandingDoors
+	}
 }
 
 export type DoorTags = {
@@ -290,7 +296,10 @@ function Tags:__ElevatorDoors()
 	local Doors: DoorTags = {}
 
 	for _, EnumValue in Enums.Elevator do
-		Doors[EnumValue :: Enums.ElevatorValues] = {}
+		Doors[EnumValue :: Enums.ElevatorValues] = {
+			Hall = {},
+			Cab = {}
+		}
 
 		for TagName: string, Inst: TagProduct in self.__dump do
 			local Split = TagName:split('_')
@@ -304,19 +313,17 @@ function Tags:__ElevatorDoors()
 					if DoorHint == "Door" then
 						local FloorNumberMatch = FloorHint:match('%d+$')
 						local FloorNumber = FloorNumberMatch and tonumber(FloorNumberMatch)
-
 						if FloorNumber then
 							local DoorNumberPlacement = tonumber(DoorNumber)
-
 							if DoorNumberPlacement then
-								if not Doors[ModelHint][FloorNumber] then
+								if not Doors[ModelHint].Hall[FloorNumber] then
-									Doors[ModelHint][FloorNumber] = {}
+									Doors[ModelHint].Hall[FloorNumber] = {}
 								end
-								if typeof(Inst) ~= "Instance" then
+								if typeof(Inst) == "Instance" then
-									Inst = Inst[1]
+									table.insert(Doors[ModelHint].Hall[FloorNumber], DoorNumberPlacement, Inst)
-									warn(`[{ModelHint}] Door {Inst} was not a single instance, duplicate doors detected Tag={TagName}`)
+								else
+									warn(`[{ModelHint}] Door {Inst[1]} was not a single instance, duplicate doors detected Tag={TagName}`)
 								end
-								table.insert(Doors[ModelHint][FloorNumber], DoorNumberPlacement, Inst :: Instance)
 							else
 
 							end
@@ -326,6 +333,22 @@ function Tags:__ElevatorDoors()
 					else
 						warn(`TODO block hit. Inst={Inst},`, debug.traceback())
 					end
+				elseif FloorHint:match('^Cab$') then
+					if DoorHint == "Door" then
+						local DoorNumberMatch = DoorNumber:match('^%d+$')
+						local DoorIndex = DoorNumberMatch and tonumber(DoorNumberMatch)
+						if DoorIndex then
+							if not Doors[ModelHint].Cab[DoorIndex] then
+								if typeof(Inst) == "Instance" then
+									table.insert(Doors[ModelHint].Cab, DoorIndex, Inst)
+								else
+									warn(`[{ModelHint}] Door {Inst[1]} was not a single instance, duplicate doors detected Tag={TagName}`)
+								end
+							end
+						end
+					else
+						warn(`Invalid floor label {FloorHint} for door {TagName},`, debug.traceback())
+					end
 				end
 			end
 		end

src/server/main/Types/Elevator.luau

@@ -52,17 +52,15 @@ export type ElevatorConfigurationTable = {
 	Colors: Colors,
 }
 
+export type DoorsConfigProperties = {
+	Type: DoorEnums.DoorEnumValues,
+	Time: number,
+	Goal: Vector3
+}
+
 export type DoorsConfig = {
-	Cab: {
+	Cab: DoorsConfigProperties,
-		Type: DoorEnums.DoorEnumValues,
+	Landing: DoorsConfigProperties
-		Time: number,
-		Goal: Vector3
-	},
-	Landing: {
-		Type: DoorEnums.DoorEnumValues,
-		Time: number,
-		Goal: Vector3
-	}
 }
 
 return nil