Working door close, TODO: Branch out the Algebra module into its own custom math tweening on vacation trip

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

@@ -6,13 +6,22 @@ local ParentDir = script.Parent
 local ElevatorsDir = ParentDir.Parent.Parent
 local MainDir = ElevatorsDir.Parent
 
+local Storage = game:GetService("ReplicatedStorage")
+local RS = game:GetService("RunService")
+
 local DoorEnums = require(MainDir:WaitForChild("Types"):WaitForChild("Enums"):WaitForChild("Doors"))
+local Tags = require(MainDir:WaitForChild("Map"):WaitForChild("Load"):WaitForChild("Tags"))
+local Algebra = require(Storage:WaitForChild("Algebra"))
 
 type ClassConstructor = typeof(setmetatable({} :: Constructor_Return_Props, {} :: Impl_Constructor))
 type Impl_Constructor = {
 	__index: Impl_Constructor,
 	constructor: Constructor_Fun,
 	--Class functions
+	OpenCabAsync: (self: ClassConstructor, ObjectSpaceDistance: Vector3) -> (),
+	CloseCabAsync: (self: ClassConstructor, ObjectSpaceDistance: Vector3) -> (),
+	OpenFloorAsync: (self: ClassConstructor, Floor: number, ObjectSpaceDistance: Vector3) -> (),
+	CloseFloorAsync: (self: ClassConstructor, Floor: number, ObjectSpaceDistance: Vector3) -> (),
 }
 
 type LandingDoorsTree = {
@@ -23,26 +32,114 @@ type CabDoorsTree = {
 }
 
 type Constructor_Fun = (
-
+	ElevatorBox: BasePart,
+	CabDoorsType: DoorEnums.DoorEnumValues,
+	CabDoorsTree: {BasePart},
+	LandingDoorsType: DoorEnums.DoorEnumValues,
+	LandingDoorsTree: Tags.LandingTags
 ) -> ClassConstructor
 
 type Constructor_Return_Props = {
-
+	ElevatorBox: BasePart,
+	CabDoorsType: DoorEnums.DoorEnumValues,
+	CabDoorsTree: {BasePart},
+	LandingDoorsType: DoorEnums.DoorEnumValues,
+	LandingDoorsTree: Tags.LandingTags
 }
 
-local Doors = {}
+local Doors = {} :: Impl_Constructor
 Doors.__index = Doors
 
-function Doors.constructor(CabDoorsType, LandingDoorsType, LandingDoorsTree, CabDoorsTree)
+function Doors.constructor(ElevatorBox, CabDoorsType, CabDoorsTree, LandingDoorsType, LandingDoorsTree)
-	return setmetatable({}, Doors)
+	return setmetatable({
+		ElevatorBox = ElevatorBox,
+		CabDoorsType = CabDoorsType,
+		CabDoorsTree = CabDoorsTree,
+		LandingDoorsType = LandingDoorsType,
+		LandingDoorsTree = LandingDoorsTree
+	}, Doors)
 end
 
-function Doors:Open()
+type DoorAnimationCallback<T...> = (self: ClassConstructor, Alpha: number, Time: number, T...) -> ()
+local function DoorAnimationAsync(self: ClassConstructor, Time: number, Callback: DoorAnimationCallback<()>)
+	local Alpha = 0
+	local StartTime = os.clock()
+	while RS.Stepped:Wait() do
+		Alpha+=1e-3
+		local AnimationTime = Algebra.LinearElapse(StartTime, Time)
+		Callback(self, Alpha, AnimationTime)
+
+		if AnimationTime>=1 then
+			print("door animation killed")
+			break
+		end
+	end
+end
+
+type DoorAnimationsMap = {
+	Cab: {[DoorEnums.DoorEnumValues]: DoorAnimationCallback<Vector3, Vector3?, Vector3?>},
+	Floor: {[DoorEnums.DoorEnumValues]: DoorAnimationCallback<number, Vector3, Vector3>}
+}
+local DoorAnimations: DoorAnimationsMap = {
+	Cab = {},
+	Floor = {}
+}
+
+DoorAnimations.Cab[DoorEnums.Door.SingleSpeed] = function(self, Alpha, AnimationTime, OpenFromVec1)
+	local ElevatorY = Vector3.new(0, self.ElevatorBox.Position.Y, 0)
+	local ElevatorDoor1_Goal = Vector3.new(OpenFromVec1.X, 0, OpenFromVec1.Z)
+
+	self.CabDoorsTree[1].Position = ElevatorY+self.CabDoorsTree[1].Position:Lerp(OpenFromVec1+ElevatorDoor1_Goal, Algebra.Easing.InOutQuart(AnimationTime))
+end
+
+DoorAnimations.Cab[DoorEnums.Door.DoubleSpeed] = function(self, Alpha, AnimationTime, OpenFromVec1, OpenFromVec2)
 
 end
 
-function Doors:Close()
+DoorAnimations.Cab[DoorEnums.Door.TripleSpeed] = function(self, Alpha, AnimationTime, OpenFromVec1, OpenFromVec2, OpenFromVec3)
 
 end
 
+DoorAnimations.Floor[DoorEnums.Door.SingleSpeed] = function(self, Alpha, AnimationTime, Floor, DoorP, OpenFromVec1)
+	local Door = self.LandingDoorsTree[Floor][1] :: BasePart
+	Door.Position = DoorP:Lerp(OpenFromVec1, Algebra.Easing.OutQuad(AnimationTime))
+end
+
+function Doors:OpenCabAsync(ObjectSpaceDistance)
+	local OpenFromVecTuple = self.CabDoorsTree[1].Position+ObjectSpaceDistance
+	DoorAnimationAsync(self, 3, function(self, Alpha, Time)
+		DoorAnimations.Cab[self.CabDoorsType](self, Alpha, Time, OpenFromVecTuple)
+	end)
+end
+
+function Doors:CloseCabAsync(ObjectSpaceDistance)
+	local CloseFromVecTuple = self.CabDoorsTree[1].Position-ObjectSpaceDistance
+	DoorAnimationAsync(self, 3, function(self, Alpha, Time)
+		DoorAnimations.Cab[self.CabDoorsType](self, Alpha, Time, CloseFromVecTuple)
+	end)
+end
+
+function Doors:CloseFloorAsync(Floor, ObjectSpaceDistance)
+	--this needs to be made custom for self.CabDoorsType
+	local DoorFloor = self.LandingDoorsTree[Floor]
+	assert(DoorFloor)
+	local Door = DoorFloor[1]
+	assert(Door)
+	local DoorP = (Door :: BasePart).Position
+	local OpenFromVecTuple = DoorP+ObjectSpaceDistance
+	DoorAnimationAsync(self, 3, function(self, Alpha, Time)
+		DoorAnimations.Floor[self.CabDoorsType](self, Alpha, Time, Floor, DoorP, OpenFromVecTuple)
+	end)
+end
+
+function Doors:OpenFloorAsync(Floor, ObjectSpaceDistance)
+	-- --this needs to be made custom for self.CabDoorsType
+	-- local OpenFromVecTuple = (self.LandingDoorsTree[Floor][1] :: BasePart).Position+ObjectSpaceDistance
+
+	-- DoorAnimationAsync(self, 1, function(self, Alpha, Time)
+	-- 	DoorAnimations.Cab[self.CabDoorsType](self, Alpha, Time, OpenFromVecTuple)
+	-- end)
+end
+
+
 return Doors

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

@@ -59,9 +59,11 @@ local function ActivateButton(self: ClassConstructor, Properties: TagsModule.But
 end
 
 local function ButtonAttributes(self: ClassConstructor)
-	self.ElevatorConstructor.Attributes.CurrentFloor:GetPropertyChangedSignal("Value"):Connect(function()
+	local Attributes = self.ElevatorConstructor.Attributes
-		if self.ElevatorConstructor.Attributes.CurrentFloor.Value == self.ElevatorConstructor.Attributes.Goal.Value then
+
-			local FloorButton = self.ButtonsConstructor:Get(Enums.ButtonTree.Car, self.ElevatorConstructor.Attributes.CurrentFloor.Value)
+	Attributes.CurrentFloor:GetPropertyChangedSignal("Value"):Connect(function()
+		if Attributes.CurrentFloor.Value == Attributes.Goal.Value then
+			local FloorButton = self.ButtonsConstructor:Get(Enums.ButtonTree.Car, Attributes.CurrentFloor.Value)
 			if FloorButton then
 				DeactivateButton(self, FloorButton)
 			end

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

@@ -2,6 +2,9 @@
 --!native
 --!strict
 
+local ButtonPromptsDistance = Vector3.new(-.05,0,0)
+local HallDoorOffset = Vector3.new(4.15,0,0)
+
 local ParentDir = script.Parent
 local ElevatorsDir = ParentDir.Parent
 local MainDir = ElevatorsDir.Parent
@@ -13,7 +16,9 @@ local Buttons       = require(script:WaitForChild("Buttons"))
 local Leveling      = require(script:WaitForChild("Leveling"))
 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
@@ -21,9 +26,14 @@ 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, Leveling)
 	local MovingObjectsConstructor = MovingObjects.constructor(TagsConstructor)
 	local ButtonsConstructor = Buttons.constructor(Config.Name, ButtonTags, Elevator.Attributes.CurrentFloor)
+	ButtonsConstructor:InitForElevator(2, ButtonPromptsDistance)
+
 	local TractionRopesConstructor = TractionRopes.constructor(CabRopesObject, PulleyRopesObject)
 	local EventsConstructor = Events.constructor(
 		Elevator,
@@ -34,7 +44,9 @@ return function(TagsConstructor: TagsModule.TagsConstructor, ButtonTags: TagsMod
 		MovingObjectsConstructor,
 		TractionRopesConstructor
 	)
-
 	EventsConstructor:InitButtons()
-	ButtonsConstructor:InitForElevator(2, Vector3.new(-.05,0,0))
+
+	local DoorsConstructor = Doors.constructor(ElevatorBoxModel, DoorEnums.Door.SingleSpeed, CabDoorsTree, DoorEnums.Door.SingleSpeed, LandingDoorTags)
+	task.wait(2)
+	DoorsConstructor:CloseFloorAsync(1, HallDoorOffset)
 end

src/server/main/Types/Enums/Doors.luau

@@ -4,10 +4,11 @@
 
 local DoorEnums = {}
 
-export type DoorEnumValues = typeof(DoorEnums.Door)
+export type DoorEnums = typeof(DoorEnums.Door)
 export type SingleSpeed = "SingleSpeed"
 export type DoubleSpeed = "DoubleSpeed"
 export type TripleSpeed = "TripleSpeed"
+export type DoorEnumValues = SingleSpeed | DoubleSpeed | TripleSpeed
 DoorEnums.Door = {
 	SingleSpeed = "SingleSpeed" :: SingleSpeed,
 	DoubleSpeed = "DoubleSpeed" :: DoubleSpeed,