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())