def test_properties(self):
floors = [Floor(1, 7), Floor(2, 7)]
elevators = [Elevator(id=1, size=10)]
c = Controller(floors, elevators)
self.assertTrue(type(c.signal_change_velocity) is Signal)
self.assertTrue(type(c.signal_stop) is Signal)
def generation_room(x_initial, y_initial, room):
x = x_initial
y = y_initial
for i in range(len(room)):
for j in range(len(room[0])):
if room[i][j] == "f":
pf = Floor(x, y, random.randint(0,5))
layer_0.add(pf)
if room[i][j] == "w":
pf = Wall(x, y, 4)
layer_1.add(pf)
if room[i][j] == "d":
pf = Wall(x, y, 1)
layer_2.add(pf)
if room[i][j] == "v":
pf = Wall(x, y, 2)
layer_2.add(pf)
if room[i][j] == "x":
pf = Wall(x, y, 0)
layer_0.add(pf)
wall.append(pf)
if room[i][j] == "u":
pf = Wall(x, y, 3)
layer_1.add(pf)
r = random.randint(0, 100)
if r <= 5:
torch = Torch(x, y, 3)
layer_1.add(torch)
if room[i][j] == "c":
r = random.randint(3, 10)
if r >= 5:
pf = Floor(x, y, 6)
layer_0.add(pf)
pf = Chest(x, y-6, random.randint(1, 2))
layer_1.add(pf)
chest.append(pf)
else:
pf = Floor(x, y, 6)
layer_0.add(pf)
if room[i][j] == "z":
pf = Monster_spawn(x, y)
layer_0.add(pf)
r = random.randint(2, 5)
for i in range(r):
x_ = random.randint(pf.rect.x-32, pf.rect.x+64)
y_ = random.randint(pf.rect.y-32, pf.rect.y+64)
pf = Monster(x_, y_, random.randint(1, 4))
layer_1.add(pf)
layer_monster.add(pf)
layer_all_monster_and_layer.add(pf)
x += 32
x = x_initial
y += 32
def __init__(self,
elevator_count,
floor_count,
message_width,
name='Building',
trace_riders=False):
self.elevators = [Elevator(n) for n in range(elevator_count)]
self.floors = [Floor(0, has_down_button=False)]
self.floors.extend(Floor(n) for n in range(floor_count)[1:-1])
self.floors.append(Floor(floor_count - 1, has_up_botton=False))
self._all_riders = []
self._message_width = message_width
self._messages = []
self._name = name
self._trace_riders = trace_riders
def main():
ground = Floor() # Create the ground
ground.gen_coor() # Generate coordinates of the ground
fl_coor = ground.coor # fl_coor are the coordinates of the ground (numpy array)
# print fl_coor
ground.gen_versors() # Generate local versors in all the ground segments
par_ver = ground.par_ver #par_ver has all the parallel versos of the segments
nor_ver = ground.nor_ver #par_ver has all the parallel versos of the segments
# print par_ver
bike_test = Bike() # Initiate Bike object
bike_test.gen_rand_bike() # Random parameters
#EXAMPLE
# l0_ww = bike_test.l0_ww #
# print l0_ww
# Test Distance routine
# res = bk_gd_int(bike_test,ground)
# print res
# print w1_pos[0],w1_pos[1]
RuKu4(bike_test,ground)
bike_new = Bike()
bike_new.gen_sp_bike(bike_positions,bike_mass,k_sp)
def step(self):
self.__doodle.move()
if self.__doodle.getTop() <= self.__magicLine:
if self.__doodle.getSpeedY() < 0:
self.__doodle.reachMagicLine()
self.__doodle.increaseScore()
else:
self.__doodle.leaveMagicLine()
if self.__doodle.isAtMagicLine():
for floor in self.__floors:
floor.moveY(-self.__doodle.getSpeedY())
for floor in list(self.__floors):
if floor.isDoodleLandOn(self.__doodle.getCenterX(),
self.__doodle.getBottom(),
self.__doodle.getSpeedY()):
# 看看是掉到了什么东西上
if floor.getLandOnItemType() == ItemType.ROCKET:
self.__doodle.landOnRocket(floor.getItemOn())
elif floor.getLandOnItemType() == ItemType.SPRING:
self.__doodle.landOnSpring()
elif floor.getLandOnItemType() == ItemType.FLOOR:
self.__doodle.landOnFloor()
if floor.isOutOfScreen():
self.__floors.remove(floor)
self.__floors.add(
Floor(self.getWindowX(), self.getWindowY(), isNew=True))
self.drawAll()
pygame.display.update()
def __init__(self):
self.blinks_detector = BlinkDetector()
self.blinks_detector.start()
pygame.init()
pygame.event.set_allowed([
QUIT, KEYDOWN, KEYUP, Pipes.SPAWN_PIPE_EVENT, Bird.BIRD_FLAP_EVENT
])
self.active = True
self.score = 0
self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT),
DOUBLEBUF)
self.screen.set_alpha(None)
self.clock = pygame.time.Clock()
self.font = pygame.font.Font('fonts/04B_19.ttf', 40)
# Game objects
self.bg_surface = pygame.transform.scale2x(
pygame.image.load("assets/background-day.png").convert())
self.gameover_surface = pygame.transform.scale2x(
pygame.image.load("assets/gameover.png").convert_alpha())
self.gameover_rect = self.gameover_surface.get_rect(
center=(SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2))
self.floor = Floor()
self.bird = Bird()
self.bird.start_flapping()
self.pipes = Pipes()
self.pipes.start_spawning()
def main(argv):
loop = True
floors = []
if len(sys.argv) < 3:
printWarning(
"usage:\nMVP\t -n = Number of floors\n\t -m= Number of Elevators")
return 0
m, n = int(sys.argv[1]), int(sys.argv[2])
printInfo("received values:" + str(n) + " " + str(m))
admin = Admin(n, m)
for i in range(m):
floors.append(Floor(i, admin))
while loop: ## While loop which will keep going until loop = False
admin.printStatusElevators()
print_menu() ## Displays menu
choice = input("Enter your choice [1-3]: ")
if choice == 1:
floor, destination = map(
int,
raw_input(" <floor> <destination floor>\n").split(" "))
if floor <= m and destination <= m and destination != floor:
up_down = 1 if destination > floor else 2
closer_elevator = floors[floor].askResources(up_down)
print "The elevator " + str(
closer_elevator) + " will attend this request"
threading.Timer(
1, set_floor,
[admin.elevators[closer_elevator], floor, destination
]).start()
#routine to ask elevator
elif choice == 2:
admin.printStatusElevators()
elif choice == 3:
loop = False
def load_tower(flo, newgame=True):
with open(flo, 'r') as file:
temp_tower = []
if newgame:
pass
for n, line in enumerate(file, 0):
if n != 51:
temp_floor = {}
line = line.strip('\n').strip('(').strip(')').split(')((')
for entry in line:
point, item = entry.split('), ')
i, j = point.split(', ')
temp_floor.update({(int(i), int(j)): item.strip("'")})
temp_tower.append(Floor(n, *temp_floor.items()))
else:
tower = Tower(temp_tower)
tower.current = tower.tower[int(
line.strip('\n').split('/')[6])]
temp = zip([
'i', 'j', 'hp', 'attack', 'defense', 'gold', 'num',
'yellow_key', 'blue_key', 'red_key', 'shop', 'cross',
'lucky_coin', 'magic_defense', 'dragon_dagger',
'hallows'
],
line.strip('\n').split('/'))
prot = Protagonist('protagonist', tower,
**dict([i for i in temp]))
return tower, prot
def on_init(self):
pygame.init()
self.screen = pygame.display.set_mode((576, 1025))
self.clock = pygame.time.Clock()
self.gameActive = True
self.gravity = 0.25
self.score = 0
self.scoreText = Text(self.score, 40)
self.highScore = 0
self.highScoreText = Text(f'High score: {int(self.score)}', 40)
self.background = pygame.image.load(
"assets/background-day.png").convert()
self.background = pygame.transform.scale2x(self.background)
self.floor = Floor()
self.bird = Bird()
self.pipes = []
self.SPAWNPIPE = pygame.USEREVENT
self.BIRDFLAP = pygame.USEREVENT + 1
pygame.time.set_timer(self.SPAWNPIPE, 1200)
pygame.time.set_timer(self.BIRDFLAP, 200)
def test_properties(self, method):
f = Floor(num=1, height=10)
self.assertEqual(1, f.num)
self.assertEqual(10, f.height)
self.assertTrue(type(f.signal_elevator_requested) is Signal)
self.assertTrue(type(f.people) is list)
self.assertTrue(type(f.queue) is list)
def load_all(self):
self.game_w = GAME_SIZE[0]
self.game_h = GAME_SIZE[1]
self.floor_y = self.game_h - FLOOR_Y
self.bird_x = self.game_w / 3 - FLOOR_Y
self.bird_y = self.game_h / 2
self.pipe_w = PIPE_W
self.build_y = self.floor_y - 229
self.mes_x = (self.game_w - MES_W) / 2
self.mes_y = (self.game_h - MES_H) / 2
self.game_p = self.game_w - DIST - self.pipe_w
self.max_s = self.floor_y - MIN_PIPE_H - DIST
self.min_pipe_h = MIN_PIPE_H
self.end_s_x = (self.game_w - 139) / 2
self.sc_x = (self.game_w - 70) / 2
self.score = 0
self.sprites = pygame.sprite.LayeredUpdates()
self.tubes = pygame.sprite.LayeredUpdates()
self.background = make_back(self)
self.screen.blit(self.background, (0, 0))
########################################################################
self.floor = Floor(0, self.floor_y, self.game_w)
self.floor.mVel = 0
self.bird = Bird(self, self.bird_x, self.bird_y)
self.bird.mAcc = 0
self.end_scores = EndScore(self.end_s_x, 200)
self.message = Message(self.mes_x, self.mes_y)
self.currentS = CurrentScore(self, self.sc_x, 100)
########################################################################
self.sprites.add(self.floor, layer=0)
self.sprites.add(self.bird, layer=2)
self.sprites.add(self.message, layer=3)
def scroll(self):
"""
地面を右から左へスクロールする
"""
# スクロールする
for f in self.floors:
f_x = f.left - self.scroll_step
f.left = f_x
# 画面左端に達した地面を消す
if self.floors[0].right < 0:
del self.floors[0]
# 画面右端にブロックを追加する
if (conf.SCREEN_WIDTH - self.floors[-1].right) > self.gap_to_next:
if random.choice([True, False]):
# 新しいブロックは前のブロックよりも上
floor_y_top = max(self.floors[-1].top - conf.GAP_UP_Y_TO_NEXT,
230)
floor_y = random.randint(floor_y_top, self.floors[-1].top)
else:
# 新しいブロックは前のブロックよりも下
floor_y = random.randint(self.floors[-1].top,
conf.SCREEN_HEIGHT - 30)
floor_length = random.randint(90 - self.new_floor_level,
200 - self.new_floor_level)
new_floor = Floor(conf.SCREEN_WIDTH, floor_y, floor_length,
conf.FLOOR_HEIGHT)
self.floors.append(new_floor)
# 新しい床の出現までランダムに間隔を空ける
self.gap_to_next = self.get_gap_to_next()
def __init__(self, game, speed, location, gameboard):
super(Player, self).__init__(location, (CELL_SIZE, CELL_SIZE))
self.game = game
self.root = game.root
self.gameboard = gameboard
self.speed = speed
self.flyable = False
self.condition = "NORMAL"
self.on_power = False
self.get_top = False
self.health = 500
self.magic = 200
self.feature = "NONE"
self.defence = 0
self.ykeynum = 0
self.bkeynum = 0
self.rkeynum = 0
self.gkeynum = 0
self.swordkeynum = 0
self.snakedp = 0
self.snakerocknum = 0
self.money = 0
self.exp = 0
self.level = 1
STARTFLOOR = 1
self.currentfloor = Floor(STARTFLOOR)
self.visited_floors = {STARTFLOOR: self.currentfloor}
self.quests = []
def _initialize_sprites(self, level_map):
"""A method which initializes the level, creates all objects necessary for the game to run
Args:
level_map: the layout of the level in a two dimensional list [y][x]
"""
height = len(level_map)
width = len(level_map[0])
for pos_y in range(height):
for pos_x in range(width):
cell = level_map[pos_y][pos_x]
normalized_x = pos_x * self.cell_size
normalized_y = pos_y * self.cell_size
if cell == 0:
self.floors.add(Floor(normalized_x, normalized_y))
elif cell == 1:
self.walls.add(Wall(normalized_x, normalized_y))
elif cell == 2:
self.player = Player(pos_x, pos_y, normalized_x,
normalized_y)
self.floors.add(Floor(normalized_x, normalized_y))
self.level_map[pos_y][pos_x] = self.player
elif cell == 3:
self.stairs = Stairs(normalized_x, normalized_y)
elif cell == 4:
enemy = Slime(pos_x, pos_y, normalized_x, normalized_y)
self.enemies.add(enemy)
self.floors.add(Floor(normalized_x, normalized_y))
self.level_map[pos_y][pos_x] = enemy
elif cell == 5:
enemy = Ranger(pos_x, pos_y, normalized_x, normalized_y)
self.enemies.add(enemy)
self.floors.add(Floor(normalized_x, normalized_y))
self.level_map[pos_y][pos_x] = enemy
elif cell == 6:
item = Item(pos_x, pos_y, normalized_x, normalized_y)
self.floors.add(Floor(normalized_x, normalized_y))
self.objects.add(item)
self.level_map[pos_y][pos_x] = item
self.all_sprites.add(self.walls, self.floors, self.stairs,
self.objects, self.enemies, self.player)
self.refresh_enemy_queue()
self.setup_camera()
def test_request_elevator(self, method):
observer = Mock()
f = Floor(num=0, height=0)
f.signal_elevator_requested.connect(observer)
f.signal_elevator_requested.emit(from_floor=1, to_floor=2)
observer.assert_called_once_with(from_floor=1, to_floor=2)
def __init__(self, level):
super(HowlGame, self).__init__(255, 255, 255, 255, 4000, 2000)
# init voice
self.NUM_SAMPLES = 1000 # pyAudio内部缓存块大小
self.LEVEL = 1500 # 声音保存的阈值
self.sample_count = 0 # 取样次数
self.average_volume = 0 # 平均音量
# init floor
self.floor = Floor(self, level)
self.add(self.floor, 0)
# init voiceBar
self.voiceBar = Sprite('ground/black.png', color=(0, 0, 255))
# self.voiceBar.position = 100, 460
self.voiceBar.scale_y = 0.1
self.voiceBar.image_anchor = 0, 0
self.add(self.voiceBar, 1)
# init role
self.role = Role(self)
self.role_run_to_right = False
self.role_run_to_left = False
self.add(self.role, 2)
self.action = FadeOut(0.5)
# init monster
# self.monster_node = cocos.cocosnode.CocosNode()
# for i in range(5):
# self.monster_node.add(Monster(self))
# self.add(self.monster_node)
# init flag
# flag = cocos.sprite.Sprite('scene/flag.png')
# flag.position = 3500, 120
# flag.scale = 0.5
# self.flag = flag
# self.add(flag)
# init stone
self.stone = None
self.boom = cocos.sprite.Sprite('scene/boom.png')
# init gameoverlayer
self.gameover = None
# Open Audio Input
pa = PyAudio()
SAMPLING_RATE = int(
pa.get_device_info_by_index(0)['defaultSampleRate'])
self.stream = pa.open(format=paInt16,
channels=1,
rate=SAMPLING_RATE,
input=True,
frames_per_buffer=self.NUM_SAMPLES)
self.schedule(self.update)
def main():
# initialize game engine
pygame.init()
# Setup main window
window_width = 400
window_height = 300
screen = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("YARL!")
# Initialize Hero
floor = Floor("floors/dungeon.json")
hero = Hero()
print(hero.name + " just entered " + floor.name)
hero.loc_x = floor.spawn[0]
hero.loc_y = floor.spawn[1]
set_position(hero, floor)
# Initialize ennemies
nb_ennemies = 1
ennemies = []
for ennemy in range(nb_ennemies):
ennemies.append(Ennemy())
loc = get_ennemy_spawn(floor, ennemies, hero)
ennemies[-1].loc_x = loc[0]
ennemies[-1].loc_y = loc[1]
set_position(ennemies[-1], floor)
# Example of event handling
while True:
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.KEYDOWN:
next_loc = [hero.loc_x, hero.loc_y]
if event.key == pygame.K_LEFT:
next_loc[0] -= 1
if event.key == pygame.K_RIGHT:
next_loc[0] += 1
if event.key == pygame.K_UP:
next_loc[1] -= 1
if event.key == pygame.K_DOWN:
next_loc[1] += 1
set_loc(floor, hero, ennemies, next_loc)
set_position(hero, floor)
# Get all items to blit
blits = floor.get_blits()
blits += ui.get_blits()
blits += hero.get_blits()
for ennemy in ennemies:
blits += ennemy.get_blits()
# Blit and update display at every frame
for item in blits:
screen.blit(item[0], item[1])
pygame.display.update()
def init_scene(self):
self.add_entity(Sky(0, 0, self))
self.add_entity(Floor(0, 0, self))
self.generate_beams()
self.generate_coins()
self.generate_magnets()
self.add_entity(Dragon(10, 450, self))
self.__mando = Mando(10, 0, self)
self.add_entity(self.__mando)
def __init__(self, width, height):
super(Game, self).__init__(width=width, height=height)
pyglet.clock.schedule_interval(self.update, 1 / 120.0)
self.fps_display = pyglet.window.FPSDisplay(self)
self.player = Player(50, 300)
self.floor = Floor(0, 10)
self.enemy = Enemy(300, 400)
self.push_handlers(self.player.key_handler)
self.game_objects = [self.player, self.floor, self.enemy]
def eval_genomes(pop):
global WIN
clock = pygame.time.Clock()
pipes = [Pipe(700)]
base = Floor(FLOOR)
win = WIN
score = 0
run = True
while run:
clock.tick(30)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
pygame.quit()
quit()
break
rem = []
add_pipe = False
for pipe in pipes:
pipe.move()
pop.check_colision_with_pipe(pipe, win)
if pipe.x + pipe.PIPE_TOP.get_width() < 0:
rem.append(pipe)
if not pipe.passed and pipe.x < pop.pop[0].x:
pipe.passed = True
add_pipe = True
if add_pipe:
score += 1
pop.increment_score_by_n(10)
pipes.append(Pipe(WIN_WIDTH))
for r in rem:
pipes.remove(r)
pipe_ind = 0
if pop.done() != True:
if len(pipes) > 1 and pop.pop[
0].x > pipes[0].x + pipes[0].PIPE_TOP.get_width():
pipe_ind = 1
pop.increment_score_by_n(0.03)
pop.update_alive(pipes, pipe_ind, FLOOR)
base.move()
else:
pop.natural_selection()
run = False
draw_window(WIN, pop.pop, pipes, base, score, gen, pipe_ind)
def __init__(self, floors_count, elevators_count):
self.floors_count = floors_count
self.elevators_count = elevators_count
self.floors = [Floor(number) for number in range(1, floors_count + 1)]
self.elevators = [
Elevator(ind, self.floors[0])
for ind in range(1, elevators_count + 1)
]
print(self)
def generate_floor(self,floor_lvl):
self.floor_lvl = floor_lvl
if self.floor_lvl >= SETTINGS['max_floor_size']:
self.floor_lvl = SETTINGS['max_floor_size']-1
cards = []
cards.append(self._gen_exit_card())
for i in range(self.floor_lvl):
randroll = randint(0,99)
# 5%
if randroll > 0 and randroll <= 4:
cards.append(self._gen_free_card())
# 15%
elif randroll > 4 and randroll <= 19:
cards.append(self._gen_loot_card())
# 10%
elif randroll > 19 and randroll <= 29:
cards.append(self._gen_tip_card())
# 5%
elif randroll > 29 and randroll <= 34:
cards.append(self._gen_chest_card())
# 15%
elif randroll > 34 and randroll <= 49:
cards.append(self._gen_trade_card())
# 10%
elif randroll > 49 and randroll <= 59:
cards.append(self._gen_fairy_card())
# 5%
elif randroll > 59 and randroll <= 64:
cards.append(self._gen_slots_card())
# 20%
elif randroll > 64 and randroll <= 84:
cards.append(self._gen_monster_card())
# 5%
elif randroll > 84 and randroll <= 89:
cards.append(self._gen_trap_card())
# 5%
elif randroll > 89 and randroll <= 94:
cards.append(self._gen_arena_card())
# 5%
else:
cards.append(self._gen_thief_card())
shuffle(cards)
return Floor(cards)
def __init__(self, rows):
super(Map, self).__init__()
self.height = len(rows)
self.width = len(rows[0])
for y, row in enumerate(rows):
self._map[y] = {}
for x, item in enumerate(row):
if item == '#':
self._map[y][x] = Floor()
elif item == '|':
self._map[y][x] = Door()
elif item == '@':
self._map[y][x] = Player()
else:
self._map[y][x] = None
def setup(self):
for i in range(0, self.numFloors):
self.floors.append(Floor(i))
for elevatorID in range(0, self.numElevators):
self.elevators.append(Elevator(elevatorID, self))
self.graphics = PelevatorGraphics(self)
# create some persons initially
for i in range(0, 3):
self.addPerson()
self.graphics.start()
def __init__(self, FloorNumber, ElevatorNumber):
self.FloorNumber = FloorNumber
self.ElevatorNumber = ElevatorNumber
self.Elevators = []
self.Passengers = []
self.Floors = []
self.Lines = []
self.RenderedText = []
self.FloorNumberRects = []
self.PressedButtonsRect = []
self.SavedButtonsUp = []
self.SavedButtonsDown = []
self.RenderedTextUp = []
self.RenderedTextDown = []
self.addPassenger(config.BASEPASSENGERS)
pressedUpDestination, pressedDownDestination = [], []
for i in range(self.FloorNumber):
self.RenderedTextUp.append(
config.SMALLFONT.render("tempText", True, config.BLUE))
self.RenderedTextDown.append(
config.SMALLFONT.render("tempText", True, config.BLUE))
for i in range(self.FloorNumber):
self.SavedButtonsUp.append([set(), set()])
self.SavedButtonsDown.append([set(), set()])
for i in range(ElevatorNumber):
self.Elevators.append(Elevator(i, config.FLOORHEIGHT))
self.Floors.append([])
[
self.Floors[i].append(
Floor(self.Elevators[-1], j, config.FLOORHEIGHT))
for j in range(FloorNumber)
]
[
self.Lines.append([
(130, i * config.FLOORHEIGHT),
(130 + (self.ElevatorNumber + 1) * config.FLOORWIDTH,
i * config.FLOORHEIGHT)
]) for i in range(FloorNumber)
]
[
self.RenderedText.append(
config.BIGFONT.render(str(i), True, config.BLUE))
for i in range(FloorNumber)
]
self.resizeFloorNumbers()
self.resizePressedButtons()
self.setSectorList()
def generateFloors():
"""
return [ floor1, floor2, ... ]
"""
NUM_FLOORS = 3
floors = []
for num in range(1, NUM_FLOORS + 1):
floor = Floor(num=num, height=FLOOR_HEIGHT_PX)
floors.append(floor)
Clock.schedule_interval(floor.tick, UPDATE_INTERVAL_SEC)
# remove this
floors[-1].people.append(Person(floors[-1].num, 1))
return floors
def getParkingData(self,vehicleList):
print "\n<--- ENTER VEHICLE DATA --->"
for numOfFloors in range(2):
vehicleDict = {}
print "\n --- Floor {} ---".format(numOfFloors)
vehicleLimit = int(input("\nEnter the Number of vehicles: "))
totalvehicles = 0
for vehicles in vehicleList:
vehicleDict[vehicles] = int(input("\n\t {}: ".format(vehicles)))
totalvehicles += vehicleDict[vehicles]
if totalvehicles == vehicleLimit:
self.floorObject = Floor(vehicleDict)
print "\nDATA STORED SUCCESSFULLY"
else:
print "\nEnter vehicles count within {}\n".format(vehicleLimit)
break
self.addFloorData(self.floorObject)
return self.data,self.floorObject
def create_map(self):
self.random_map()
self.tiles = []
for i in range(self.number_of_tiles):
for j in range(self.number_of_tiles):
tile = []
position = j * self.number_of_tiles + i
if position in self.walls:
tile.append(Wall())
else:
tile.append(Floor())
tile.append(position)
x = self.tile_size * j
y = self.tile_size * i
tile[0].x = x
tile[0].y = y
tile.append([x, y])
self.tiles.append(tile)
def __init__(self, floors, index, mmin, mmax):
self.floors = []
for idx in range(floors):
if idx == 0:
self.floors.append(Firstfloor(idx, Direction.NONE))
elif idx == floors - 1:
self.floors.append(Lastfloor(idx, Direction.NONE))
else:
self.floors.append(Floor(idx, Direction.NONE, Direction.NONE))
self.index = index # elevator index
self.lock = threading.Lock()
self.cv = threading.Condition(self.lock)
self.current_floor = 0
self.min_floor = mmin
self.max_floor = mmax
self.direction = Direction.UP
self.num_of_request = 0
t1 = threading.Thread(target=self.move, args=())
t1.start()
def goto_floor(self, floornum):
""" 跳转至指定楼层。
floornum: 去往楼层号
"""
if floornum == self.currentfloor.floornum:
return
f = self.visited_floors.get(floornum)
if f is None:
f = Floor(floornum)
self.visited_floors[floornum] = f
self.root.remove(self.currentfloor.group)
oldfloornum = self.currentfloor.floornum
self.currentfloor = f
self.root.add(self.currentfloor.group)
if floornum > oldfloornum:
for npc in self.currentfloor.group.sprites():
if isinstance(npc, DownStair):
self.rect.left = npc.rect.left + CELL_SIZE
self.rect.top = npc.rect.top
if self.currentfloor.floornum == 10:
if KingSnake.first_ften == True:
Msgbox("You get here, now. But you can't continue."
).show()
KingSnake.first_ften = False
else:
for npc in self.currentfloor.group.sprites():
if isinstance(npc, UpStair):
if self.currentfloor.floornum == 7:
self.rect.left = npc.rect.left + CELL_SIZE
self.rect.top = npc.rect.top
elif self.currentfloor.floornum in [8, 12]:
self.rect.left = npc.rect.left
self.rect.top = npc.rect.top - CELL_SIZE
elif self.currentfloor.floornum == 9:
self.rect.left = npc.rect.left
self.rect.top = npc.rect.top + CELL_SIZE
else:
self.rect.left = npc.rect.left - CELL_SIZE
self.rect.top = npc.rect.top