mirror of
https://github.com/unixtensor/Roblox-Elevator-Game.git
synced 2025-12-14 06:41:55 +00:00
279 lines
11 KiB
Lua
279 lines
11 KiB
Lua
--!optimize 2
|
|
--!native
|
|
--!strict
|
|
|
|
local Elevators = script.Parent
|
|
local MainDir = Elevators.Parent
|
|
local LoadDir = MainDir:WaitForChild("Load")
|
|
|
|
local RunService = game:GetService("RunService")
|
|
|
|
local ElevatorTypes = require(MainDir:WaitForChild("Types"):WaitForChild("Elevator"))
|
|
local Tags = require(LoadDir:WaitForChild("Tags"))
|
|
local RelayAlgorithm = require(script:WaitForChild("RelayAlgorithm"))
|
|
|
|
type Tags = Tags.ExportedTags
|
|
type TagsConstructor = Tags.TagsConstructor
|
|
|
|
type ClassConstructor = typeof(setmetatable({} :: Constructor_Return_Props, {} :: Impl_Constructor))
|
|
type Impl_Constructor = {
|
|
__index: Impl_Constructor,
|
|
constructor: Constructor_Fun,
|
|
--Class functions
|
|
RequestLevel: (self: ClassConstructor, RequestedLevel: number) -> boolean,
|
|
__TravelToFloor: (self: ClassConstructor, LevelInt: number, LevelVec3: number, ElevatorGoingUp: boolean) -> (),
|
|
}
|
|
|
|
type FloorLevelingPositions = {number}
|
|
type Constructor_Fun = (ElevatorBoxModel: UnionOperation, ElevatorConfigurationTable: ElevatorTypes.ElevatorConfigurationTable, FloorLevelingPositions: FloorLevelingPositions) -> ClassConstructor
|
|
|
|
type Constructor_Return_Props = {
|
|
RelayAlgorithm: RelayAlgorithm.RelayAlgorithmConstructor,
|
|
FloorLevelingPositions: FloorLevelingPositions,
|
|
|
|
Elevator: {
|
|
BoxModel: UnionOperation,
|
|
AlignPosition: AlignPosition,
|
|
Configuration: ElevatorTypes.ElevatorConfigurationTable
|
|
},
|
|
Attributes: {
|
|
PreviousFloor: IntValue,
|
|
CurrentFloor: IntValue,
|
|
NextFloor: IntValue,
|
|
Goal: IntValue,
|
|
GoingUp: BoolValue,
|
|
Stopped: BoolValue
|
|
},
|
|
Events: {
|
|
CabProgression: RBXScriptSignal<number, number, number>,
|
|
CabTraveling: RBXScriptSignal<number, Vector3>,
|
|
Parked: RBXScriptSignal,
|
|
Leveling: RBXScriptSignal,
|
|
Leveling3Phase: RBXScriptSignal,
|
|
__eventInstances__: {
|
|
CabProgression: BindableEvent,
|
|
CabTraveling: BindableEvent,
|
|
Parked: BindableEvent,
|
|
Leveling: BindableEvent,
|
|
Leveling3Phase: BindableEvent,
|
|
}
|
|
},
|
|
|
|
__Connections: {
|
|
Moving: RBXScriptConnection?,
|
|
}
|
|
}
|
|
|
|
local Elevator = {} :: Impl_Constructor
|
|
Elevator.__index = Elevator
|
|
|
|
local function ElevatorGoingUpDirection(CurrentFloor: number, RequestedFloor: number): boolean
|
|
-- -(CurrentFloor-RequestedFloor)>0
|
|
-- -CurrentFloor+RequestedFloor>0
|
|
return CurrentFloor<RequestedFloor
|
|
end
|
|
|
|
local function Mover(ElevatorBoxModel: UnionOperation, Responsiveness: number, MaxVelocity: number): (Attachment, AlignPosition, AlignOrientation)
|
|
local BoxAttachment = Instance.new("Attachment")
|
|
BoxAttachment.Parent = ElevatorBoxModel
|
|
|
|
local BoxAlignPosition = Instance.new("AlignPosition")
|
|
BoxAlignPosition.Mode = Enum.PositionAlignmentMode.OneAttachment
|
|
BoxAlignPosition.Attachment0 = BoxAttachment
|
|
BoxAlignPosition.MaxForce = math.huge
|
|
BoxAlignPosition.Position = ElevatorBoxModel.Position
|
|
-- BoxAlignPosition.RigidityEnabled = true
|
|
-- Lines below are disabled with RigidityEnabled true
|
|
BoxAlignPosition.Responsiveness = Responsiveness
|
|
BoxAlignPosition.MaxVelocity = MaxVelocity
|
|
--
|
|
BoxAlignPosition.Parent = ElevatorBoxModel
|
|
|
|
local BoxAlignOrientation = Instance.new("AlignOrientation")
|
|
BoxAlignOrientation.Mode = Enum.OrientationAlignmentMode.OneAttachment
|
|
BoxAlignOrientation.Attachment0 = BoxAttachment
|
|
BoxAlignOrientation.RigidityEnabled = true
|
|
BoxAlignOrientation.CFrame = CFrame.new(0,0,0)*CFrame.fromOrientation(0,0,0)
|
|
BoxAlignOrientation.Parent = ElevatorBoxModel
|
|
|
|
return BoxAttachment, BoxAlignPosition, BoxAlignOrientation
|
|
end
|
|
|
|
function Elevator.constructor(ElevatorBoxModel, ElevatorConfigurationTable, FloorLevelingPositions)
|
|
assert(#FloorLevelingPositions>1, `[{ElevatorConfigurationTable.Name}] requires more floors to operate. Floors={FloorLevelingPositions}, #Floors={#FloorLevelingPositions}.`)
|
|
|
|
local _BoxAttachment,
|
|
BoxAlignPosition,
|
|
_BoxAlignOrientation = Mover(ElevatorBoxModel, ElevatorConfigurationTable.Responsiveness, ElevatorConfigurationTable.MaxVelocity)
|
|
|
|
local RelayAlgorithmConstructor = RelayAlgorithm.constructor(BoxAlignPosition)
|
|
|
|
local CabProgression = Instance.new("BindableEvent") :: BindableEvent
|
|
local CabTraveling = Instance.new("BindableEvent") :: BindableEvent
|
|
local Parked = Instance.new("BindableEvent") :: BindableEvent
|
|
local Leveling = Instance.new("BindableEvent") :: BindableEvent
|
|
local Leveling3Phase = Instance.new("BindableEvent") :: BindableEvent
|
|
|
|
local Attributes = {
|
|
PreviousFloor = Instance.new("IntValue") :: IntValue,
|
|
CurrentFloor = Instance.new("IntValue") :: IntValue,
|
|
NextFloor = Instance.new("IntValue") :: IntValue,
|
|
Goal = Instance.new("IntValue") :: IntValue,
|
|
GoingUp = Instance.new("BoolValue") :: BoolValue,
|
|
Stopped = Instance.new("BoolValue") :: BoolValue
|
|
}
|
|
Attributes.CurrentFloor.Value = 1
|
|
Attributes.PreviousFloor.Value = Attributes.CurrentFloor.Value
|
|
Attributes.NextFloor.Value = Attributes.CurrentFloor.Value+1
|
|
Attributes.GoingUp.Value = false
|
|
Attributes.Goal.Value = 1
|
|
|
|
print(`🛗 [{ElevatorConfigurationTable.Name}]: Initialized and ready`)
|
|
|
|
return setmetatable({
|
|
RelayAlgorithm = RelayAlgorithmConstructor,
|
|
FloorLevelingPositions = FloorLevelingPositions,
|
|
Elevator = {
|
|
BoxModel = ElevatorBoxModel,
|
|
AlignPosition = BoxAlignPosition,
|
|
Configuration = ElevatorConfigurationTable,
|
|
},
|
|
Events = {
|
|
CabProgression = CabProgression.Event,
|
|
CabTraveling = CabTraveling.Event,
|
|
Parked = Parked.Event,
|
|
Leveling = Leveling.Event,
|
|
Leveling3Phase = Leveling3Phase.Event,
|
|
__eventInstances__ = {
|
|
CabProgression = CabProgression,
|
|
CabTraveling = CabTraveling,
|
|
Parked = Parked,
|
|
Leveling = Leveling,
|
|
Leveling3Phase = Leveling3Phase,
|
|
}
|
|
},
|
|
Attributes = Attributes,
|
|
__Connections = {}
|
|
}, Elevator)
|
|
end
|
|
|
|
local function CheckFloorQueue(self: ClassConstructor)
|
|
if self.RelayAlgorithm.__FloorQueue[1] ~= self.Attributes.CurrentFloor.Value then
|
|
warn("The floor queue first index did not match the elevator's current floor, CurrentFloor=", self.Attributes.CurrentFloor.Value, "FloorQueue[1]=", self.RelayAlgorithm.__FloorQueue[1])
|
|
end
|
|
table.remove(self.RelayAlgorithm.__FloorQueue, 1)
|
|
|
|
local NextFloorInQueue = self.RelayAlgorithm.__FloorQueue[1]
|
|
print(NextFloorInQueue)
|
|
if NextFloorInQueue then
|
|
local ElevatorGoingUp = ElevatorGoingUpDirection(self.Attributes.CurrentFloor.Value, NextFloorInQueue)
|
|
local LevelVec3 = self.FloorLevelingPositions[NextFloorInQueue]
|
|
|
|
self:__TravelToFloor(NextFloorInQueue, LevelVec3, ElevatorGoingUp)
|
|
end
|
|
end
|
|
|
|
local function CabTraveling(self: ClassConstructor, deltaTime: number, LevelVec3: number, ElevatorGoingUp: boolean)
|
|
local ElevatorPosition = self.Elevator.BoxModel.Position
|
|
local AtFloorY = self.FloorLevelingPositions[ElevatorGoingUp and self.Attributes.CurrentFloor.Value+1 or self.Attributes.CurrentFloor.Value-1]
|
|
|
|
if ElevatorGoingUp then
|
|
--Detecting between the floors
|
|
if ElevatorPosition.Y>=AtFloorY-self.Elevator.Configuration.FloorLevelingDistance then
|
|
self.Attributes.PreviousFloor.Value = self.Attributes.CurrentFloor.Value
|
|
self.Attributes.CurrentFloor.Value+=1
|
|
self.Attributes.NextFloor.Value = math.clamp(1, self.Attributes.CurrentFloor.Value+1, #self.FloorLevelingPositions)
|
|
|
|
self.Events.__eventInstances__.CabProgression:Fire(self.Attributes.PreviousFloor.Value, self.Attributes.CurrentFloor.Value, self.Attributes.NextFloor.Value)
|
|
end
|
|
|
|
--Elevator is riding upwards towards the destination
|
|
if ElevatorPosition.Y>=LevelVec3-self.Elevator.Configuration.FloorLevelingDistance then
|
|
self.Events.__eventInstances__.Leveling:Fire()
|
|
self.Elevator.AlignPosition.MaxVelocity = self.Elevator.Configuration.LevelingVelocity
|
|
|
|
if ElevatorPosition.Y>=LevelVec3-self.Elevator.Configuration.FloorLeveling3PhaseDistance then
|
|
self.Events.__eventInstances__.Leveling3Phase:Fire()
|
|
self.Elevator.AlignPosition.MaxVelocity = self.Elevator.Configuration.Phase3LevelingVelocity
|
|
|
|
if ElevatorPosition.Y>=LevelVec3-self.Elevator.Configuration.ParkedDistance then
|
|
self.Events.__eventInstances__.Parked:Fire()
|
|
CheckFloorQueue(self);
|
|
|
|
(self.__Connections.Moving :: RBXScriptConnection):Disconnect()
|
|
end
|
|
end
|
|
end
|
|
else
|
|
if ElevatorPosition.Y<=AtFloorY+self.Elevator.Configuration.FloorLevelingDistance then
|
|
self.Attributes.PreviousFloor.Value = self.Attributes.CurrentFloor.Value
|
|
self.Attributes.CurrentFloor.Value-=1
|
|
self.Attributes.NextFloor.Value = math.clamp(1, self.Attributes.CurrentFloor.Value-1, #self.FloorLevelingPositions)
|
|
|
|
self.Events.__eventInstances__.CabProgression:Fire(self.Attributes.PreviousFloor.Value, self.Attributes.CurrentFloor.Value, self.Attributes.NextFloor.Value)
|
|
end
|
|
|
|
--Elevator is riding upwards towards the destination
|
|
if ElevatorPosition.Y<=LevelVec3+self.Elevator.Configuration.FloorLevelingDistance then
|
|
self.Events.__eventInstances__.Leveling:Fire()
|
|
self.Elevator.AlignPosition.MaxVelocity = self.Elevator.Configuration.LevelingVelocity
|
|
|
|
if ElevatorPosition.Y<=LevelVec3+self.Elevator.Configuration.FloorLeveling3PhaseDistance then
|
|
self.Events.__eventInstances__.Leveling3Phase:Fire()
|
|
self.Elevator.AlignPosition.MaxVelocity = self.Elevator.Configuration.Phase3LevelingVelocity
|
|
|
|
if ElevatorPosition.Y<=LevelVec3+self.Elevator.Configuration.ParkedDistance then
|
|
self.Events.__eventInstances__.Parked:Fire()
|
|
CheckFloorQueue(self);
|
|
|
|
(self.__Connections.Moving :: RBXScriptConnection):Disconnect()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
self.Events.__eventInstances__.CabTraveling:Fire(deltaTime, ElevatorPosition)
|
|
end
|
|
|
|
function Elevator:__TravelToFloor(LevelInt, LevelVec3, ElevatorGoingUp)
|
|
if self.__Connections.Moving and self.__Connections.Moving.Connected then
|
|
self.__Connections.Moving:Disconnect()
|
|
end
|
|
|
|
self.Attributes.Goal.Value = LevelInt
|
|
self.Attributes.GoingUp.Value = ElevatorGoingUp
|
|
|
|
self.__Connections.Moving = RunService.Heartbeat:Connect(function(deltaTime)
|
|
CabTraveling(self, deltaTime, LevelVec3, ElevatorGoingUp)
|
|
end)
|
|
|
|
--Set the elevator's AlignPosition to the floor Y vector
|
|
self.Elevator.AlignPosition.Position = Vector3.new(self.Elevator.AlignPosition.Position.X, LevelVec3, self.Elevator.AlignPosition.Position.Z)
|
|
--Set the elevator's max velocity to its fastest speed when moving starts
|
|
self.Elevator.AlignPosition.MaxVelocity = self.Elevator.Configuration.MaxVelocity
|
|
end
|
|
|
|
function Elevator:RequestLevel(RequestedLevel)
|
|
local LevelVec3 = self.FloorLevelingPositions[RequestedLevel]
|
|
|
|
if LevelVec3 then
|
|
if RequestedLevel ~= self.Attributes.CurrentFloor.Value then
|
|
local ElevatorGoingUp = ElevatorGoingUpDirection(self.Attributes.CurrentFloor.Value, RequestedLevel)
|
|
self.RelayAlgorithm:AddFloor(ElevatorGoingUp, self.Attributes.GoingUp, RequestedLevel)
|
|
|
|
if #self.RelayAlgorithm.__FloorQueue == 1 then
|
|
self:__TravelToFloor(RequestedLevel, LevelVec3, ElevatorGoingUp)
|
|
end
|
|
else
|
|
warn(`[{self.Elevator.Configuration.Name}]: The elevator is already at the requested floor. RequestLevel={RequestedLevel}, CurrentLevel={self.Attributes.CurrentFloor.Value}`)
|
|
return false
|
|
end
|
|
return true
|
|
end
|
|
|
|
warn(`[{self.Elevator.Configuration.Name}]: Requested floor: "{RequestedLevel}" does not exist for this elevator`)
|
|
return false
|
|
end
|
|
|
|
return Elevator
|