def test_matches_pickup_request():
elevator_id = 0
current_floor = 4
el = Elevator(elevator_id, current_floor)
# target_floor is None
directionUp = 1
directionDown = -1
floor = 2
assert el.matches_request(floor, directionUp)
floor = 5
assert el.matches_request(floor, directionDown)
el.set_target_floor(10)
floor = 4
assert not el.matches_request(floor, directionUp)
floor = 8
assert el.matches_request(floor, directionUp)
floor = 2
assert not el.matches_request(floor, directionUp)
floor = 5
assert not el.matches_request(floor, directionDown)
floor = 9
assert not el.matches_request(floor, directionDown)
print("test_matches_pickup_request OK")
class RunElevator:
def __init__(self):
self.elevator = Elevator()
self.left_floor = self.elevator.get_random_left_elevator_floor()
self.right_floor = self.elevator.get_random_right_elevator_floor()
self.call_floor = self.elevator.get_random_elevator_call()
def run_elevator(self):
if (self.right_floor - self.call_floor) * (-1) < (
self.left_floor - self.call_floor) * (-1):
print(
f"You're on {self.call_floor} floor, please wait for the right elevator that will come from floor"
f" {self.right_floor} that is as far from the left elevator that is on {self.left_floor}"
)
elif (self.right_floor - self.call_floor) * (-1) == (
self.left_floor - self.call_floor) * (-1):
print(
f"You're on {self.call_floor} floor, please wait for the right elevator that will come from floor"
f" {self.right_floor} that is as far from the left elevator that is on {self.left_floor} floor."
)
else:
print(
f"You're on {self.call_floor} floor, please wait for the left elevator on floor {self.left_floor}"
f" that is as far from the left elevator that is on {self.right_floor} floor"
)
class ElevatorGuy:
'''
The ElevatorGuy creates and starts the elevatorself.
Customers tell the ElevatorGuy which floor they go to.
'''
def __init__(self):
self.num_customers = self.get_user_int("How many customers? ",1,24)
self.num_floors = self.get_user_int("How many floors? ", 1, 100)
self.customers = self.gather_customers()
print("Gathered ", self.num_customers, "customers for", self.num_floors,"floors.")
self.elevator = Elevator(self.num_floors, DefaultStrategy)
for c in self.customers:
self.elevator.add_customer(c)
print("Customers in elevator:")
for c in self.elevator.customers:
print(str(c))
self.elevator.start()
def get_user_int(self, message, minimum, maximum):
mn = minimum
mx = maximum
msg = message
while True:
try:
user_int = int(input(msg))
if(user_int < mn or user_int > mx ):
print("Please provide a number between",mn,"and",mx)
continue
except ValueError:
print("Please provide a number between",mn,"and",mx)
continue
else:
break
return user_int
def gather_customers(self):
customers = []
for i in range(0, self.num_customers):
start = random.randint(1, self.num_floors)
end = start
while end == start:
end = random.randint(1, self.num_floors)
c = Customer(start,end)
customers.append(c)
return customers
def test_directionality1(self):
e = Elevator(ElevatorLogic())
e.call(2, DOWN)
e.select_floor(5)
e.run_until_stopped()
self.assertEqual(e._current_floor, 5)
e.run_until_stopped()
self.assertEqual(e._current_floor, 2)
def __init__(self, N, K, p, q, r, t_u):
self.N = N # number of floors
self.K = K # number of elevators
self.p = p # probability person arrives at a given time step
self.q = q # probability person arrives at first floor
self.r = r # probability person wants to get down at first floor
self.t_u = t_u # one time unit
self.elev = Elevator(N, K)
self.total_cost = 0
self.total_people_served = 0
self.people_in_sys = []
def test_changing_direction2(self):
'''
If nobody wants to go further up though, the elevator can turn around.
'''
e = Elevator(ElevatorLogic())
e.call(2, DOWN)
e.call(4, UP)
e.run_until_stopped()
self.assertEqual(e._current_floor, 4)
e.run_until_stopped()
self.assertEqual(e._current_floor, 2)
def __init__(self, numberOfPeople, numOfFloors, numOfElevators):
self.numberOfPeople = numberOfPeople
self.numberOfFloors = numOfFloors
self.floors = {}
self.elevators = []
i = 0
peopleInFloor = int(numberOfPeople / numOfFloors)
"""need to fix"""
# peopleInFloor = int(numberOfPeople / numOfFloors)
# if peopleInFloor < 1:
# while floorNum < numOfFloors + 1:
# randPerson = random.randint(0, 1)
# if i < numberOfPeople:
# if randPerson == 1:
# self.floors[floorNum] = Floor(floorNum, randPerson, numOfFloors)
# floorNum = floorNum + 1
# i = i + 1
# else:
# self.floors[floorNum] = Floor(floorNum, randPerson, numOfFloors)
# floorNum = floorNum + 1
for floorNum in range(1, numOfFloors + 1):
self.floors[floorNum] = Floor(floorNum, peopleInFloor, numOfFloors)
for i in range(0, numOfElevators):
self.elevators.append(Elevator(i, numOfFloors))
def __init__(self, id, num_floors):
self.id = id
self.order_timeout_secs = 60
self.ips = {self.id: self.own_ip()}
self.elevators = {id: Elevator()}
self.hub_down = dict() # KEY: floor, id VALUE: boolean
self.hub_up = dict()
self.cab = dict() # KEY: floor, id VALUE: boolean
self.cab[0] = False
self.hub_up[0] = False
self.cab[num_floors - 1] = False
self.hub_down[num_floors - 1] = False
for floor in range(1, num_floors - 1):
self.cab[floor] = False
self.hub_up[floor] = False
self.hub_down[floor] = False
self._sockets_init()
launch_thr(self.receive_hub_order)
launch_thr(self.receive_state)
time.sleep(0.5)
launch_thr(self.send_state)
def __init__(self, elevators=8, verbose=False):
self._elevators = []
self._verbose = verbose
for i in range(1, elevators + 1):
self._elevators.append(Elevator(i, verbose=self._verbose))
def __init__(self,MaxCustomer,Speed,BoardTime):
''' 初始化
@type MaxCustomer: int
@param MaxCustomer: 每部电梯最大顾客数
@type Speed: int
@param Speed: 电梯运行速度 Speed秒/层
@type BoardTime: int
@param BoardTime: 顾客上下电梯耗时
'''
self.AllElevator = []
# 电梯基本信息
AvaliableFloorTable = {
'E0' : range(1,41),
'E1' : range(1,41),
'E2' : [1] + range(25,41),
'E3' : [1] + range(25,41),
'E4' : range(1,26),
'E5' : range(1,26),
'E6' : [1] + range(2,41,2),
'E7' : [1] + range(2,41,2),
'E8' : range(1,41,2),
'E9' : range(1,41,2)
}
ElevatorNum = len(AvaliableFloorTable)
# 产生电梯
for tag,floor in AvaliableFloorTable.items():
newElevator = Elevator(tag,floor,MaxCustomer,random.choice(floor),Speed,BoardTime)
self.AllElevator.append(newElevator)
#print newElevator
self.AllElevator.sort(cmp = lambda x,y: cmp(x.Tag, y.Tag))
def __init__(self, name, FLOOR_COUNT, elevator_count):
self.name = name
self.FLOOR_COUNT = FLOOR_COUNT
self.elevator_count = elevator_count
self.elevators = []
self.calls_for_elevator = []
for i in range(0, self.elevator_count):
self.elevators.append(Elevator(self, i, 1))
def reset_elevator():
global elevator
p = elevator.p
elevator = Elevator(scheduler=schedule_list[schedule_var.get()](),
floors=floors,
p=p,
capacity=2,
initial_count=0,
pressing_up=pressing_list[pressing_var.get()])
def __init__(self, communicator, dispatcher=False):
self.communicator = communicator
self.orderList = [[0 for x in range(NO_FLOORS)] for x in range(2)] # direction is one dimension, no. floors the other
self.peerList = {} # store peer objects, with IP as key
self.dispatcher = dispatcher
self.id = self.getMyIP()
self.status = ""
self.elevator = Elevator() # this object should handle the interface with the driver and keep track of elevator state
def __init__(self):
self.num_customers = self.get_user_int("How many customers? ",1,24)
self.num_floors = self.get_user_int("How many floors? ", 1, 100)
self.customers = self.gather_customers()
print("Gathered ", self.num_customers, "customers for", self.num_floors,"floors.")
self.elevator = Elevator(self.num_floors, DefaultStrategy)
for c in self.customers:
self.elevator.add_customer(c)
print("Customers in elevator:")
for c in self.elevator.customers:
print(str(c))
self.elevator.start()
def __init__(self, elevators_count):
if elevators_count <= 0:
raise Exception("elevators count must be greater than 0")
self.elevators_count = elevators_count
self.elevators = {} # dictionary of elevators and their state
# populate elevators
for i in range(self.elevators_count):
self.elevators[i] = Elevator(i)
# keep instance of factory for building requests
self._request_factory = GoToFloorRequestFactory()
def _generateGiantSpike(self):
self.giantSpike = giantSpike()
self.giantSpikeList = pygame.sprite.Group()
self.giantSpikeList.add(self.giantSpike)
self.giantSpikePlat = Elevator('elevator')
self.giantSpikePlat.speed = 0
self.giantSpikePlat.rect.x, self.giantSpikePlat.rect.y = self.giantSpike.rect.x + 10, self.giantSpike.rect.y - 5
self.giantSpike.plat = self.giantSpikePlat
self.elevatorList.add(self.giantSpikePlat)
self.chainGroup = pygame.sprite.Group()
self.chainGroup.add(self.giantSpike.chain)
def __init__(self, number_of_elevator, number_of_floor):
self.elevators = [
Elevator(i, number_of_floor) for i in range(number_of_elevator)
]
self.floors = number_of_floor
# people start from certain floor that have a elevator come for them
self.people_from_floors = [[Queue(), Queue()]
for i in range(number_of_floor + 1)]
# people cannot get elevators come to them
self.waitlist = Queue()
def testShouldGoBackDown(self):
elevator = Elevator()
elevator.currentFloor = 4
elevator.doorsOpen = True
elevator.closeDoors()
self.assertEqual(elevator.nextFloor, 0)
self.assertEqual(elevator.direction, -1)
def testPickupInRightOrder(self):
elevator = Elevator(speed=0.5)
elevator.handleRequest(floor=8)
elevator.handleRequest(floor=4)
time.sleep(1)
elevator.handleRequest(floor=1)
self.assertEqual(elevator.direction, 1)
self.assertEqual(elevator.nextFloor, 4)
def __init__(self, num_floors, num_elevators):
self.floors = num_floors
self.num_elevators = num_elevators
self.elevators = []
self.pending_targets = {}
self.new_floor_calls = []
self.new_elevator_calls = []
for i in range(num_elevators):
self.elevators.append(Elevator(i, self.floors))
self.pending_targets[i] = []
self.control_loop = threading.Thread(target=self.state_loop,
args=(True, ))
self.control_loop.start()
self.input_loop()
def __init__(self, communicator, dispatcher=False):
self.communicator = communicator
self.orderList = [[0 for x in range(NO_FLOORS)] for x in range(2)] # direction is one dimension, no. floors the other
self.peerList = {} # store peer objects, with IP as key
self.dispatcher = dispatcher
self.id = self.getMyIP()
self.status = ""
self.peers = []
# ugly hack to give the messageHandler the controller instance.
self.communicator.messageHandler.setController(self)
# this object should handle the interface with the driver and keep track of elevator state
self.elevator = Elevator(self)
def main(): # #Genereate test cases, uncomment the next line to generate input files with random requests # generate_pseudo_input(building_floors, customer_total_number, end_time, input_file_path) # Read the input file and get all the customer data all_data = get_pseudo_input(input_file_path) # Initialize the elevator my_elevator = Elevator(starting_floor, max_capacity,max_speed,actions_log_file_path) # Initialize the simulator my_simulator = Simulator(building_floors,my_elevator) # Operate the simulator my_simulator.operate(all_data, requests_log_file_path)
def __init__(self, total_elevator_num, height, max_people):
self.target = 0
self.total_elevator_num = total_elevator_num
self.max_people_in_floor = max_people
#each elevator has max capacity of 10
self.elevators = []
for idx in range(total_elevator_num):
self.elevators.append(Elevator(idx, 10, height))
self.height = height
self.people_in_floors = []
self.floor_button = []
for idx in range(height):
self.people_in_floors.append([])
self.floor_button.append(Switch())
def main():
currentIndex = 0
time_tick = 0
cumulative_time = 0
#reads from jsonfile
with open('testcases/elevator_practice1.json') as json_data:
jsonFile = json.load(json_data)
#intializing floor and elevators
numFloors = jsonFile["floors"]
numElevators = jsonFile["elevators"]
floorList = []
elevatorList = []
drawGui = DrawElevator(numFloors, numElevators)
drawGui.initialDraw()
for i in range(numFloors):
floorList.append(Floor(i))
for i in range(numElevators):
elevatorList.append(Elevator(5, numFloors))
while time_tick < 1000:
#stores the data locally from the json object
if time_tick == jsonFile["events"][currentIndex]["time"]:
startFloor = jsonFile["events"][currentIndex]["start"]
endFloor = jsonFile["events"][currentIndex]["end"]
#populates the floor class
new_person = Person(time_tick, startFloor, endFloor)
floorList[startFloor].appendPerson(new_person)
currentIndex += 1
#updates the elevator class
for elevator in elevatorList:
floorList = elevator.update(floorList)
drawGui.update(elevatorList, floorList)
time_tick += 1
time.sleep(0.1)
def __init__(self, total_floors):
self.elevator_obj = Elevator()
self.max_floor_number = total_floors
def reset_elevator():
global elevator
p = elevator.p
elevator = Elevator(scheduler=schedule_list[schedule_var.get()](),
floors=floors,
p=p,
capacity=2,
initial_count=0,
pressing_up=pressing_list[pressing_var.get()])
if __name__ == '__main__':
elevator = Elevator(scheduler=MinMaxScheduler(),
floors=floors,
p=1 / 20,
capacity=2,
initial_count=0)
master = Tk()
master.resizable = False
master.title("Elevator")
master.bind("<Configure>", window_event)
master.protocol("WM_DELETE_WINDOW", window_event2)
canvas = Canvas(master, width=canvas_width, height=canvas_height)
canvas.pack(expand=YES, fill=BOTH)
schedule_var = StringVar(master)
pressing_var = StringVar(master)
button0 = Button(master, text="Reset", fg='black', command=reset_elevator)
def test_basic_usage(self):
e = Elevator(ElevatorLogic())
self.assertEqual(e._current_floor, 1)
e.call(5, DOWN)
e.run_until_stopped()
self.assertEqual(e._current_floor, 5)
e.select_floor(1)
e.call(3, DOWN)
e.run_until_stopped()
self.assertEqual(e._current_floor, 3)
e.run_until_stopped()
self.assertEqual(e._current_floor, 1)
def test_directionality2(self):
e = Elevator(ElevatorLogic())
e.select_floor(3)
e.select_floor(5)
e.run_until_stopped()
self.assertEqual(e._current_floor, 3)
e.select_floor(2) # ignored
e.run_until_stopped()
self.assertEqual(e._current_floor, 5)
e.run_until_stopped() # nothing happens, because e.select_floor(2) was ignored
self.assertEqual(e._current_floor, 5)
e.select_floor(2)
e.run_until_stopped()
self.assertEqual(e._current_floor, 2)
# 当 self.Status == 'InElevator'时才能调用
# 确认到达请求楼层
assert self.Status == 'InElevator'
# 因为存在电梯时间先加1，人时间后加1的问题，所以这里人的楼层不可能等于电梯的楼层。
self.NowFloor = elevator.NowFloor
self.Status = 'Landing'
# 此时的时间控制和Elevator相同
self.TimeRemain = elevator.BoardTime
self.Elevator = elevator
#print '%s LandingNotify %s' % (self,elevator)
def GetNowStatus(self):
''' 获得当前顾客状态
@rtype: tuple
@return: 当前状态,(ID,Status,NowFloor,DestFloor,LaunchNum,InRequestTime)
'''
return (self.ID, self.Status, self.NowFloor, self.DestFloor,
self.LaunchNum, self.InRequestTime)
if __name__ == '__main__':
from Elevator import Elevator
eve = Elevator('E0', range(1, 41), 10, InitFloor=1, Speed=2, BoardTime=2)
cust = Customer(1, 5)
cust.AddTimer(1)
cust.AddTimer(2)
cust.AddTimer(3)
def test_changing_direction3(self):
'''
If the elevator is called in both directions at that floor, it must
wait once for each direction. You may have seen this too. Some
elevators will close their doors and reopen them to indicate that
they have changed direction.
'''
e = Elevator(ElevatorLogic())
e.select_floor(5)
e.call(5, UP)
e.call(5, DOWN)
e.run_until_stopped()
self.assertEqual(e._current_floor, 5)
# Here, the elevator considers itself to be going up, as it favors
# continuing in the direction it came from.
e.select_floor(4) # ignored
e.run_until_stopped()
self.assertEqual(e._current_floor, 5)
# Since nothing caused the elevator to move further up, it now waits
# for requests that cause it to move down.
e.select_floor(6) # ignored
e.run_until_stopped()
self.assertEqual(e._current_floor, 5)
# Since nothing caused the elevator to move down, the elevator now
# considers itself idle. It can move in either direction.
e.select_floor(6)
e.run_until_stopped()
self.assertEqual(e._current_floor, 6)
def test_changing_direction1(self):
'''
The process of switching directions is a bit tricky. Normally, if an
elevator going up stops at a floor and there are no more requests at
higher floors, the elevator is free to switch directions right away.
However, if the elevator was called to that floor by a user indicating
that she wants to go up, the elevator is bound to consider itself
going up.
'''
e = Elevator(ElevatorLogic())
e.call(2, DOWN)
e.call(4, UP)
e.run_until_stopped()
self.assertEqual(e._current_floor, 4)
e.select_floor(5)
e.run_until_stopped()
self.assertEqual(e._current_floor, 5)
e.run_until_stopped()
self.assertEqual(e._current_floor, 2)
def test_elevator_movement():
elevator_id = 0
current_floor = 0
el = Elevator(elevator_id, current_floor)
assert el.get_current_floor() == 0
el.set_target_floor(5)
assert el.get_target_floor() == 5
assert el.get_direction() == 1
el.step()
assert el.get_current_floor() == 1
el.step()
el.step()
assert el.get_current_floor() == 3
el.step()
el.step()
assert el.get_current_floor() == 5
print("test_elevator_movement OK")
def __init__(self,
manager=ElevatorManager.NaiveManager,
debug_mode=False,
verbose=True,
sim_len=120,
sim_pace=None,
time_resolution=0.5,
logfile=None,
seed=1,
n_floors=3,
n_elevators=2,
capacity=4,
speed=1,
open_time=2,
arrival_pace=1 / 10,
p_between=0.1,
p_up=0.45,
size=1.5,
delay=3):
# Note: default time unit is seconds.
self.debug = debug_mode
self.verbose = verbose
## Simulation world
# conf
self.sim_len = sim_len
sim_pace = sim_pace # visualization's fast-forward; None for no visualization
self.time_resolution = np.inf if sim_pace is None else time_resolution
self.logfile = logfile
self.seed = seed
# init
self.sim_time = 0
self.real_time = None
self.logger = None
# stats init
self.useless_opens = 0
self.blocked_entrances = 0
self.moves_without_open = 0
## Elevators
# conf
self.n_floors = n_floors
self.n_elevators = n_elevators
el_capacity = capacity
el_speed = speed # floors per second. Note: acceleration is neglected
el_open_time = open_time # = time to open = time to close
# init
self.el_next_event_time = [np.inf for _ in range(self.n_elevators)]
self.el = [
Elevator(i, self.n_floors, el_capacity, el_speed, el_open_time)
for i in range(self.n_elevators)
]
self.sim_plot = SimPlotter(self.n_floors, self.n_elevators, sim_pace) \
if sim_pace is not None else None
## Passengers
# conf
self.arrivals_pace = arrival_pace # arrivals per second
self.p_go_between = p_between
self.p_go_up = p_up
self.p_go_down = 1 - (self.p_go_between + self.p_go_up)
self.arrival_size = size # mean number of passengers per arrival
self.delay = delay # mean delay on passengers entrance
# init
self.scenario = []
self.future_arrivals = []
self.waiting_passengers = []
self.moving_passengers = [[] for _ in range(self.n_elevators)]
self.completed_passengers = []
## Manager
self.manager_info = manager.version_info()
self.manager = manager(self.n_floors, self.el, el_capacity, el_speed,
el_open_time, self.arrivals_pace, self.p_go_up,
self.p_go_down, self.p_go_between,
self.arrival_size, self.delay)
def addElevator(self):
self.__elevatorList.append(Elevator())
class Environment(object):
"""
- plays out the simulation as specified in the problem statement for one time unit
- method to simulate an action on existing state
- method to print current state (not equivalent to state representation of elevator in Elevator.py)
"""
# CONSTANTS
WAIT_TIME_COST_FACTOR = 2
UP_DOWN_COST_FACTOR = 1
def __init__(self, N, K, p, q, r, t_u):
self.N = N # number of floors
self.K = K # number of elevators
self.p = p # probability person arrives at a given time step
self.q = q # probability person arrives at first floor
self.r = r # probability person wants to get down at first floor
self.t_u = t_u # one time unit
self.elev = Elevator(N, K)
self.total_cost = 0
self.total_people_served = 0
self.people_in_sys = []
def apply_action(self, action):
"""
- action is a K length list with actions of the form 'AU', 'AD', 'AOU', 'AOD', 'AS' for each elevator
- executes the action and simulates the next state
- returns the new buttons pressed after simulation
- updates the cost
"""
# reset lights, will set depending on action
self.elev.reset_lights()
# update costs
# cost for people carried over from last time step
self.total_cost += Environment.WAIT_TIME_COST_FACTOR * \
len(self.people_in_sys)
self.total_cost += Environment.UP_DOWN_COST_FACTOR * \
len([x for x in action if x == 'AU' or x == 'AD']
) # cost for all lifts moved
new_buttons_pressed = ''
# move lifts
for k in range(self.K):
if action[k] == 'AU':
self.elev.modify_pos(k, 1)
if action[k] == 'AD':
self.elev.modify_pos(k, -1)
if not 0 <= self.elev.pos[k] < self.N:
return 'INVALID ACTION'
# embarkation, disembarkation
for k in range(self.K):
# remove people with this dest, unpress floor and lift buttons
if action[k] == 'AOU' or action[k] == 'AOD':
self.people_in_sys = [
x for x in self.people_in_sys
if not (x.elev_num == k and x.dest == self.elev.pos[k])
]
self.elev.modify_elevator_button(k, self.elev.pos[k], 0)
self.elev.modify_floor_button(self.elev.pos[k], action[k][-1],
0)
# add people to the elevator who want to go in the direction of lift, press their buttons
for i in range(len(self.people_in_sys)):
if (self.people_in_sys[i].elev_num == -1
and self.people_in_sys[i].start == self.elev.pos[k]
and self.people_in_sys[i].direction
== action[k][-1]):
self.people_in_sys[i].elev_num = k
unpressed = self.elev.modify_elevator_button(
k, self.people_in_sys[i].dest, 1)
if unpressed: # may have been pressed by someone already in list, or multiple times by people entering => add once
new_buttons_pressed += 'B_' + \
str(self.people_in_sys[i].dest +
1) + '_' + str(k+1) + ' '
# set lights
if action[k] == 'AOU':
self.elev.modify_lights(k, 'U', 1)
if action[k] == 'AOD':
self.elev.modify_lights(k, 'D', 1)
floor_button_pressed = False
# person arrival
if random.random() < self.p: # person arrives
self.total_people_served += 1
new_person = Person(self.total_people_served, self.N, self.q,
self.r)
unpressed = self.elev.modify_floor_button(new_person.start,
new_person.direction, 1)
if unpressed:
new_buttons_pressed = 'B' + new_person.direction + '_' + \
str(new_person.start+1) + ' ' + new_buttons_pressed
floor_button_pressed = True
self.people_in_sys.append(new_person)
if not floor_button_pressed:
new_buttons_pressed = '0 ' + new_buttons_pressed
return new_buttons_pressed
def __str__(self):
"""
- returns a (hopefully kinda sorta pretty) text based representation of the current environment
- notice that while this representation prints the number of people at each floor, it is not informed
as part of the elevator state to the agent
- e.g. if the BU3 has been pressed and another person comes in at the third floor to go up, BU3 will
not be sent again to the agent
"""
left_margin = 25
lift_width = 5
state = ''
state += '-' * (left_margin + (lift_width + 1) * self.N + 24) + '\n'
state += 'FLOOR' + ' ' * (left_margin - 5) + ' ' * (lift_width / 2 + 1)
for i in range(self.N):
# complex rule for accounting for different string lengths for more than 100 floors
state += str(i + 1) + ' ' * (lift_width - len(str(i + 1)) -
(len(str(i + 2)) - len(str(i + 1))) *
((len(str(i + 2)) - 1) / 2) + 1)
state += '\n'
# people waiting
waiting_up = [0] * self.N
waiting_down = [0] * self.N
people_in_lift = [0] * self.K
for person in self.people_in_sys:
if person.elev_num == -1:
if person.direction == 'U':
waiting_up[person.start] += 1
else:
waiting_down[person.start] += 1
else:
people_in_lift[person.elev_num] += 1
state += 'PEOPLE WAITING UP/DOWN' + ' ' * \
(left_margin-22) + ' '*(lift_width/2)
for u, d in zip(waiting_up, waiting_down):
state += str(u) + '/' + str(d) + ' ' * \
(lift_width-len(str(u)+str(d)))
state += '\n'
# up and down buttons
state += 'FLOOR UP BUTTON' + ' ' * (left_margin + lift_width / 2 - 15)
for i in range(self.N):
if self.elev.BU[i]:
state += '-->'
else:
state += ' ' * 3
state += ' ' * (lift_width - 2)
state += '\n'
state += 'FLOOR DOWN BUTTON' + ' ' * \
(left_margin + lift_width / 2 - 17)
for i in range(self.N):
if self.elev.BD[i]:
state += '<--'
else:
state += ' ' * 3
state += ' ' * (lift_width - 2)
state += '\n'
# lifts
for i in range(self.K):
state += ' ' * (left_margin + 1)
for j in range(self.N):
if self.elev.pos[i] == j and self.elev.LU[i]:
state += ' ' * (lift_width / 2 - 1) + \
'-->' + ' ' * (lift_width / 2)
elif self.elev.pos[i] == j and self.elev.LD[i]:
state += ' ' * (lift_width / 2 - 1) + \
'<--' + ' ' * (lift_width / 2)
else:
state += ' ' * (lift_width + 1)
state += '\n'
state += ' ' * left_margin + '-'
for j in range(self.N):
if self.elev.pos[i] == j and (self.elev.LU[i]
or self.elev.LD[i]):
state += '-' * (lift_width / 2 -
1) + ' ' * 3 + '-' * (lift_width / 2)
else:
state += '-' * (lift_width + 1)
state += '\n'
state += 'ELEVATOR ' + str(i+1) + ' ' * \
(left_margin - 9 - len(str(i+1)))
for j in range(self.N):
if self.elev.pos[i] == j:
state += '|' + ' '*(lift_width/2) + \
'.' + ' '*(lift_width/2)
else:
state += '|' + ' ' * lift_width
state += '|' + ' '*5 + 'PEOPLE IN LIFT : ' + \
str(people_in_lift[i]) + '\n'
state += ' ' * left_margin + '-' * \
((lift_width + 1) * self.N + 1) + '\n'
state += 'BUTTONS PRESSED' + ' ' * \
(left_margin-15 + lift_width/2 + 1)
for j in range(self.N):
if self.elev.BF[i][j]:
state += 'o' + ' ' * lift_width
else:
state += ' ' * (lift_width + 1)
state += '\n'
state += '\n'
state += 'TOTAL PEOPLE IN SYSTEM : ' + \
str(len(self.people_in_sys)) + '\n'
state += 'TOTAL CUMULATIVE COST : ' + str(self.total_cost) + '\n'
state += '-' * (left_margin + (lift_width + 1) * self.N + 24)
return state
import time
from Elevator import Elevator
el = Elevator.Elevator(1)
el.start()
print(el.distance_request("U", 3))
el.push_button_floor(3)
el.push_button_floor(4)
el.push_button_floor(6)
el.assing_request("D", 10)
time.sleep(3)
el.assing_request("D", 2)
def __init__(self, allpassengers):
if allpassengers is None:
raise Exception("Passengers cannot be None")
self.elevator = Elevator(self)
self.allPassengers = allpassengers
from Person import Person from Elevator import Elevator e = Elevator(6) p = Person(1, 4) p1 = Person(3, 5) e.add_people_to_floor(4, 1) e.floor_change_up() e.floor_change_up() e.remove_people_from_ele(2) e.floor_change_down() e.floor_change_down() print(e.get_ele_list()) print(e.get_total_time())
