def put_tile(self, coord):
pipe = self.mapdata.pipes[coord]
tile = self.mapdata.tiles[coord]
if self.selected in xrange(0, len(COLORS)): #colorize
if pipe.type != "empty.png":
pipe.switch_color(self.selected)
elif tile.type == "btn.png":
tile.switch_color(self.selected)
elif self.selected == "del_col.png": #decolorize
pipe.switch_color(None)
elif self.selected == "delete.png": #delete
tile.switch_type("empty.png")
elif self.selected == "del_pipe.png":
pipe.switch_type("empty.png")
elif self.selected.startswith("pipe"): #put/rotate pipes
if pipe.type == self.selected:
#change rotation on 2nd click
pipe.add_rot()
else:
pipe.switch_type(self.selected)
elif self.selected == "block.png": #block junction
if pipe.type == "pipe_tjunc.png":
pipe.switch_block()
else:
tile.switch_type(self.selected) #put normal tile
draw_map(self.mapdata, self.map_layer)
draw_pipes(self.mapdata, self.pipe_layer)
self.scr_update = 1
def unpause(self):
self.scr_update = 1
if self.next_was == "game":
self.next_was = None
self.mapdata = self.mapcopy.copy()
#elf.mapdata = load_mapdata("TMP", MAP_folder)
draw_map(self.mapdata, self.map_layer)
draw_pipes(self.mapdata, self.pipe_layer)
BaseState.unpause(self)
def run_map(self):
"""
Run the map with given user choices.
It takes no arguments.
It returns nothing.
"""
choice = self.radio_button_var.get()
#Make an input check before running map
if self.input_check(choice) == True:
#Prepare thresholds , facility_number , confidence_interval etc.
threshold, is_stochastis, min_threshold, facility_number, confidence_interval = self.get_user_entries(
choice)
#Generate file name of the solution file
self.generate_solution_filename(choice, threshold, is_stochastis,
min_threshold, facility_number,
confidence_interval)
if self.check_map() == True:
map.draw_map(self.map_file_name)
else:
#Prepare District data
name_of_districts, x_coordinates, y_coordinates, from_districts, to_districts, distances = solver.writer.reader.read_district_file(
)
risks = solver.writer.reader.read_risk()
risk_indicator = solver.writer.reader.util.generate_risk_indicator(
risks)
risk_array = solver.writer.reader.util.generate_risk_array()
random_numbers = solver.writer.reader.read_generated_numbers()
print("District file is read")
#Get availability_matrix , it can be stochastic as well
availability_matrix = self.get_appropriate_available_matrix(
choice, from_districts, to_districts, distances, threshold,
random_numbers, min_threshold, confidence_interval)
#Create fixed_cost
fixed_cost = solver.writer.reader.util.generate_fixed_cost_array(
)
print("Fixed_cost is created")
#Get .dat file
self.write_appropriate_dat_file(choice, availability_matrix,
fixed_cost, threshold,
facility_number, is_stochastis,
confidence_interval,
risk_indicator, risk_array,
min_threshold)
solver.run(choice, threshold, confidence_interval,
facility_number, min_threshold)
print(self.solution_file_name)
solution_array = solver.writer.reader.read_cloud_solution(
self.solution_file_name)
print("Solution array is read")
map.run(solution_array, name_of_districts, x_coordinates,
y_coordinates, from_districts, to_districts, distances,
threshold, self.map_file_name)
def begin_match(level, destroy_menu):
destroy_menu.destroy()
draw_map(level)
name, choose, animals = set_up_turtle(level)
if level == 1: length_to_race = 400
elif level == 2: length_to_race = 800
else: length_to_race = 1000
check_available_to_move = [[0 for i in range(4)] for i in range(3)]
for i in range(0, 4, 1):
check_available_to_move[0][
i] = False #The first row describe if the animals can move
check_available_to_move[1][i] = False
check_available_to_move[2][i] = 0
winner, score = race(animals, check_available_to_move, length_to_race)
winning_pose(animals[winner])
turtle.bye()
if choose == winner + 1:
endgame_board(True)
else:
endgame_board(False)
def on_draw(self):
arcade.start_render()
# self.stars._refresh_shape((5,1))
# self.stars.draw()
for bodie in self.bodies:
if orb_in_view(bodie):
bodie.draw()
if (self.buttons_down['v']):
arcade.draw_line(bodie.pos.x, bodie.pos.y,
bodie.pos.x + bodie.vel.x,
bodie.pos.y + bodie.vel.y,
arcade.color.WHITE, bodie.size / 10)
if bodie == self.orb and self.dest != self.orb:
arcade.draw_line(bodie.pos.x, bodie.pos.y, self.dest.pos.x,
self.dest.pos.y, self.dest.color, 2)
if self.map_on:
draw_map(self.bodies, self.window_width, self.window_height)
arcade.finish_render()
def __init__(self, mapdata=None):
BaseState.__init__(self)
self.selected = None
self.map_pos = (0, 32)
self.scr_update = 1
self.next_was = None
#tile buttons
buttons = [
"delete.png",
"start.png",
"finish.png",
"ground.png",
"btn.png",
"del_pipe.png",
"pipe.png",
"pipe_exit.png",
"pipe_turn.png",
"pipe_tjunc.png",
"block.png",
]
x, y = 0, 0
self.tile_buttons = {}
for b in buttons:
self.background.blit(GFX_tiles[b], (x, y))
tile_button = ImgButton(img=GFX_tiles[b],
callback=self.select_type,
name=b)
tile_button.set_pos((x, y))
self.widgets.append(tile_button)
self.tile_buttons[b] = tile_button
x += 34
self.select_type("delete.png")
#color buttons
y = 0
x = 800 - ((len(COLORS) + 1) * 34)
img = GFX_tiles["del_col.png"] #nocolor button
self.background.blit(img, (x, y))
col_button = ImgButton(img,
callback=self.select_type,
name="del_col.png")
col_button.set_pos((x, y))
self.widgets.append(col_button)
self.tile_buttons["del_col.png"] = col_button
x += 34
img = pygame.Surface((32, 32))
for c in COLORS: #draw button for each color
img.fill(c)
name = COLORS.index(c)
self.background.blit(img, (x, y))
col_button = ImgButton(img=img,
callback=self.select_type,
name=name)
col_button.set_pos((x, y))
self.widgets.append(col_button)
self.tile_buttons[name] = col_button
x += 34
#save, load and test button
x, y = 704, 584
buttons = ["save.png", "load.png", "test.png"]
for b in buttons:
img = GFX_tiles[b]
self.background.blit(img, (x, y))
btn = ImgButton(img, callback=self.submit, action=b)
btn.set_pos((x, y))
self.widgets.append(btn)
x += 34
#quit button
x = 0
img = GFX_tiles["quit.png"]
self.background.blit(img, (x, y))
btn = ImgButton(img, callback=self.quit)
btn.set_pos((x, y))
self.widgets.append(btn)
#new button
x += 34
img = GFX_tiles["new.png"]
self.background.blit(img, (x, y))
btn = ImgButton(img, callback=self.new_map)
btn.set_pos((x, y))
self.widgets.append(btn)
#map
if mapdata:
self.mapdata = mapdata
else:
self.mapdata = MapData()
self.mapcopy = self.mapdata.copy()
self.map_layer = pygame.Surface((800, 544))
self.map_layer.set_colorkey((255, 0, 255))
self.map_layer.fill((20, 20, 20))
self.pipe_layer = pygame.Surface((800, 544))
self.pipe_layer.set_colorkey((255, 0, 255))
self.pipe_layer.fill((255, 0, 255))
draw_map(self.mapdata, self.map_layer)
draw_pipes(self.mapdata, self.pipe_layer)
#tile buttons
for k in self.mapdata.tiles.keys():
tile = self.mapdata.tiles[k]
rect = [[
tile.pos[0] * 32 + self.map_pos[0],
tile.pos[1] * 32 + self.map_pos[1]
], [32, 32]]
btn = DragArea(rect, callback=self.put_tile, coord=k)
self.widgets.append(btn)
#grid
self.grid_layer = pygame.Surface((800, 544))
self.grid_layer.fill((255, 0, 255))
self.grid_layer.set_colorkey((255, 0, 255))
for i in xrange(1, 25):
pygame.draw.line(self.grid_layer, (255, 255, 255), (i * 32, 0),
(i * 32, 544))
for i in xrange(1, 17):
pygame.draw.line(self.grid_layer, (255, 255, 255), (0, i * 32),
(800, i * 32))
#keyboard shortcuts
self.add_kbevent(KEYDOWN, K_ESCAPE, self.quit)
#self.add_kbevent(KEYDOWN, K_F3, self.new_map)
self.add_kbevent(KEYDOWN, K_F5, self.submit, action="test.png")
self.add_kbevent(KEYDOWN, K_F7, self.submit, action="save.png")
self.add_kbevent(KEYDOWN, K_F8, self.submit, action="load.png")