def draw_flood(self, canvas: Canvas, step_time_ms: int): scale = canvas.winfo_width() / (self.size * 2 + 1) flood_step = self.flood.step() rgb = self.to_rgba(flood_step["position"]) color = "#" + \ str(hex(int(rgb[0] * 255)))[2:].rjust(2, '0') + \ str(hex(int(rgb[1] * 255)))[2:].rjust(2, '0') + \ str(hex(int(rgb[2] * 255)))[2:].rjust(2, '0') for point in flood_step["front"]: canvas.create_rectangle((point["x"] * 2 + 1) * scale, (point["y"] * 2 + 1) * scale, (point["x"] * 2 + 2) * scale, (point["y"] * 2 + 2) * scale, fill=color, width=0) if point['from'] == DIRECTIONS[0]: canvas.create_rectangle((point["x"] * 2) * scale, (point["y"] * 2 + 1) * scale, (point["x"] * 2 + 1) * scale, (point["y"] * 2 + 2) * scale, fill=color, width=0) elif point['from'] == DIRECTIONS[1]: canvas.create_rectangle((point["x"] * 2 + 1) * scale, (point["y"] * 2) * scale, (point["x"] * 2 + 2) * scale, (point["y"] * 2 + 1) * scale, fill=color, width=0) elif point['from'] == DIRECTIONS[2]: canvas.create_rectangle((point["x"] * 2 + 2) * scale, (point["y"] * 2 + 1) * scale, (point["x"] * 2 + 3) * scale, (point["y"] * 2 + 2) * scale, fill=color, width=0) elif point['from'] == DIRECTIONS[3]: canvas.create_rectangle((point["x"] * 2 + 1) * scale, (point["y"] * 2 + 2) * scale, (point["x"] * 2 + 2) * scale, (point["y"] * 2 + 3) * scale, fill=color, width=0) if len(flood_step["front"]) > 0: canvas.after(step_time_ms, lambda: self.draw_flood(canvas, step_time_ms))
class StarField: def __init__(self, width, height, depth=32, num_stars=500): self.master = Tk() self.master.title("StarField") self.master.resizable(False, False) self.master.maxsize(width, height) self.fov = 180 * math.pi / 180 self.view_distance = 0 self.stars = [] self.width = width self.height = height self.max_depth = depth self.canvas = Canvas(self.master, width=width, height=height, bg="#000000") self.canvas.pack() for x in range(num_stars): star = Star(x=randrange(-self.width, self.width), y=randrange(-self.height, self.height), z=randrange(1, self.max_depth)) star.id = self.canvas.create_oval(star.x - star.radius, star.y - star.radius, star.x + star.radius, star.y + star.radius, fill='#FFFFFF') self.stars.append(star) self.draw() mainloop() def draw(self): for star in self.stars: # move depth star.z -= 0.19 star.radius = (1 - float(star.z) / self.max_depth) * 1.7 star.fill = int((1 - float(star.z) / self.max_depth) * 255) # reset depth if star.z <= 0: star.x = randrange(-self.width, self.width) star.y = randrange(-self.height, self.height) star.z = self.max_depth star.radius = 1 star.fill = 0 # Transforms this 3D point to 2D using a perspective projection. factor = self.fov / (self.view_distance + star.z) x = star.x * factor + self.width / 2 y = -star.y * factor + self.height / 2 self.canvas.coords(star.id, x - star.radius, y - star.radius, x + star.radius, y + star.radius) self.canvas.itemconfig(star.id, fill='#%02x%02x%02x' % (star.fill, star.fill, star.fill)) self.canvas.after(30, self.draw)
class MainWindow(Frame): def __init__(self): super().__init__() self.initUI() self.to_clear = [] def initUI(self): self.master.title('Simulación caja') self.pack(fill=tk.BOTH, expand=1) self.canvas = Canvas(self) self.canvas.pack(fill=tk.BOTH, expand=1) self.x = 20 self.canvas.create_rectangle(0, 0, WIDTH, HEIGHT, fill='#fff') box(self.canvas, 10, 10) self.boton_siguiente = Button(self, text='siguiente', command=siguiente) print(self.winfo_width()) self.boton_siguiente.place(x=500, y=50) def clear(self, fast=True): if fast: for item in self.to_clear: self.canvas.create_rectangle(*item, outline='#fff', fill='#fff') def draw(self): self.clear() for i_row, row in enumerate(deposito): for i_col, cell in enumerate(row): if cell == True: posicion = Position(row=i_row, col=i_col) c = (i_row, i_col) if posicion == posicion_inicial: cell_image = box(self.canvas, i_col, i_row, color='#FAA') elif c in posicion_actual.cells: cell_image = box(self.canvas, i_col, i_row, color='#FFA') elif c in posicion_destino.cells: cell_image = box(self.canvas, i_col, i_row, color='#AFA') else: cell_image = box(self.canvas, i_col, i_row, color='#AAf') self.to_clear.append(cell_image) self.canvas.after(30, self.draw)
class GUI(object): def __init__(self, universe): self.ticks = 0 self.universe = universe self.width = universe.width self.height = universe.height self.window = Tk() self.window.title("Mars Explorer") temp_x, temp_y = self.get_window_coordinates() self.window.geometry('%dx%d+%d+%d' % (self.width, self.height, temp_x, temp_y)) self.canvas = Canvas(self.window, width=self.width, height=self.height) self.canvas.pack() self.canvas.after(1, self.tick()) def start(self): print('GUI:: Starting loop...') self.window.mainloop() def get_window_coordinates(self): # Get screen width and height. screen_width = self.window.winfo_screenwidth() screen_height = self.window.winfo_screenheight() # Get x and y window_x = screen_width / 2 - self.width / 2 window_y = screen_height / 2 - self.height / 2 return window_x, window_y def tick(self): # Stop if done. if self.universe.universe_is_no_more(): return self.universe.tick() self.draw() self.ticks += 1 self.canvas.after(1, self.tick) def draw(self): self.canvas.delete('all') self.universe.draw(self.canvas) for obj in self.universe.objects: obj.draw(self.canvas) self.canvas.create_text(70, 10, text=str(self.ticks)) self.canvas.create_text(70, 50, text='Rocks delivered: %d' % self.universe.n_rocks_collected) self.canvas.create_text(70, 70, text='Total rocks: %d' % self.universe.n_rocks)
class Animation(object): # Override these methods when creating an animation def mousePressed(self, event): pass def keyPressed(self, event): pass def timerFired(self): pass def init(self): pass def redrawAll(self): pass def run(self, width=1000, height=600): # create the root and the canvas root = Tk() self.width = width self.height = height self.boardDim = self.width - 400 self.canvas = Canvas(root, width=width, height=height) self.canvas.pack() # set up events def redrawAllWrapper(): self.canvas.delete(ALL) self.redrawAll() def mousePressedWrapper(event): self.mousePressed(event) redrawAllWrapper() def keyPressedWrapper(event): self.keyPressed(event) redrawAllWrapper() root.bind("<Button-1>", mousePressedWrapper) root.bind("<Key>", keyPressedWrapper) # set up timerFired events self.timerFiredDelay = 50 def timerFiredWrapper(): self.timerFired() redrawAllWrapper() # pause, then call timerFired again self.canvas.after(self.timerFiredDelay, timerFiredWrapper) # init and get timerFired running self.init() timerFiredWrapper() pygame.init() # launch the app root.mainloop()
def loo_lumi(aken, lume_pilt, kingi_pilt): """Create new snow, gifts and make both move with another function.""" lumi = Canvas(aken, bg="Blue", highlightthickness=0, width=20, height=20) pilt = [lume_pilt, kingi_pilt] pilt = random.choice(pilt) positsioon_x = random.randint(0, 780) lumi.create_image(9, 9, image=pilt) lumi.pack() lumi.after(500, loo_lumi, aken, lume_pilt, kingi_pilt) lumesadu(aken, lumi, positsioon_x, 120)
class PulseText: def __init__(self, parent): self.canvas = Canvas(parent, bg=ApiSettings.Background, highlightthickness=0) width = int(self.canvas.cget("width")) / 2 height = int(self.canvas.cget("height")) / 2 self.text = self.canvas.create_text(width, height, fill=ApiSettings.Foreground, font=(ApiSettings.Font, ApiSettings.LargeTextSize), text="no text") self.run = False self.color = 0 self.brighten = True Logger.debug("Initialization of PulseText class") def _animation(self): pulse_color = "#{:02x}{:02x}{:02x}".format(self.color, self.color, self.color) if self.color == 0: self.brighten = True if self.color == 255: self.brighten = False if self.brighten: self.color += 5 else: self.color -= 5 self.canvas.itemconfig(self.text, fill=pulse_color) if self.run: self.canvas.after(15, self._animation) def set_text(self, text): self.canvas.itemconfig(self.text, text=text) Logger.debug("Set pulse text animation: {0}".format(text)) def start_animation(self): self.canvas.pack() self.run = True self._animation() Logger.debug("Start pulse text animation") def stop_animation(self): self.run = False self.canvas.pack_forget() Logger.debug("Stop pulse text animation")
class Gui(object): def __init__(self, width, height, world): self.ticks = 0 self.world = world self.width = width self.height = height self.keepGoing = True self.root = Tk() self.root.title("Mars Explorer Agent") window_x, window_y = self._compute_window_coords() self.root.geometry('%dx%d+%d+%d' % (self.width, self.height, window_x, window_y)) self.canvas = Canvas(self.root, width=self.width, height=self.height) self.canvas.pack() self.canvas.after(1, self._tick) self.root.protocol("WM_DELETE_WINDOW", self.onClosing) def onClosing(self): self.root.destroy() def start(self): self.root.mainloop() def _tick(self): self.world.tick() self._draw() self.ticks += 1 if self.keepGoing: self.canvas.after(10, self._tick) def _draw(self): self.canvas.delete('all') self.world.draw(self.canvas) self.canvas.create_text(self.width - 20, 10, text=str(self.ticks)) self.canvas.create_text(self.width - 70, 50, text='Rocks delivered: %d' % self.world.collectedSamples) self.canvas.create_text(self.width - 55, 70, text='Total rocks: %d' % self.world.existingSamples) def _compute_window_coords(self): # http://stackoverflow.com/a/14912644/742501 screen_width = self.root.winfo_screenwidth() screen_height = self.root.winfo_screenheight() window_x = screen_width / 2 - self.width / 2 window_y = screen_height / 2 - self.height / 2 return window_x, window_y
class SS(Tk): def __init__(self): super().__init__() # self.lift() # self.attributes("-fullscreen", True) # self.attributes('-topmost', True) self.sw = 700 # self.winfo_screenwidth() self.sh = 500 # self.winfo_screenheight() self.x = self.sw / 2 self.y = self.sh / 2 self.vx = randint(-3, 3) self.vy = randint(-3, 3) self.img_index = 0 self.c = Canvas(width=self.sw, height=self.sh) self.c.config(bg="black", bd=0, highlightthickness=0) self.c.pack() dvd_img = PhotoImage(file=f"{this_dir}/data/{self.img_index}.gif") self.dvd = dvd_img self.dvd_w = self.dvd.width() / 2 self.dvd_h = self.dvd.height() / 2 self.img = self.c.create_image(self.x, self.y, image=dvd_img) self.main() def change_img(self): self.img_index += 1 self.dvd["file"] = f"{this_dir}/data/{self.img_index}.gif" def main(self): self.x = self.x + self.vx self.y = self.y + self.vy if self.x - self.dvd_w < 0 or self.x + self.dvd_w > self.sw: self.vx = -self.vx self.change_img() if self.y - self.dvd_h < 0 or self.y + self.dvd_h > self.sh: self.vy = -self.vy self.change_img() if self.img_index >= 6: self.img_index = 0 self.c.coords(self.img, self.x, self.y) self.c.after(20, self.main)
class GUI(object): def __init__(self, world): self.ticks = 0 self.world = world self.width = world.width self.height = world.height self.root = Tk() self.root.title("Mars Explorer") window_x, window_y = self._compute_window_coords() self.root.geometry('%dx%d+%d+%d' % (self.width, self.height, window_x, window_y)) self.canvas = Canvas(self.root, width=self.width, height=self.height) self.canvas.pack() self.canvas.after(1, self._tick) def start(self): self.root.mainloop() def _tick(self): # Stop if done. if self.world.is_done(): return self.world.tick() self._draw() self.ticks += 1 self.canvas.after(1, self._tick) def _draw(self): self.canvas.delete('all') self.world.draw(self.canvas) for entity in self.world.entities: entity.draw(self.canvas) self.canvas.create_text(self.width - 20, 10, text=str(self.ticks)) self.canvas.create_text(self.width - 70, 50, text='Rocks delivered: %d' % self.world.rocks_collected) self.canvas.create_text(self.width - 55, 70, text='Total rocks: %d' % self.world.num_rocks) def _compute_window_coords(self): # http://stackoverflow.com/a/14912644/742501 screen_width = self.root.winfo_screenwidth() screen_height = self.root.winfo_screenheight() window_x = screen_width / 2 - self.width / 2 window_y = screen_height / 2 - self.height / 2 return window_x, window_y
def make_game(tk: Tk): """ The main activity constructor. It turns on the music volume to max level, allocates canvas and manages its entity motions. Generally speaking, there're just two sprites over here: the ball and the paddle. The first one is periodically re-rendered by the game, the last one's managed by the player. The endgame condition is the ball being fallen over the bottom viewport border. """ music.set_volume(GAME_VOLUME) canvas_width, canvas_height = tk.winfo_width(), tk.winfo_height() canvas = Canvas(tk, width=canvas_width, height=canvas_height, highlightthickness=0, bg=BACKGROUND_COLOR) canvas.pack_configure(expand=True, fill='both') canvas.setvar(GAME_IS_RUNNING) canvas.setvar(BALL_IS_MOVING) canvas.update() paddle_width, paddle_height = 150, 10 paddle_x, paddle_y = (canvas.winfo_width() - paddle_width) // 2, canvas.winfo_height() - 300 paddle_id = canvas.create_rectangle(paddle_x, paddle_y, paddle_x + paddle_width, paddle_y + paddle_height, width=0, fill=SPRITE_COLOR) paddle_vx = 8 canvas.bind_all(KEY_LEFT, move_paddle_left(canvas, paddle_id, paddle_vx)) canvas.bind_all(KEY_RIGHT, move_paddle_right(canvas, paddle_id, paddle_vx)) ball_x, ball_y, ball_r = 455, 300, 15 ball_id = canvas.create_oval(ball_x, ball_y, ball_x + 2 * ball_r, ball_y + 2 * ball_r, width=0, fill=SPRITE_COLOR) ball_vx, ball_vy = uniform(-3, -1), uniform(-4, -2) delay = 10 canvas.after( 0, move_ball(canvas, ball_id, paddle_id, choice([ball_vx, -ball_vx]), ball_vy, delay)) canvas.after(0, check_fall(tk, canvas, ball_id, delay))
class World(Tk): def __init__(self): Tk.__init__(self) self.queue = queue self.is_game_over = False self.canvas = Canvas(self, width=500, height=300, bg='red') self.canvas.pack() self.snake = self.canvas.create_line((0, 0), (0, 0), fill='black', width=10) self.food = self.canvas.create_rectangle(0, 0, 0, 0, fill='#FFCC4C', outline='#FFCC4C') self.points_earned = self.canvas.create_text(450, 20, fill='white', text='SCORE:0') self.queue_handler() def queue_handler(self): while True: try: task = self.queue.get(block=False) if task.get('game_over'): self.game_over() if task.get('move'): points = [x for point in task['move'] for x in point] self.canvas.coords(self.snake, *point) except queue.Empty: if not self.is_game_over: self.canvas.after(100, self.queue_handler) def game_over(self): self.is_game_over = True self.canvas.create_text('Game Over') qb = Button(self, text='Quit', command=self.destroy) rb = Button(self, text='Again', command=self.__init__)
class Visual(object): def __init__(self, width=800, height=600): root = Tk() self.root = root self.margin = 0.12*height self.width, self.height = width, height - self.margin self.cx, self.cy = width/2, (height - self.margin)/2 self.toolbar = \ Canvas(self.root, width=self.width, height=self.margin) self.toolbar.pack() self.canvas = Canvas(root, width=width, height=height - self.margin) self.canvas.pack() self.init_animation() root.bind("<Button-1>", lambda e: self.mouse_event(e)) root.bind("<Key>", lambda e: self.key_event(e)) root.mainloop() def draw_users(self): """Draw all users""" for user in self.users: user.draw() def draw_connections(self): """Draw all of user's connections""" for user in self.users: user.draw_students() def draw_start_screen(self): """Start screen text""" self.canvas.delete(ALL) cx, cy = self.width/2, self.height/2 font = ("Impact", "128") self.canvas.create_text(cx, 0.8*cy, text="INFECTION", font=font) font = ("Impact", 32) self.canvas.create_text(cx, 1.5*cy, text="Press s to Begin", font=font) def draw_setup_screen(self): """User setup screen""" self.canvas.delete(ALL) cx, cy = self.width/2, self.height/2 text = "Number of Users (1-{})".format(self.max_users) font = ("Impact", 24) self.canvas.create_text(cx, 0.4*cy, text=text, font=font) self.num_users_entry = Entry(self.canvas, justify=CENTER) self.canvas.create_window(cx, 0.5*cy, window=self.num_users_entry) self.num_users_entry.insert(0, str(self.default_users)) text = "Number of Coaches" self.canvas.create_text(cx, 0.6*cy, text=text, font=font) self.num_coaches_entry = Entry(self.canvas, justify=CENTER) self.canvas.create_window(cx, 0.7*cy, window=self.num_coaches_entry) self.num_coaches_entry.insert(0, str(self.default_coaches)) text = "Max Number of Students" self.canvas.create_text(cx, 0.8*cy, text=text, font=font) self.num_students_entry = Entry(self.canvas, justify=CENTER) self.canvas.create_window(cx, 0.9*cy, window=self.num_students_entry) self.num_students_entry.insert(0, str(self.default_students)) self.button = Button(cx, 1.5*cy, 0.3*cx, 0.2*cy, "Begin") self.button.draw(self.canvas) def draw_toolbar(self): """Toolbar for main animation""" self.toolbar.create_text(self.cx, 0.1*self.cy, text="INFECTION", font=("Impact", 32)) self.toolbar.create_text(self.cx*0.05, 0.1*self.cy, text="Total Infection: Click User", font=("Impact", 20), anchor="w") self.toolbar.create_text(self.cx*1.8, 0.1*self.cy, text="Limited Infection", font=("Impact", 20), anchor="e") self.limited_entry = Entry(self.toolbar, justify=CENTER, width=3) self.toolbar.create_window(self.cx*1.85, 0.1*self.cy, window=self.limited_entry) self.limited_entry.insert(0, str(self.default_users//2)) cx, cy = self.cx*1.95, self.margin*0.35 r = self.margin/5 self.limited_button = (cx, cy, r) self.toolbar.create_oval((cx-r, cy-r, cx+r, cy+r), width=2, fill="RED") self.toolbar.create_text(cx, cy, text="X", font=("Courier Bold", 30)) side = self.width/self.versions self.side = side y = 50 self.gradient = (y, y+side) for col in range(int(self.versions)): fill = self.get_fill(col) width = 2 if col == self.version else 0 self.toolbar.create_rectangle(col*side, y, (col+1)*side, y+side, fill=fill, width=width) self.select_version() def redraw_all(self): """Refresh frame for infection animation""" self.canvas.delete(ALL) # Draw connections first so circles get drawn on top of lines self.draw_connections() self.draw_users() def init_users(self): """Initializes list of VisualUser objects from users""" for user in self.raw_users: self.users.append(VisualUser(user, self)) def update_locations(self): """Update locations of all users""" for user in self.users: user.update_location() def get_fill(self, v): """ Convert version number into RGB hex value Creates gradient covering range of colors """ if v is None: return "white" b = 0 quarter = self.versions/4 if v < quarter: # Red -> Yellow r = 255 g = int(255*min((v/quarter), 1)) elif quarter <= v < 2*quarter: # Yellow -> Green r = int(255*max(0, (1-(v-quarter)/quarter))) g = 255 elif 2*quarter <= v < 3*quarter: # Green -> Blue r = 0 g = int(255*max(0, (1-(v-2*quarter)/quarter))) b = int(255*min(((v-2*quarter)/quarter), 1)) else: # Blue -> Purple g = 0 r = int(255*min(((v-3*quarter)/quarter), 1)) b = 255 return "#{:02x}{:02x}{:02x}".format(r, g, b) def draw_random_point(self): """Draw randomly colored point on screen""" fill = self.get_fill(self.start_counter % 100) self.start_counter += 1 x = random.randint(0, self.width) y = random.randint(0, self.height) self.canvas.create_rectangle(x, y, x+2, y+2, width=0, fill=fill) def timer_fired(self): """Called every frame refresh""" if self.mode == Mode.START: for _ in range(10): self.draw_random_point() if self.mode == Mode.MAIN and not self.paused: self.update_locations() self.redraw_all() def timer(self): """Setup timer loop""" self.timer_fired() self.canvas.after(self.timer_delay, self.timer) def init_animation(self): """Initialize or reset animation""" self.users = [] self.timer_delay = 100 self.start_counter = 0 self.versions = 40 self.default_users = 20 self.default_coaches = 5 self.default_students = 5 self.max_users = 100 self.version = None self.paused = False self.mode = Mode.START self.draw_start_screen() self.error_text = None self.error_font_size = 20 self.version_select = None self.timer() def start_infection(self): """Initialize users and start infections""" num_users_text = self.num_users_entry.get() num_coaches_text = self.num_coaches_entry.get() num_students_text = self.num_students_entry.get() try: error = "Invalid Number of Users" num_users = int(num_users_text) if not (1 <= num_users <= self.max_users): raise ValueError num_coaches = int(num_coaches_text) error = "Invalid Number of Coaches" if not (1 <= num_coaches <= num_users): raise ValueError error = "Invalid Number of Students" num_students = int(num_students_text) if not (1 <= num_students <= num_users): raise ValueError except ValueError: if self.error_text: self.canvas.delete(self.error_text) self.error_text = \ self.canvas.create_text(self.cx, 0.2*self.cy, text=error, font=("Impact", self.error_font_size)) self.error_font_size += 2 return self.infection = Infection(num_users=num_users, num_coaches=num_coaches, students=(1, num_students)) self.num_users = num_users self.num_coaches = num_coaches self.num_students = num_students self.raw_users = self.infection.network.users self.init_users() self.draw_toolbar() self.mode = Mode.MAIN def limited_infection(self): size_text = self.limited_entry.get() try: size = int(size_text) if not (1 <= size <= self.num_users): raise ValueError except ValueError: print("Bad input") # TODO: display to user return self.infection.limited_infection(size, self.version) print("Limited infection of size", size, self.num_users) def select_version(self): if self.version_select: # Erase old selection self.toolbar.delete(self.version_select) if self.version is None: return y0, y1 = self.gradient x0, x1 = self.version*self.side, (self.version + 1)*self.side self.version_select = \ self.toolbar.create_rectangle(x0, y0, x1, y1, width="2") def mouse_event(self, e): """Process click event""" x, y = e.x, e.y if self.mode == Mode.SETUP: if self.button.clicked(x, y): self.start_infection() if self.mode == Mode.MAIN: cx, cy, r = self.limited_button if distance(cx, cy, x, y) < r: self.limited_infection() elif self.gradient[0] <= y <= self.gradient[1]: print("gradient bar", x) self.version = int(x / self.side) print(self.versions, self.version) self.select_version() else: for user in self.users: if user.clicked(x, y): print("user clicked", user) user.infect() break def key_event(self, e): """Process keyboard event""" if e.keysym == 'r': self.init_animation() self.paused = False elif e.keysym == 'p': self.paused = not self.paused elif e.keysym == 's' and self.mode == Mode.START: self.mode = Mode.SETUP self.draw_setup_screen() elif e.keysym == 'b' and self.mode == Mode.SETUP: self.start_infection() elif e.keysym == 'q': self.root.destroy()
class Gem: def __init__(self): self.frame = Tk(); self.frame.resizable(False, False) self.status = 1 self.scorePlayerA = 0 self.scorePlayerB = 0 self.scoreRoundA = 0 self.scoreRoundB = 0 self.countRound = 0 self.quitMatch = 0 self.isQuitRound = 0 self.canvas_after_2 = 0 self.canvas_after_1 = 0 self.isPause = 0 #register event self.frame.bind("<F4>", self.quitGame) self.frame.bind("<F5>", self.pauseGame) self.frame.protocol("WM_DELETE_WINDOW", self.on_closing) self.registerKeyboard() def setName(self, title): self.frame.title(title) def setBall(self, ball): self.ball = ball def setLeftBar(self, bar): self.leftBar = bar def setRightBar(self, bar): self.rightBar = bar def run(self): self.frame.mainloop() def getFrame(self): return self.frame; def getCanvas(self): return self.canvas def setSize(self, size): self.frame.geometry(("%dx%d")%(size[0], size[1])) self.frame.update() def getSize(self): return (self.frame.winfo_width(), self.frame.winfo_height()) def setBackground(self, color): self.background = color def setPlayers(self, players): self.players = players def setScoreBoard(self): players = self.players size = self.getSize() mid = round(size[0]/2) # Board self.canvas.create_rectangle(mid - 100, 0, mid + 100, 35, fill="grey58", outline="white", tag="boarda") # Player name 1 self.canvas.create_text(mid - 80, 15, text=players[0], fill="magenta2", tag="boardb") # Round score 1 r1 = players[0]+"a" self.canvas.create_text(mid - 80, 28, text="0", fill="pale green", tag="scoreplayera") # Player name 2 self.canvas.create_text(mid + 80, 15, text=players[1], fill="magenta2", tag="boardc") # Round score 2 self.canvas.create_text(mid + 80, 28, text="0", fill="pale green", tag="scoreplayerb") # Box score 1 self.canvas.create_rectangle(mid - 50, 5, mid - 10, 25, fill="thistle3", outline="white", tag="boardd") # Score 1 self.canvas.create_text(mid - 30, 15, text="000", fill="cyan", tag=players[0]) # Box score 2 self.canvas.create_rectangle(mid + 10, 5, mid + 50, 25, fill="thistle3", outline="white", tag="boarde") # Score 2 self.canvas.create_text(mid + 30, 15, text="000", fill="cyan", tag=players[1]) self.canvas.pack() self.frame.update() def clearScoreBoard(self): self.canvas.delete(self.players[0]) self.canvas.delete(self.players[1]) self.canvas.delete("boarda") self.canvas.delete("boardb") self.canvas.delete("boardc") self.canvas.delete("boardd") self.canvas.delete("boarde") self.canvas.delete("scoreplayera") self.canvas.delete("scoreplayerb") self.canvas.update() def initCanvas(self): canvas_width = self.frame.winfo_width() canvas_height = self.frame.winfo_height() self.canvas = Canvas(self.frame, width=canvas_width, height=canvas_height, bg=self.background) self.frame.update() def setDashboard(self): size = self.getSize(); midw = round(size[0]/2) midh = round(size[1]/2) self.canvas.create_oval(midw - 120, midh - 70, midw + 120, midh+70, fill="alice blue", outline="white", tag="dash1") self.canvas.create_text(midw, midh - 35, text="F1: Machine Vs Machine", fill="blue violet", tag="dash2") self.canvas.create_text(midw, midh - 10, text="F2: Human Vs Machine ", fill="blue violet", tag="dash3") self.canvas.create_text(midw, midh + 15, text="F3: Human Vs Human ", fill="blue violet", tag="dash4") self.canvas.create_text(midw, midh + 38, text="F4: Quit Game ", fill="blue violet", tag="dash5") self.canvas.pack() def clearDashboard(self): self.canvas.delete("dash1") self.canvas.delete("dash2") self.canvas.delete("dash3") self.canvas.delete("dash4") self.canvas.delete("dash5") self.canvas.update() def setWinter(self, status = -1): size = self.getSize(); midw = round(size[0]/2) midh = round(size[1]/2) if status == 1: textstr = self.players[0] + " Win" elif status == 2: textstr = self.players[1] + " Win" elif self == 3 and self.scorePlayerA != self.scorePlayerB: if self.scoreRoundB > self.scorePlayerA: textstr = self.players[1] + " Win" else: textstr = self.players[0] + " Win" else: textstr = "Not Match" self.canvas.create_oval(midw - 50, midh - 20, midw + 50, midh+20, fill="alice blue", outline="white", tag="wintera") self.canvas.create_text(midw, midh, text=textstr, fill="blue violet", tag="winterb") self.canvas.pack() self.canvas.update(); def clearWinter(self): self.canvas.delete("wintera") self.canvas.delete("winterb") self.canvas.update() def quitRound(self, status): if self.scorePlayerA >= self.maxRoundScore and self.scorePlayerB >= self.maxRoundScore: self.isQuitRound = 1 if status == 1 or status == 2 or self.isQuitRound == 1 or self.quitMatch == 1: if self.isQuitRound == 0: self.updateScoreRound(status - 1) self.isQuitRound = 1 self.ball.quit(self.canvas) self.leftBar.quit(self.canvas) self.rightBar.quit(self.canvas) return self.isQuitRound def nextRound(self, status): self.canvas.after_cancel(self.canvas_after_2) if status == 2 or status == 1: if self.maxRound > self.countRound: #self.ball.quit(self.canvas) #self.leftBar.quit(self.canvas) #self.rightBar.quit(self.canvas) self.resetRound() self.countRound += 1 self.leftBar.reset(self.canvas) self.rightBar.reset(self.canvas) if status == 1: self.leftBar.transferBall(self.canvas, self.ball) else: self.leftBar.transferBall(self.canvas, self.ball) #print(self.canvas.find_withtag(self.ball.name)) else: self.stopMatch() def play(self, event): self.clearDashboard() self.unRegisterKeyboard() if event.keycode == 112: self.isPause = 4 self.startMatch() self.machineVSmachine() elif event.keycode == 113: self.isPause = 5 self.leftBar.registerKeyboard(self.frame) self.startMatch() self.machineVShuman() elif event.keycode == 114: self.isPause = 6 self.leftBar.registerKeyboard(self.frame) self.rightBar.registerKeyboard(self.frame) self.startMatch() self.humanVShuman() def machineVSmachine(self): try: if self.ball.exists == False: self.isQuitRound = 0 if self.isQuitRound == 0: rs = self.ball.move(self.canvas) self.leftBar.autoMove(self.canvas) self.rightBar.autoMove(self.canvas) rs = self.update(rs) if rs == 1: return ; self.canvas_after_1 = self.canvas.after(10, self.machineVSmachine) except: print("I am so sorry!") self.stopMatch(0) def machineVShuman(self): try: if self.ball.exists == False: self.isQuitRound = 0 if self.isQuitRound == 0: rs = self.ball.move(self.canvas) self.leftBar.move(self.canvas) self.rightBar.autoMove(self.canvas) rs = self.update(rs) if rs == 1: return ; self.canvas_after_1 = self.canvas.after(10, self.machineVShuman) except: print("I am so sorry!") self.stopMatch(0) def humanVShuman(self): try: if self.ball.exists == False: self.isQuitRound = 0 if self.isQuitRound == 0: rs = self.ball.move(self.canvas) self.leftBar.move(self.canvas) self.rightBar.move(self.canvas) rs = self.update(rs) if rs == 1: return ; self.canvas_after_1 = self.canvas.after(10, self.humanVShuman) except: print("I am so sorry!") self.stopMatch(0) def startMatch(self): self.setScoreBoard() self.quitMatch = 0 self.isQuitRound = 0 self.countRound = 0 self.nextRound(1) def resetRound(self): self.scorePlayerA = 0 self.scorePlayerB = 0 self.isQuitRound = 0 self.updateScorePlayer() self.leftBar.registerKeyboard(self.frame) self.rightBar.registerKeyboard(self.frame) def update(self, status): self.updateScorePlayer(status-3) self.canvas.update() if self.quitRound(status) == 1 and self.quitMatch == 0: self.leftBar.unRegisterKeyboard(self.frame) self.rightBar.unRegisterKeyboard(self.frame) self.canvas_after_2 = self.canvas.after(800, self.nextRound, status) if self.quitMatch == 1: self.leftBar.unRegisterKeyboard(self.frame) self.rightBar.unRegisterKeyboard(self.frame) self.isQuitRound == 1 return self.quitMatch def updateScoreRound(self, status): if self.scorePlayerB == 0 and self.scorePlayerA == 0: return if status == 0: self.scoreRoundA += 1 self.canvas.itemconfig("scoreplayera", text=self.scoreRoundA) elif status == 1: self.scoreRoundB += 1 self.canvas.itemconfig("scoreplayerb", text=self.scoreRoundB) def updateScorePlayer(self, status = 5): if status == 0: self.scorePlayerA += 1 self.canvas.itemconfig(self.players[0], text=self.__countScore(self.scorePlayerA)) if self.scorePlayerA != 0 and self.scorePlayerA % 5 == 0: self.ball.speed +=1 elif status == 1: self.scorePlayerB += 1 self.canvas.itemconfig(self.players[1], text=self.__countScore(self.scorePlayerB)) elif status == 5: self.canvas.itemconfig(self.players[0], text=self.__countScore(self.scorePlayerA)) self.canvas.itemconfig(self.players[1], text=self.__countScore(self.scorePlayerB)) self.canvas.update() def __countScore(self, score): if score < 10: scorestr = "00" + str(score); elif score < 100: scorestr = "0" + str(score) else: scorestr = str(score) return scorestr def stopMatch(self, event = 0): self.isQuitRound = 1 self.quitMatch = 1 self.leftBar.unRegisterKeyboard(self.frame) self.rightBar.unRegisterKeyboard(self.frame) self.canvas.after_cancel(self.canvas_after_1); self.canvas_after_3 = self.canvas.after(500, self.returnMenu) def quitGame(self, event): self.isQuitRound = 1 self.quitMatch = 1 self.leftBar.unRegisterKeyboard(self.frame) self.rightBar.unRegisterKeyboard(self.frame) self.canvas.after_cancel(self.canvas_after_1); self.canvas_after_3 = self.canvas.after(200, self.destroy) def destroy(self): self.canvas.after_cancel(self.canvas_after_3) self.frame.destroy() def returnMenu(self): self.canvas.after_cancel(self.canvas_after_3) self.ball.quit(self.canvas) self.leftBar.quit(self.canvas) self.rightBar.quit(self.canvas) self.clearScoreBoard() self.clearWinter() self.setDashboard() self.registerKeyboard() def setMaxRound(self, max): self.maxRound = max def setMaxRoundScore(self, max): self.maxRoundScore = max def registerKeyboard(self): self.frame.bind("<F1>", self.play) self.frame.bind("<F2>", self.play) self.frame.bind("<F3>", self.play) self.frame.unbind("<Escape>") def unRegisterKeyboard(self): self.frame.unbind("<F1>") self.frame.unbind("<F2>") self.frame.unbind("<F3>") self.frame.bind("<Escape>", self.stopMatch) def on_closing(self): self.quitGame(0) def pauseGame(self, event): if self.isPause == 1: self.isPause += 3 self.machineVSmachine() elif self.isPause == 2: self.isPause += 3 self.machineVShuman() elif self.isPause == 3: self.isPause += 3 self.humanVShuman() elif self.isPause > 3: self.canvas.after_cancel(self.canvas_after_1) self.isPause -= 3
class Painter: def __init__( self, root, width=800, height=600, offset=5, min_radius=5, max_radius=10, num_balls=20, refresh_speed=5 ): # Draw frame etc self.app_frame = Frame(root) self.app_frame.pack() self.canvas = Canvas(self.app_frame, width=width, height=height) self.canvas_size = (int(self.canvas.cget("width")), int(self.canvas.cget("height"))) self.canvas.pack() self.refresh_speed = refresh_speed # Work area self.min_x = offset self.max_x = width - offset self.min_y = offset self.max_y = height - offset self.num_balls = num_balls self.balls = [] self.ball_handles = dict() self.init_balls(max_radius, min_radius, num_balls) self.time = 0 self.wall_collision_times = np.zeros(num_balls) self.init_wall_collision_times() self.ball_collision_times = np.zeros((num_balls, num_balls)) self.init_ball_collision_times() self.draw() self.refresh() return def init_balls(self, max_radius, min_radius, num_balls): for i in np.arange(num_balls): while True: radius = (max_radius - min_radius) * rand.random_sample() + min_radius ball_min_x = self.min_x + radius ball_max_x = self.max_x - radius x = (ball_max_x - ball_min_x) * rand.random_sample() + ball_min_x ball_min_y = self.min_y + radius ball_max_y = self.max_y - radius y = (ball_max_y - ball_min_y) * rand.random_sample() + ball_min_y vx = rand.random_sample() vy = rand.random_sample() mass = rand.random_sample() new_ball = Ball(radius, x, y, vx, vy, mass) if not new_ball.check_overlap(self.balls): self.balls.append(new_ball) break def draw(self): # Draw walls self.canvas.create_line((self.min_x, self.min_y), (self.min_x, self.max_y), fill="red") self.canvas.create_line((self.min_x, self.min_y), (self.max_x, self.min_y), fill="red") self.canvas.create_line((self.min_x, self.max_y), (self.max_x, self.max_y), fill="red") self.canvas.create_line((self.max_x, self.min_y), (self.max_x, self.max_y), fill="red") # Draw balls for b in self.balls: obj = self.canvas.create_oval(b.x - b.radius, b.y - b.radius, b.x + b.radius, b.y + b.radius) self.ball_handles[b] = obj self.canvas.update() def next_wall_collision_idx(self): collided = [] for i in np.arange(self.num_balls): if self.wall_collision_times[i] <= self.time: collided.append(i) return collided def next_ball_collision_idx(self): min_i = 0 min_j = 0 collided = [] # min_tij = float('inf') for i in np.arange(self.num_balls): for j in np.arange(i, self.num_balls): tij = self.ball_collision_times[i][j] if tij <= self.time: collided.append((i, j)) return collided # CODE YOU NEED TO IMPLEMENT def init_wall_collision_times(self): for i in np.arange(self.num_balls): self.wall_collision_times[i] = self.balls[i].compute_wall_collision_time( self, self.min_x, self.max_x, self.min_y, self.max_y ) # def update_wall_collision_time(self, i): # def init_ball_collision_times(self): for i in np.arange(self.num_balls): for j in np.arange(self.num_balls): self.ball_collision_times[i] = self.balls[i].compute_ball_collision_time(self, other) # # def update_ball_collision_time(self, i): # Do not update this def refresh(self): wall_i = self.next_wall_collision_idx() ball_i = self.next_ball_collision_idx() # print wall_i, ball_i for i in wall_i: bi = self.balls[i] old_x = bi.x old_y = bi.y bi.collide_with_wall(self.min_x, self.max_x, self.min_y, self.max_y) self.canvas.move(self.ball_handles[bi], bi.x - old_x, bi.y - old_y) for (i, j) in ball_i: bi = self.balls[i] bj = self.balls[j] bi.collide_with_ball(bj) collided = wall_i for (i, j) in ball_i: collided.append(i) collided.append(j) collided = set(collided) # print collided for i in collided: self.update_ball_collision_time(i) self.update_wall_collision_time(i) not_collided = set(np.arange(self.num_balls)) - collided for i in not_collided: bi = self.balls[i] old_x = bi.x old_y = bi.y bi.move() self.canvas.move(self.ball_handles[bi], bi.x - old_x, bi.y - old_y) self.time += 1 self.canvas.update() self.canvas.after(self.refresh_speed, self.refresh) # Calls the function again
can.delete(line1[int(y/50)]) can.delete(line2[int(y/50)]) line1[int(y/50)] = [can.create_line(pos1, fill='#000')] line2[int(y/50)] = [can.create_line(pos2, fill='#f00', dash=(3, 2))] can.update() """ 본문 캔버스를 선언하고 원과 선들을 초기화 """ master = Tk() can = Canvas(master, width=500, height=500) obj = can.create_oval(240, 240, 260, 260, fill='#aafcdf') can.pack() # 라인 초기화 line1 = [can.create_line(0, 0, 1, 1)]*11 line2 = [can.create_line(0, 0, 1, 1)]*11 # 애니메이션 구동 can.after(0, web) onTarget = False # bind: 미리 정해져 있는 입력에 따라서 함수를 실행 # 사용자의 드래그 동작은 클릭과 클릭한 후 이동으로 구성되어 있다. can.bind('<Button-1>', onClick) can.bind('<B1-Motion>', onDrag) master.mainloop()
len(population.cars[population.max_fit_car].brain.connections)) # print("Connections checkpoints:", population.cars[population.max_fit_car].checkpoints) print("Reproducing...") population.reproduction() print("Species: ", population.neat.species) print("Garbage collecting") gc.collect() print(len(population.neat.neurons)) print(len(population.neat.connections)) print("--------------------------------------------------------") print(f"Starting generation {generation}!") time = 0 if step % 10 == 0: time = 1 canvas.after(time, update) if __name__ == "__main__": window = Tk() canvas = Canvas(window) for w in route_walls: canvas.create_line(w.x1, w.y1, w.x2, w.y2) for w in checkpoints: canvas.create_line(w.x1, w.y1, w.x2, w.y2, fill="green") canvas.pack(fill=BOTH, expand=1) canvas.after(1000, update) window.mainloop() # Possible futura GUI amb tkinter
class SearchFrame: def __init__(self, logicManger, root): self.logicManager = logicManger # images setup self.backgroundImg = None self.connectImg = None self.backImg = None self.initPictures() # frame setup self.frame = None self.clients_list = None self.connect_button = None self.back_button = None self.timeUpdateMobileList = 1000 # in ms self.initFrame(root) def initPictures(self): self.backgroundImg = getPhoto('\\img\\ConnectScreen.png') self.connectImg = getPhoto('\\img\\MouseButton.png') self.backImg = getPhoto('\\img\\BackButton.png') def initFrame(self, root): self.frame = Canvas(root, bg=DARK_BLUE) self.frame.create_image(0, 0, anchor=NW, image=self.backgroundImg) self.frame.pack(expand="true", fill="both") padyClients = (200, 0) padyButtons = 4 padx = (35, 0) y_grid = 0 y_grid = self.initClients(self.frame, y_grid, padyClients, padx) self.initButtons(self.frame, y_grid, 0, padx, padyButtons) self.frame.after(self.timeUpdateMobileList, self.addClient) def initClients(self, frame, y_grid, pady, padx): rapper_frame = Frame(frame, bg=GRAY_BLUE) rapper_frame.grid(row=y_grid, column=0, rowspan=1, columnspan=4, padx=padx, pady=pady) label = Label(rapper_frame, text='Select your Smartphone', width=23, font=("Calibri", 14), bg=DARK_GRAY_BLUE, fg=WHITE) label.pack(side="top") self.clients_list = Listbox(rapper_frame, width=25, height=9, bd=0, font=("Calibri", 12)) # set the listbox contains func self.clients_list.contains = lambda x: x in self.clients_list.get( 0, "end") self.clients_list.pack(side="left", fill="y", padx=(2, 0), pady=2) scrollbar = Scrollbar(rapper_frame, orient="vertical") scrollbar.config(command=self.clients_list.yview) scrollbar.pack(side="right", fill="y", padx=(0, 2), pady=2) self.clients_list.config(yscrollcommand=scrollbar.set) return y_grid + 1 def initButtons(self, frame, y_grid, x_grid, padx, pady): self.connect_button = Button(frame, image=self.connectImg, bg=GRAY, font=SMALL_BUTTON_FONT) self.connect_button.grid(row=y_grid, column=x_grid, rowspan=1, padx=padx, pady=pady) x_grid = x_grid + 3 self.back_button = Button(frame, image=self.backImg, bg=GRAY, font=SMALL_BUTTON_FONT) self.back_button.grid(row=y_grid, column=x_grid, rowspan=1, padx=5, pady=pady) def setBackButtonFunction(self, func): self.back_button["command"] = func def setConnectionSelectFunction(self, func): def select(): index = self.clients_list.curselection() connection = self.clients_list.get(index) # empty tuple whike return false if connection: func(connection) self.connect_button["command"] = select def addClient(self): connections = self.logicManager.getConnections() for connection in connections.values(): if not self.clients_list.contains(connection): index = self.clients_list.size() self.clients_list.insert(index, str(connection)) self.frame.after(self.timeUpdateMobileList, self.addClient) def hideFrame(self): self.frame.pack_forget()
class Painter: #__init__ performs the construction of a Painter object def __init__(self, root, scale=500, border=5, refresh_speed=5, filename='balls.txt', min_radius=5, max_radius=10, num_balls=20): #width and height are used to set the simulation borders width = scale + border height = scale + border #Time is the time stamp for the simulation; it is set to 0 to indicate the beginning of the simulation self.time = 0 #setup will set up the necessary graphics window and the ball list self.setup(root, width, height, border, refresh_speed) #Check the input parameter 'filename' to load predetermined simulation #otherwise set up the default simulation if filename is None: self.init_balls(max_radius, min_radius, num_balls) self.num_balls = num_balls else: self.num_balls = self.read_balls(scale, filename) #Create the priority data structure self.PQ = ArrayPQ(self.num_balls) #Initialize all possible collision times self.init_ball_collision_times() self.init_wall_collision_times() #draw will draw the graphics to the window self.draw() #refresh is a loop method intended to create animations self.refresh() #A blank return indicates the end of the function return #setup creates the window to display the graphics along with the red border #of the simulation def setup(self, root, width, height, border, refresh_speed): # Draw frame etc self.app_frame = Frame(root) self.app_frame.pack() self.canvas = Canvas(self.app_frame, width=width, height=height) self.canvas_size = (int(self.canvas.cget('width')), int(self.canvas.cget('height'))) self.canvas.pack() self.refresh_speed = refresh_speed # Work area self.min_x = border self.max_x = width - border self.min_y = border self.max_y = height - border #create array to hold the n number of balls self.balls = [] self.ball_handles = dict() return #This function reads in predefined ball numbers and locations to implement predetermined simulations def read_balls(self, scale, filename): f = open(filename) num_balls = int(f.readline().strip()) for l in f: ll = l.strip().split(" ") x = scale * float(ll[0]) y = scale * float(ll[1]) vx = scale * float(ll[2]) vy = scale * float(ll[3]) radius = scale * float(ll[4]) mass = float(ll[5]) r = int(ll[6]) g = int(ll[7]) b = int(ll[8]) tk_rgb = "#%02x%02x%02x" % (r, g, b) new_ball = Ball(radius, x, y, vx, vy, mass, tk_rgb) self.balls.append(new_ball) return num_balls #init_balls will create an array of size "num_balls" stored within self.balls def init_balls(self, max_radius, min_radius, num_balls): for i in np.arange(num_balls): while (True): radius = (max_radius - min_radius) * rand.random_sample() + min_radius ball_min_x = self.min_x + radius ball_max_x = self.max_x - radius x = (ball_max_x - ball_min_x) * rand.random_sample() + ball_min_x ball_min_y = self.min_y + radius ball_max_y = self.max_y - radius y = (ball_max_y - ball_min_y) * rand.random_sample() + ball_min_y vx = rand.random_sample() vy = rand.random_sample() mass = 1.0 # rand.random_sample() new_ball = Ball(radius, x, y, vx, vy, mass) if not new_ball.check_overlap(self.balls): self.balls.append(new_ball) break #init_wall_collision_times will set all of the balls' minimum collision time #for both horizontal and vertical walls and store that time in their respective arrays def init_wall_collision_times(self): for i in np.arange(len(self.balls)): bi = self.balls[i] tix = bi.horizontal_wall_collision_time(self.min_x, self.max_x) tiy = bi.vertical_wall_collision_time(self.min_y, self.max_y) self.PQ.insert(i, -1, tix + self.time, self.balls[i].count, -1) self.PQ.insert(-1, i, tiy + self.time, -1, self.balls[i].count) return #init_ball_collision_times will set all of the balls' minimum collision time #with all other balls and store that time within the ith and jth index of #PQ.ball_collision_time def init_ball_collision_times(self): for i in np.arange(self.num_balls): bi = self.balls[i] for j in np.arange(i + 1, self.num_balls): bj = self.balls[j] tij = bi.ball_collision_time(bj) self.PQ.insert(i, j, tij + self.time, self.balls[i].count, self.balls[j].count) # self.ball_collision_times[i][j] = tij # self.ball_collision_times[j][i] = tij return #update collision times is meant to update collision times of ball i with all #walls (horizontal and vertical) and all other balls within the PQ array def update_collision_times(self, i): bi = self.balls[i] tix = bi.horizontal_wall_collision_time(self.min_x, self.max_x) tiy = bi.vertical_wall_collision_time(self.min_y, self.max_y) self.PQ.insert(i, -1, tix + self.time, self.balls[i].count, -1) self.PQ.insert(-1, i, tiy + self.time, -1, self.balls[i].count) for j in np.arange(self.num_balls): bj = self.balls[j] tij = bi.ball_collision_time(bj) + self.time if i > j: self.PQ.insert(j, i, tij, self.balls[j].count, self.balls[i].count) else: self.PQ.insert(i, j, tij, self.balls[i].count, self.balls[j].count) return #draw will draw the borders and all balls within self.balls def draw(self): #Draw walls self.canvas.create_line((self.min_x, self.min_y), (self.min_x, self.max_y), fill="red") self.canvas.create_line((self.min_x, self.min_y), (self.max_x, self.min_y), fill="red") self.canvas.create_line((self.min_x, self.max_y), (self.max_x, self.max_y), fill="red") self.canvas.create_line((self.max_x, self.min_y), (self.max_x, self.max_y), fill="red") #Draw balls for b in self.balls: obj = self.canvas.create_oval(b.x - b.radius, b.y - b.radius, b.x + b.radius, b.y + b.radius, outline=b.tk_rgb, fill=b.tk_rgb) self.ball_handles[b] = obj self.canvas.update() #refresh is called to update the state of the simulation #-each refresh call can be considered one iteration of the simulation #-all balls will be moved and if there is a collision then it will be computed def refresh(self): #get the next collision i, j, t, num_collisions_i, num_collision_j = self.PQ.get_next() #gather the current collisions of the ith and jth ball current_collisions_i = self.balls[i].count current_collisions_j = self.balls[j].count #Check the difference in time between the predicted collision time and #the current time stamp of the simulation delta = t - self.time #If the difference is greater than 1, then just move the balls if delta > 1.0: # cap delta to 1.0 for bi in self.balls: bi.move() self.canvas.move(self.ball_handles[bi], bi.vx, bi.vy) self.time += 1.0 #Otherwise a collision has occurred else: #Move all balls for bi in self.balls: bi.move(delta) self.canvas.move(self.ball_handles[bi], bi.vx * delta, bi.vy * delta) #increment the simulation time stamp self.time += delta #Delete the top element within the Priority Queue self.PQ.delete() #if i is -1 then this indicates a collision with a vertical wall #also this if statement checks if the number of collisions recorded #when the collision returned by PQ.get_next() is equal to the #number of collisions within the jth ball #this acts as a test to check if the collision is still valid if i == -1 and num_collision_j == current_collisions_j: #compute what happens from the vertical wall collision self.balls[j].collide_with_vertical_wall() #update collision times for the jth ball self.update_collision_times(j) #if j is -1 then this indicates a collision a horizontal wall #while also checking if the number of collisions match #to see if the collision is valid elif j == -1 and num_collisions_i == current_collisions_i: #compute what happens from the horizontal wall collision self.balls[i].collide_with_horizontal_wall() #update collision times for the ith ball self.update_collision_times(i) #Otherwise i and j are not equal to -1 indicating that the collision is between two balls #check if no collisions have occurred between both balls before the collision returned from PQ.get_next #if true then this means that the collision is still valid and must be executed elif num_collision_j == current_collisions_j and num_collisions_i == current_collisions_i: #Execute collision across the ith and jth ball self.balls[i].collide_with_ball(self.balls[j]) #update collision times for both the ith and jth ball self.update_collision_times(i) self.update_collision_times(j) #update the canvas to draw the new locations of each ball self.canvas.update() self.canvas.after(self.refresh_speed, self.refresh) #Calls the function again
class Graphics: """ Wraps tk graphics primitives to make graphics concepts easier for beginners. """ def __init__(self, w, h): self.tk = Tk() self.width = w self.height = h self.canvas = Canvas(self.tk, width=self.width, height=self.height) self.canvas.pack() def circle(self, center, radius, **kwargs): x, y = center self.checkbounds([(x - radius, y - radius), (x + radius, y + radius)]) return self.canvas.create_oval(x - radius, y - radius, x + radius, y + radius, kwargs) def show_grid(self, size=50, color='black'): w = self.width # Get current width of canvas h = self.height # Get current height of canvas # Creates all vertical lines at intevals of 100 for i in range(0, w + size, size): self.line((i, 0), (i, h), fill=color, tag='grid_line') label = Label(self.canvas, text=str(i), fg='red') x_off = 0 if i > 0: x_off = 15 if i == w: print("w....") x_off = 25 label.place(x=i - x_off, y=0) # Creates all horizontal lines at intevals of 100 for i in range(0, h + size, size): label = Label(self.canvas, text=str(i), fg='red') y_off = 0 if i > 0: y_off = 15 if i == h: y_off = 20 label.place(x=0, y=i - y_off) self.line((0, i), (w, i), fill=color, tag='grid_line') def hide_grid(self): self.canvas.delete('grid_line') def rectangle(self, topleft, bottomright, **kwargs): self.checkbounds([topleft, bottomright]) xmin, ymin, xmax, ymax = extent([topleft, bottomright]) return self.canvas.create_rectangle(xmin, ymin, xmax, ymax, kwargs) def polygon(self, points, **kwargs): self.checkbounds(points) return self.canvas.create_polygon(points, kwargs) def line(self, a, b, **kwargs): self.checkbounds([a, b]) xmin, ymin, xmax, ymax = extent([a, b]) return self.canvas.create_line(xmin, ymin, xmax, ymax, kwargs) def coords(self, obj, *args): points = self.canvas.coords(obj, *args) coords = [] for i in range(0, len(points), 2): coords.append((points[i], points[i + 1])) return coords def move(self, obj, delta): self.canvas.move(obj, delta[0], delta[1]) def update(self, after=20): self.canvas.update() self.canvas.after(after) def show(self): self.tk.mainloop() def checkbounds(self, points): xmin, ymin, xmax, ymax = extent(points) if xmax > self.width: print( "WARNING:The shape extends beyond the canvas: x=%d is greater than canvas width %d" % (xmax, self.width)) if xmin < 0: print("WARNING: The minimum boundary x=%d cannot be less than 0" % xmin) if ymax > self.height: print( "WARNING:The shape extends beyond the canvas: y=%d is greater than window height %d " % (ymax, self.height)) if ymin < 0: print("WARNING: The minimum boundary y=%d cannot be less than 0" % ymin)
class Painter: #__init__ performs the construction of a Painter object def __init__(self, root, scale=500, border=5, refresh_speed=5, filename='balls.txt', min_radius=5, max_radius=10, num_balls=20): #width and height are used to set the simulation borders width = scale + border height = scale + border #Time is the time stamp for the simulation; it is set to 0 to indicate the beginning of the simulation self.time = 0 #setup will set up the necessary graphics window and the ball list self.setup(root, width, height, border, refresh_speed) #Check the input parameter 'filename' to load predetermined simulation #otherwise set up the default simulation if filename is None: self.init_balls(max_radius, min_radius, num_balls) self.num_balls = num_balls else: self.num_balls = self.read_balls(scale, filename) #Create the priority data structure self.PQ = ArrayPQ(self.num_balls) #Initialize all possible collision times self.init_ball_collision_times() self.init_wall_collision_times() #draw will draw the graphics to the window self.draw() #refresh is a loop method intended to create animations self.refresh() #A blank return indicates the end of the function return #setup creates the window to display the graphics along with the red border #of the simulation def setup(self, root, width, height, border, refresh_speed): # Draw frame etc self.app_frame = Frame(root) self.app_frame.pack() self.canvas = Canvas(self.app_frame, width = width, height = height) self.canvas_size = (int(self.canvas.cget('width')), int(self.canvas.cget('height'))) self.canvas.pack() self.refresh_speed = refresh_speed # Work area self.min_x = border self.max_x = width - border self.min_y = border self.max_y = height - border #create array to hold the n number of balls self.balls = [] self.ball_handles = dict() return #This function reads in predefined ball numbers and locations to implement predetermined simulations def read_balls(self, scale, filename): f = open(filename) num_balls = int(f.readline().strip()) for l in f: ll = l.strip().split(" ") x = scale*float(ll[0]) y = scale*float(ll[1]) vx = scale*float(ll[2]) vy = scale*float(ll[3]) radius = scale*float(ll[4]) mass = float(ll[5]) r = int(ll[6]) g = int(ll[7]) b = int(ll[8]) tk_rgb = "#%02x%02x%02x" % (r, g, b) new_ball = Ball(radius, x, y, vx, vy, mass, tk_rgb) self.balls.append(new_ball) return num_balls #init_balls will create an array of size "num_balls" stored within self.balls def init_balls(self, max_radius, min_radius, num_balls): for i in np.arange(num_balls): while(True): radius = (max_radius - min_radius) * rand.random_sample() + min_radius ball_min_x = self.min_x + radius ball_max_x = self.max_x - radius x = (ball_max_x - ball_min_x)*rand.random_sample() + ball_min_x ball_min_y = self.min_y + radius ball_max_y = self.max_y - radius y = (ball_max_y - ball_min_y)*rand.random_sample() + ball_min_y vx = rand.random_sample() vy = rand.random_sample() mass = 1.0 # rand.random_sample() new_ball = Ball(radius, x, y, vx, vy, mass) if not new_ball.check_overlap(self.balls): self.balls.append(new_ball) break #init_wall_collision_times will set all of the balls' minimum collision time #for both horizontal and vertical walls and store that time in their respective arrays def init_wall_collision_times(self): for i in np.arange(len(self.balls)): bi = self.balls[i] tix = bi.horizontal_wall_collision_time(self.min_x, self.max_x) tiy = bi.vertical_wall_collision_time(self.min_y, self.max_y) self.PQ.insert(i, -1, tix + self.time, self.balls[i].count, -1) self.PQ.insert(-1, i, tiy + self.time, -1, self.balls[i].count) return #init_ball_collision_times will set all of the balls' minimum collision time #with all other balls and store that time within the ith and jth index of #PQ.ball_collision_time def init_ball_collision_times(self): for i in np.arange(self.num_balls): bi = self.balls[i] for j in np.arange(i+1, self.num_balls): bj = self.balls[j] tij = bi.ball_collision_time(bj) self.PQ.insert(i, j, tij + self.time, self.balls[i].count, self.balls[j].count) # self.ball_collision_times[i][j] = tij # self.ball_collision_times[j][i] = tij return #update collision times is meant to update collision times of ball i with all #walls (horizontal and vertical) and all other balls within the PQ array def update_collision_times(self, i): bi = self.balls[i] tix = bi.horizontal_wall_collision_time(self.min_x, self.max_x) tiy = bi.vertical_wall_collision_time(self.min_y, self.max_y) self.PQ.insert(i, -1, tix + self.time,self.balls[i].count, -1) self.PQ.insert(-1, i, tiy + self.time, -1, self.balls[i].count) for j in np.arange(self.num_balls): bj = self.balls[j] tij = bi.ball_collision_time(bj) + self.time if i > j: self.PQ.insert(j, i, tij,self.balls[j].count,self.balls[i].count) else: self.PQ.insert(i, j, tij,self.balls[i].count, self.balls[j].count) return #draw will draw the borders and all balls within self.balls def draw(self): #Draw walls self.canvas.create_line((self.min_x, self.min_y), (self.min_x, self.max_y), fill = "red") self.canvas.create_line((self.min_x, self.min_y), (self.max_x, self.min_y), fill = "red") self.canvas.create_line((self.min_x, self.max_y), (self.max_x, self.max_y), fill = "red") self.canvas.create_line((self.max_x, self.min_y), (self.max_x, self.max_y), fill = "red") #Draw balls for b in self.balls: obj = self.canvas.create_oval(b.x - b.radius, b.y - b.radius, b.x + b.radius, b.y + b.radius, outline=b.tk_rgb, fill=b.tk_rgb) self.ball_handles[b] = obj self.canvas.update() #refresh is called to update the state of the simulation #-each refresh call can be considered one iteration of the simulation #-all balls will be moved and if there is a collision then it will be computed def refresh(self): #get the next collision i, j, t, num_collisions_i, num_collision_j = self.PQ.get_next() #gather the current collisions of the ith and jth ball current_collisions_i = self.balls[i].count current_collisions_j = self.balls[j].count #Check the difference in time between the predicted collision time and #the current time stamp of the simulation delta = t - self.time #If the difference is greater than 1, then just move the balls if delta > 1.0: # cap delta to 1.0 for bi in self.balls: bi.move() self.canvas.move(self.ball_handles[bi], bi.vx, bi.vy) self.time += 1.0 #Otherwise a collision has occurred else: #Move all balls for bi in self.balls: bi.move(delta) self.canvas.move(self.ball_handles[bi], bi.vx*delta, bi.vy*delta) #increment the simulation time stamp self.time += delta #Delete the top element within the Priority Queue self.PQ.delete() #if i is -1 then this indicates a collision with a vertical wall #also this if statement checks if the number of collisions recorded #when the collision returned by PQ.get_next() is equal to the #number of collisions within the jth ball #this acts as a test to check if the collision is still valid if i == -1 and num_collision_j == current_collisions_j: #compute what happens from the vertical wall collision self.balls[j].collide_with_vertical_wall() #update collision times for the jth ball self.update_collision_times(j) #if j is -1 then this indicates a collision a horizontal wall #while also checking if the number of collisions match #to see if the collision is valid elif j == -1 and num_collisions_i == current_collisions_i: #compute what happens from the horizontal wall collision self.balls[i].collide_with_horizontal_wall() #update collision times for the ith ball self.update_collision_times(i) #Otherwise i and j are not equal to -1 indicating that the collision is between two balls #check if no collisions have occurred between both balls before the collision returned from PQ.get_next #if true then this means that the collision is still valid and must be executed elif num_collision_j == current_collisions_j and num_collisions_i == current_collisions_i: #Execute collision across the ith and jth ball self.balls[i].collide_with_ball(self.balls[j]) #update collision times for both the ith and jth ball self.update_collision_times(i) self.update_collision_times(j) #update the canvas to draw the new locations of each ball self.canvas.update() self.canvas.after(self.refresh_speed, self.refresh) #Calls the function again
class Earth: DELAY_STEP = 10 def __init__(self, nsize, msize, scale, dencity=None, lifeRule=None, root=None): self.root = root self.lifeRule = lifeRule self.RowSize = nsize self.ColumnSize = msize self.Scale = scale self.dencity = dencity self.drawArray = [] self.MyArray = array('H', (False for s in range(self.RowSize * self.ColumnSize))) self.canvas = Canvas(root, width=self.RowSize * self.Scale, height=self.ColumnSize * self.Scale, bg="black") self.canvas.pack() self.delay = 10 self.__init_life() def delay_increase(self): self.delay += self.DELAY_STEP def delay_decrease(self): if self.delay > 0: self.delay -= self.DELAY_STEP def get(self, row_pos, column_pos): row_pos = row_pos % self.RowSize column_pos = column_pos % self.ColumnSize return self.MyArray[row_pos * self.ColumnSize + column_pos] def __set(self, row_pos, column_pos): self.MyArray[row_pos * self.ColumnSize + column_pos] = True self.canvas.itemconfigure(self.drawArray[row_pos * self.ColumnSize + column_pos], fill='yellow') def __unset(self, row_pos, column_pos): self.MyArray[row_pos * self.ColumnSize + column_pos] = False self.canvas.itemconfigure(self.drawArray[row_pos * self.ColumnSize + column_pos], fill='black') def __init_life(self): for i in range(self.RowSize): for j in range(self.ColumnSize): self.drawArray.append( self.canvas.create_oval(i * self.Scale, j * self.Scale, i * self.Scale + self.Scale, j * self.Scale + self.Scale, fill='black')) for i in range(self.RowSize): for j in range(self.ColumnSize): if random.randint(1, self.dencity) == self.dencity: self.__set(i, j) def __next_generation(self): for i in range(self.RowSize): for j in range(self.ColumnSize): alive = self.get(i, j) comfort_level = self.lifeRule(self, self.RowSize, self.ColumnSize, i, j) if alive and comfort_level == IS_UNPLEASURE: self.__unset(i, j) if not alive and comfort_level == IS_PLEASURE: self.__set(i, j) def next_move(self): self.__next_generation() self.canvas.after(self.delay, self.next_move)
stvorec(x + 20 * i, y) def stvorecStvorcov(x, y, dx, dy): for i in range(0, dy): riadok(x, y + 20 * i, dx) def mindfuck(amt): for i in range(0, 20): stvorecStvorcov(i * amt, i * amt, i, i) def loop(): global t, c c.delete('all') mindfuck(t) if t > 20: t = 0 else: t += 1 c.update_idletasks() c.update() c.after(0, loop) c.after(0, loop) c.mainloop()
class PathFindingBfs: def __init__(self, myCanvas: Canvas, columns: int, rows: int, width: float, height: float): self.Canvas = myCanvas self.columns = columns self.rows = rows self.width = width self.height = height self.operation = 0 self.dr = [-1, 1, 0, 0] self.dc = [0, 0, 1, -1] self.rq = [] # Row Queue self.cq = [] # Column Queue self.queue = [] # Containing the path self.visited = list() # Visited Matrix self.reached = False # To check if we get to the destination self.move_count = 0 self.nodes_left_in_layer = 1 self.nodes_in_next_layer = 0 self.secondarylist = list() self.columnwidth = float(self.width / self.columns) self.rowheight = float(self.height / self.rows) self.isstartselected = False self.isendselected = False self.startid = 0 self.endid = 0 self.barrierlist = list() self.operationlist = list() self.canvas = Canvas(self.Canvas, height=self.height, width=self.width, bg="#FDE69F") # Canvas within the canvas self.canvas1 = self.Canvas.create_window(0, 0, anchor="nw", window=self.canvas) for i in range(self.rows): for j in range(self.columns): self.x = self.canvas.create_rectangle( 0 + j * self.columnwidth, 0 + i * self.rowheight, self.columnwidth + j * self.columnwidth, self.rowheight + i * self.rowheight) # Responsible for choosing the start and end point self.canvas.bind("<Double-Button-1>", lambda event: self.start(event)) # Responsible for Adding Barriers self.canvas.bind("<B1-Motion>", lambda event: self.motion(event)) # Responsible self.canvas.bind("<B3-Motion>", lambda event: self.removemotion(event)) def clear(self): # Empty Out the stored variables self.rq = [] self.cq = [] self.queue = [] self.reached = False self.move_count = 0 self.nodes_left_in_layer = 1 self.nodes_in_next_layer = 0 self.operation = 0 self.isstartselected = False self.isendselected = False self.barrierlist = [] self.startid = 0 self.endid = 0 self.operationlist = list() for i in range(self.rows): for j in range(self.columns): id = self.getwidgetid(i, j) self.canvas.itemconfig(id, fill="#FDE69F") def start(self, event): x = event.widget.find_closest(event.x, event.y) # id of the widget if not self.isstartselected: self.canvas.itemconfig(x, fill="yellow") self.isstartselected = True self.startid = x[0] elif not self.isendselected: self.canvas.itemconfig(x, fill="green") self.isendselected = True self.endid = x[0] elif x[0] == self.startid: self.canvas.itemconfig(x, fill="#FDE69F") self.isstartselected = False self.startid = 0 elif x[0] == self.endid: self.canvas.itemconfig(x, fill="#FDE69F") self.isendselected = False self.endid = 0 def motion(self, event): if self.isstartselected and self.isendselected: x = event.widget.find_closest(event.x, event.y) if x[0] not in self.barrierlist and x[0] != self.startid and x[ 0] != self.endid: self.canvas.itemconfig(x, fill="black") self.barrierlist.append(x[0]) def removemotion(self, event): x = event.widget.find_closest(event.x, event.y) if x[0] in self.barrierlist: self.canvas.itemconfigure(x, fill="#FDE69F") self.barrierlist.remove(x[0]) def getlistcoordinates(self, number): if not (number % self.columns == 0): row = number // self.columns column = number % self.columns - 1 else: column = self.columns - 1 row = (number - 1) // self.columns return int(row), int(column) def getwidgetid(self, row, column): return row * self.columns + column + 1 def bfs(self, event): if self.isstartselected and self.isstartselected: # empty the list so that we operate after we make modification self.operationlist = [["" for i in range(self.columns)] for j in range(self.rows)] # adding the start path i, j = self.getlistcoordinates(self.startid) self.operationlist[i][j] = "S" k, l = self.getlistcoordinates(self.endid) self.operationlist[k][l] = "E" for i in self.barrierlist: n, m = self.getlistcoordinates(i) self.operationlist[n][m] = "#" i, j = self.getlistcoordinates(self.startid) self.Solve(i, j) def explore_neighbors(self, r: int, c: int): list1 = list() for i in range(4): rr = r + self.dr[i] cc = c + self.dc[i] # Skipping the wrong choices if rr < 0 or cc < 0: continue if rr >= self.rows or cc >= self.columns: continue # Skipping visited locations or blocked cells if self.visited[rr][cc]: continue if self.operationlist[rr][cc] == "#": continue list1.append(i) self.VisitedColor(rr, cc) self.operation += 1 self.rq.append(rr) self.cq.append(cc) self.visited[rr][cc] = True self.nodes_in_next_layer += 1 # Tracking The Path Of the Solution Part if len(list1) != 0: path = self.queue.pop(0) for i in range(len(list1)): if list1[i] == 0: string = path + "U" self.queue.append(string) elif list1[i] == 1: string = path + "D" self.queue.append(string) elif list1[i] == 2: string = path + "R" self.queue.append(string) elif list1[i] == 3: string = path + "L" self.queue.append(string) else: self.queue.pop(0) def Solve(self, sr: int, sc: int): self.visited = [[False for i in range(self.columns)] for j in range(self.rows)] self.rq.append(sr) self.cq.append(sc) self.queue.append("") self.visited[sr][sc] = True while len( self.rq ) > 0: # or self.cq because we add and remove items in the same time r = self.rq.pop(0) c = self.cq.pop(0) if self.operationlist[r][c] == "E": self.reached = True break self.explore_neighbors(r, c) self.nodes_left_in_layer -= 1 if self.nodes_left_in_layer == 0: self.nodes_left_in_layer = self.nodes_in_next_layer self.nodes_in_next_layer = 0 self.move_count += 1 if self.reached: k, l = self.getlistcoordinates(self.endid) self.backtracking(self.queue[0], k, l) text = f"The Shortest Path is {self.move_count} blocks away\nAnd The cells visited are: " \ f"{self.operation} ({int((self.operation / (self.columns * self.rows)) * 100)}%)" messagebox.showinfo("Solution Details", text) return self.move_count messagebox.showerror("PathError", "Path Not Found") return -1 def backtracking(self, path: str, r: int, c: int): self.ValidateColorSolution(r, c) for move in path[-1::-1]: if move == "D": r -= 1 self.ValidateColorSolution(r, c) elif move == "U": r += 1 self.ValidateColorSolution(r, c) elif move == "R": c -= 1 self.ValidateColorSolution(r, c) elif move == "L": c += 1 self.ValidateColorSolution(r, c) def ValidateColorSolution(self, i: int, j: int): id = self.getwidgetid(i, j) self.canvas.itemconfig(id, fill="#FCA85A") self.canvas.update() self.canvas.after(100) def VisitedColor(self, i: int, j: int): id = self.getwidgetid(i, j) self.canvas.itemconfigure(id, fill="red") self.canvas.update() def delete(self): self.clear() self.Canvas.delete(self.canvas1) self.canvas.destroy()
speed_y = 0 y1 = 600 c.move(player, speed_x, speed_y) if x1 < 50: speed_x = 0 c.after(50, PhysMove) def PhysKey(key): global player, speed_y, speed_x print("с.coords") x1, y1 = c.coords(player) if key.char == "d" and speed_x < 10 and is_available(x1+50, y1): speed_x = speed_x + 10 c.move(player, speed_x, speed_y) print("right") if key.char == "a" and speed_x > -10 and is_available(x1-50, y1): speed_x = speed_x - 10 c.move(player, speed_x, speed_y) print("left") if key.char == " " and speed_y == 0: speed_y = speed_y - 40 print("space") c.move(player, speed_x, speed_y) c.after(50, PhysMove) tk.bind("<KeyPress>", PhysKey) mainloop()
class Visual(Frame): '''Class that takes a world as argument and present it graphically on a tkinter canvas.''' def __init__(self): '''Sets up a simulation GUI in tkinter. ''' Frame.__init__(self) self.master.title("The Schelling Segregation Model in Python") self.master.wm_resizable(0, 0) self.grid() self.movement_possible = True # --------------------------------------- # # --------- FRAMES FOR GUI -------------- # # --------------------------------------- # # The pane for user values self._entryPane = Frame(self, borderwidth=5, relief='sunken') self._entryPane.grid(row=0, column=0, sticky='n') # The buttons pane self._buttonPane = Frame(self, borderwidth=5) self._buttonPane.grid(row=1, column=0, sticky='n') # A temp pane where graph is located, just for cosmetic reasons width, height = 425, 350 self._graph = Canvas(self, width=width, height=height, background="black") self._graph.configure(relief='sunken', border=2) self._graph.grid(row=3, column=0) # The pane where the canvas is located self._animationPane = Frame(self, borderwidth=5, relief='sunken') self._animationPane.grid(row=0, column=1, rowspan=4, pady=10, sticky="n") # --------------------------------------- # # --------- FILLING THE FRAMES ---------- # # --------------------------------------- # self._canvas() # Create graphics canvas self._entry() # Create entry widgets self._buttons() # Create button widgets def _plot_setup(self, time): '''Method for crudely annotating the graph window.''' time = time # Main plot width, height = 425, 350 y0 = -time / 10 self._graph = Canvas(self, width=width, height=height, background="black", borderwidth=5) self._graph.grid(row=3, column=0) self.trans = Plotcoords(width, height, y0, -0.2, time, 1.3) x, y = self.trans.screen(time // 2, 1.2) x1, y1 = self.trans.screen(time // 2, 1.13) self._graph.create_text(x, y, text="% Happy", fill="yellow", font="bold 12") self._graph.create_text(x1, y1, text="% Unhappy", fill="blue", font="bold 12") # Line x-axis x, y = self.trans.screen((-5 * (time / 100)), -0.05) x1, y = self.trans.screen(time, -0.05) self._graph.create_line(x, y, x1, y, fill="white", width=1.5) # Text x-axis x_text, y_text = self.trans.screen(time / 2, -0.15) self._graph.create_text(x_text, y_text, text="Time", fill="white", font="bold 12") # Liney-axis x, y = self.trans.screen((-0.5 * (time / 100)), -0.05) x, y1 = self.trans.screen((-5 * (time / 100)), 1) self._graph.create_line(x, y, x, y1, fill="white", width=1.5) def _entry(self): '''Method for creating widgets for collecting user input.''' # N (no of turtles) dim = 30 * 30 self._N_label = Label(self._entryPane, anchor='w', justify='left', text="N:", relief='raised', width=12, height=1, font="italic 20") self._N_label.grid(row=0, column=1, ipady=14) self._N = Scale(self._entryPane, from_=1, to=dim - 50, resolution=1, bd=3, relief='sunken', orient='horizontal', length=235, tickinterval=849) self._N.set(400) self._N.grid(row=0, column=2) # Ticks (lenght of simulation) self._Ticks_label = Label(self._entryPane, anchor='w', justify='left', text="Time:", relief='raised', width=12, height=1, font="bold 20") self._Ticks_label.grid(row=1, column=1, ipady=14) self._Ticks = Scale(self._entryPane, from_=10, to=1000, resolution=1, bd=3, relief='sunken', orient='horizontal', length=235, tickinterval=990) self._Ticks.set(500) self._Ticks.grid(row=1, column=2) # % similar wanted self._Similar_label = Label(self._entryPane, anchor='w', justify='left', text="Similar wanted:", relief='raised', width=12, height=1, font="bold 20") self._Similar_label.grid(row=2, column=1, ipady=14) self._Similar = Scale(self._entryPane, from_=0.0, to=1.0, resolution=0.01, bd=3, relief='sunken', orient='horizontal', length=235, tickinterval=1) self._Similar.set(0.76) self._Similar.grid(row=2, column=2) def _buttons(self): '''Method for creating button widgets for setting up, running and plotting results from simulation.''' width = 7 height = 1 # The 'Setup' button self._setupButton = Button(self._buttonPane, text="Setup", command=self._setup, width=width, height=height, font="bold 30", relief='raised', borderwidth=5) self._setupButton.grid(row=0, column=0) # The 'Go' button self._goButton = Button(self._buttonPane, text="Go", command=self._go, width=width, height=height, font="bold 30", relief='raised', borderwidth=5) self._goButton.grid(row=0, column=1) # The 'Quit' button self._quitButton = Button(self._buttonPane, text="Quit", command=self._quit, width=width, height=height, font="bold 30", relief='raised', borderwidth=5) self._quitButton.grid(row=1, column=0, columnspan=2) def _canvas(self): '''Creates the canvas on which everything happens.''' # The tick counter information self._Tick_counter = Label(self._animationPane, anchor='w', justify='left', text="Time:", width=5, font="bold 20") self._Tick_counter.grid(row=0, column=0, sticky="e") self._Tick_counter1 = Label(self._animationPane, justify='center', text="", relief='raised', width=5, font="bold 20") self._Tick_counter1.grid(row=0, column=1, sticky='w') self.canvas_w, self.canvas_h = 750, 750 self.canvas = Canvas(self._animationPane, width=self.canvas_w, height=self.canvas_h, background="black") self.canvas.grid(row=1, column=0, columnspan=2) def _setup(self): '''Method for 'Setup' button.''' ## Clearing the canvas and reset the go button self.canvas.delete('all') self._goButton['relief'] = 'raised' self.N = int(self._N.get()) self.Ticks = int(self._Ticks.get()) self.similar = float(self._Similar.get()) self.data = [] self.tick_counter = 0 self._Tick_counter1['text'] = str(self.tick_counter) self._plot_setup(self.Ticks) self.grid_size = 30 self.world = World(750, 750, self.grid_size) self.create_turtles() self.neighbouring_turtles() self.draw_turtles() def _go(self): '''Method for the 'Go' button, i.e. running the simulation.''' self._goButton['relief'] = 'sunken' if self.tick_counter <= self.Ticks: self._Tick_counter1['text'] = str(self.tick_counter) self.canvas.update() self._graph.update() self._graph.after(0) # Data collection turtles_unhappy = self.check_satisfaction() prop_happy, prop_unhappy = self.calc_prop_happy(self.tick_counter) self.data_collection(self.tick_counter, prop_happy, prop_unhappy) if self.tick_counter >= 1: # HAPPY values (%) x0 = self.tick_counter - 1 x1 = self.tick_counter # Collecting values from stoblue data y0 = self.data[self.tick_counter - 1][1] y1 = self.data[self.tick_counter][1] # Transforming to tkinter x1, y1 = self.trans.screen(x1, y1) x0, y0 = self.trans.screen(x0, y0) self._graph.create_line(x0, y0, x1, y1, fill="yellow", width=1.3, tag="happy") # Draw "happy lines # UNHAPPY values (%) x0 = self.tick_counter - 1 x1 = self.tick_counter # Collecting values from stored data y0 = self.data[self.tick_counter - 1][2] y1 = self.data[self.tick_counter][2] # Transforming to tkinter x1, y1 = self.trans.screen(x1, y1) x0, y0 = self.trans.screen(x0, y0) self._graph.create_line(x0, y0, x1, y1, fill="blue", width=1.1, tag="unhappy") # Draw unhappy lines if prop_happy < 1: self.turtle_move(turtles_unhappy) self.update_neighbours() self.tick_counter += 1 self.canvas.after(0, self._go()) self._goButton['relief'] = 'raised' def _quit(self): '''Method for the 'Quit' button.''' self.master.destroy() # ------------------------------------------------------ # # ---------- FUNCTIONS CALLED AT EACH TICK ------------- # # ------------------------------------------------------ # def turtle_move(self, unhappy_turtles): '''Moves all the unhappy turtles (randomly).''' while unhappy_turtles: i = random.randint(0, len(unhappy_turtles) - 1) turtle = unhappy_turtles.pop(i) turtle.move(self) def update_neighbours(self): '''Updates the turtles neigbour attributes. Called after all turtles have moved.''' for turtle in self.turtles: turtle.update_neighbours() def check_satisfaction(self): '''Checks to see if turtles are happy or not. Returns a list of unhappy turtles, i.e. turtles that should move. Called before the move method.''' for turtle in self.turtles: turtle.is_happy() unhappy_turtles = [] for element in self.turtles: if not element.happy: unhappy_turtles.append(element) return unhappy_turtles def calc_prop_happy(self, i): '''Calculates the proportion of happy turtles.''' happy = 0 unhappy = 0 for turtle in self.turtles: if turtle.happy: happy += 1 else: unhappy += 1 prop_happy = happy / len(self.turtles) prop_unhappy = unhappy / len(self.turtles) return prop_happy, prop_unhappy def data_collection(self, i, prop_happy, prop_unhappy): '''Method for collecting data at each tick.''' self.data.append((i, prop_happy, prop_unhappy)) # ------------------------------------------------------ # # ---------- INITIALISATION FUNCTIONS ------------------ # # ------------------------------------------------------ # def create_turtles(self): '''Method for creating a new list of turtles. Upon creation they are registered in the World object.''' if self.N <= self.grid_size * self.grid_size: counter = 0 self.turtles = [] while counter < self.N: s = "S" + str(counter) if counter <= int(self.N / 2): color = "yellow" else: color = "blue" x = random.randint(0, self.grid_size - 1) y = random.randint(0, self.grid_size - 1) if not self.world.patch_list[x][y]: new_turtle = Schelling(world=self.world, x=x, y=y, s=s, color=color, similar_wanted=self.similar) self.world.register(new_turtle) counter += 1 self.turtles.append(new_turtle) else: print("Number of turtles exceeds world!") def draw_turtles(self): '''Method for drawing turtles on canvas. Calls each turtle's own method for drawing.''' for turtle in self.turtles: turtle.draw(self.canvas) def neighbouring_turtles(self): '''Method for updating turtles' neighbours. Calls on each turtle's own method for updating neighbours.''' for turtle in self.turtles: turtle.get_neighbouring_patches()
else: #иначе начинаем новый цикл сразу currentStage = STAGE_CLEANING elevatorCanvas.after(INTERVAL, progress) elif currentStage == STAGE_DISPATCHING: dispatchGrain() getStats() blinkArrow(elevatorCanvas, [goodGrainArrowToExport]) currentStage = STAGE_CLEANING elevatorCanvas.after(INTERVAL, progress) totalExpense += 500 totalProfit = totalIncome - totalExpense kek.append([iters, totalProfit]) print(totalIncome) print(totalExpense) print(totalProfit) timeGoodExportText.config(text="Через {0} дн.".format( str(abs(iters % DISPATCH_DELAY % (-1 * DISPATCH_DELAY))))) print() ################################################################################## elevatorCanvas.after(0, progress) window.geometry('1280x720') window.mainloop()
canvas.grid(row=0, column=0) delay = 30 rad = 5 color = 'red' x = rad y = ch - rad vx = 4.0 vy = -5.0 ay = 0.05 line = [x, y] while True: canvas.delete(ALL) canvas.create_oval(x - rad, y - rad, x + rad, y + rad, fill=color) line.append(x) line.append(y) canvas.create_line(line, fill='blue') canvas.update() if (x + rad) >= cw: vx = -abs(vx) elif (y + rad) >= ch: vy = -abs(vy) elif x <= rad: vx = abs(vx) elif y <= rad: vy = abs(vy) x += vx y += vy + 0.5 * ay vy += ay canvas.after(delay)
class App: sg = "" def __init__(self, screen): self.debug = False self.controlMode = "l" # l = location, s = size # user by the x (cross) button to show virtual screen cross self.xMode = False # false - no x is displayed in the middle of the screen self.xVertical = 0 self.xHorizental = 0 self.xBoundry = 0 # used by the y (mid button) button to show mid screen marker self.yMode = False # False - no midScreen marker is displayed self.yVertical = 0 self.yHorizental = 0 ##### self.bgColor = 0 self.vsColor = 0 self.stimulusColor = 0 self.appConfig = loadCSV(constants.APP_CONFIG_FILE) self.vsX = self.getAppConfig("fishScreenStartX") self.vsY = self.getAppConfig("fishScreenStartY") self.vsWidth = self.getAppConfig("fishScreenWidth") self.vsHeight = self.getAppConfig("fishScreenHeight") self.bgColor = self.getAppConfig("backgroundColor", "str") self.vsColor = self.getAppConfig("virtualScreenColor", "str") self.stimulusColor = self.getAppConfig("stimulusColor", "str") self.f9CommunicationEnabled = self.getAppConfig( "f9CommunicationEnabled", "str") self.NiDaqPulseEnabled = self.getAppConfig("NiDaqPulseEnabled", "str") self.DishRadiusSize = self.getAppConfig("DishRadiusSize") self.VirtualScreenDegrees = self.getAppConfig("VirtualScreenDegrees") self.VirtualScreenWidthActualSize = self.getAppConfig( "VirtualScreenWidthActualSize") self.VirtualScreenHeightActualSize = self.getAppConfig( "VirtualScreenHeightActualSize") self.projectorOnMonitor = self.getAppConfig("projectorOnMonitor") self.deltaX = 0 self.deltaY = 0 self.positionDegreesToVSTable = [] self.calcConvertPositionToPixelsTable() # populate the above table if self.NiDaqPulseEnabled.lower() == "on": # try to add channel try: task = NiDaqPulse(device_name="Dev2/port{0}/line{1}".format( self.port, self.line)) self.output_device = task except nidaqmx.DaqError as e: print(e) task.stop() else: self.output_device = None if self.f9CommunicationEnabled.lower() == "on": self.f9CommunicationEnabled = False else: self.f9CommunicationEnabled = False logging.info("f9CommunicationEnabled=" + str(self.f9CommunicationEnabled)) self.printVirtualScreenData() self.screen_width = int(screen.winfo_screenwidth() / 4) self.screen_height = int(screen.winfo_screenheight() / 4) screen.geometry( self.calcGeometry(self.screen_width, self.screen_height)) self.canvas = Canvas(screen, background="black") self.textVar = tkinter.StringVar() self.label = ttk.Label(self.canvas, textvariable=self.textVar) self.label.config(font=("Courier", 20)) self.label.grid(column=0, row=0) self.canvas.pack(fill=BOTH, expand=1) self.vs = self.canvas.create_rectangle(self.vsX, self.vsY, self.vsX + self.vsWidth, self.vsY + self.vsHeight, fill=self.vsColor) screen.bind('<Up>', self.processEvent) screen.bind('<Down>', self.processEvent) screen.bind('<Left>', self.processEvent) screen.bind('<Right>', self.processEvent) screen.bind(constants.DEBUG, self.turnDebug) screen.bind(constants.LOCATION, self.changeControlMode) screen.bind(constants.SIZE, self.changeControlMode) screen.bind(constants.UPDATE, self.updateConfig) screen.bind(constants.EXIT, self.leaveProg) screen.bind(constants.RUN, self.manageStimulus) screen.bind(constants.PAUSE, self.manageStimulus) screen.bind(constants.CROSS, self.showCrossAndBoundries) screen.bind(constants.MID_SCREEN, self.showMidScreen) screen.bind('?', self.printHelp) self.printHelp("") def updateConfig(self, event): """ Update config file with current VS settings """ logging.debug(event) self.appConfig[0]["fishScreenStartX"] = self.vsX self.appConfig[0]["fishScreenStartY"] = self.vsY self.appConfig[0]["fishScreenWidth"] = self.vsWidth self.appConfig[0]["fishScreenHeight"] = self.vsHeight writeCSV(constants.APP_CONFIG_FILE, self.appConfig[0]) self.printVirtualScreenData() logging.debug("Config file updates successfully") def leaveProg(self, event): logging.debug(event) logging.info("Bye bye !") if self.output_device is not None: self.output_device.stop() sys.exit() def printHelp(self, event): print("NOTE : press the keyboard while focus is on the graphic screen") print("========== General actions ==========") print('? = for help (this screen)') print(constants.EXIT, ' - to exit') print(constants.DEBUG, ' - to activate debug') print("========== Controlling Virtual Screen ==========") print(constants.CROSS, ' - show cross') print(constants.LOCATION, ' - switch to virtual screen location setting') print(constants.SIZE, ' - switch to virtual screen size setting ') print('<Up> - move up or reduce virtual screen height') print('<Down> - move down or extend virtual screen hegith') print('<Left> - move left or reduce virtual screen width') print('<Right> - move right or extend virtual screen size ') print(constants.UPDATE, ' - to update app config with current virtual screen location') print("========== Controlling Stimulus generator ==========") print(constants.RUN, ' - Run the stimuli, pressing r again will restart') print(constants.PAUSE, ' - Pause the run') def changeControlMode(self, event): logging.debug(event) self.chagneVirtualScreenProperties(event.keysym) self.controlMode = event.keysym logging.debug("ControlMode=" + event.keysym) def processEvent(self, event): logging.debug(event) self.chagneVirtualScreenProperties(event.keysym) if self.controlMode == constants.LOCATION: self.canvas.move(self.vs, self.deltaX, self.deltaY) self.canvas.move(self.xBoundry, self.deltaX, self.deltaY) self.canvas.move(self.xHorizental, self.deltaX, self.deltaY) self.canvas.move(self.xVertical, self.deltaX, self.deltaY) elif self.controlMode == constants.SIZE: x0, y0, x1, y1 = self.canvas.coords(self.vs) x1 = x0 + self.vsWidth y1 = y0 + self.vsHeight self.canvas.coords(self.vs, x0, y0, x1, y1) if self.xMode: self.deleteCross() self.createCross() return def manageStimulus(self, event): logging.debug(event) if event.keysym == constants.PAUSE: self.state = constants.PAUSE if self.sg != "": self.sg.terminate_run() elif event.keysym == constants.RUN: self.state = constants.RUN self.sg = StimulusGenerator(self.canvas, self, self.output_device) self.runStimuli() def runStimuli(self): # this is main loop of stimulus if self.state == constants.PAUSE: return if self.sg.run_stimuli() == constants.DONE: # call specific stim list logging.info("All stimuli were executed ! ") self.setDebugText("Done") self.state = constants.PAUSE else: self.canvas.after(constants.SLEEP_TIME, self.runStimuli) def calcGeometry(self, screen_width, screen_height): geometryStr = str(screen_width) + "x" + str(screen_height) + "+-10+0" return geometryStr def printVirtualScreenData(self): logging.debug("X=" + str(self.vsX) + " Y=" + str(self.vsY) + " Width=" + str(self.vsWidth) + " Height=" + str(self.vsHeight)) def getAppConfig(self, variableName, type="int"): """get appConfig value Args: variableName ([string]): [the name of the variable] type ([type]): [int or str] """ ret = self.appConfig[0][variableName] if type == "int": return (int(ret)) else: return (ret) def showCrossAndBoundries(self, event): logging.debug(event) if self.xMode: self.xMode = False self.deleteCross() else: self.xMode = True self.createCross() def showMidScreen(self, event): logging.debug(event) monitor = self.get_monitors_dimensions(self.projectorOnMonitor) if self.yMode: self.yMode = False self.deleteMidScreen() else: self.createMidScreen(monitor['width'], monitor['height']) self.yMode = True def deleteCross(self): self.canvas.delete(self.xHorizental) self.canvas.delete(self.xVertical) self.canvas.delete(self.xBoundry) def deleteMidScreen(self): self.canvas.delete(self.yHorizental) self.canvas.delete(self.yVertical) def createMidScreen(self, width, height): self.yVertical = self.canvas.create_line( width / 2, 0, width / 2, height, fill=constants.FILL_COLOR, width=constants.THIN_LINE_WIDTH) self.yHorizental = self.canvas.create_line( 0, height / 2, width, height / 2, fill=constants.FILL_COLOR, width=constants.THIN_LINE_WIDTH) def createCross(self): self.xBoundry = self.canvas.create_rectangle( self.vsX - 10, self.vsY - 10, self.vsX + self.vsWidth + 10, self.vsY + self.vsHeight + 10, fill=constants.FILL_COLOR) self.xHorizental = self.canvas.create_line( self.vsX, self.vsY + self.vsHeight / 2, self.vsX + self.vsWidth, self.vsY + self.vsHeight / 2, fill=constants.FILL_COLOR, width=constants.LINE_WIDTH) self.xVertical = self.canvas.create_line(self.vsX + self.vsWidth / 2, self.vsY, self.vsX + self.vsWidth / 2, self.vsY + self.vsHeight, fill=constants.FILL_COLOR, width=constants.LINE_WIDTH) self.canvas.tag_lower(self.xBoundry) def chagneVirtualScreenProperties(self, direction): """ Change screen Location or Size properties based on controlMode Args: direction ([String]): the event.keySym Up,Down,Left,Rigth """ # we need delta X and Y as tkinter move is relative to the existing locaiton whereas teh vsX and vsY are absolute self.deltaX = 0 self.deltaY = 0 if self.controlMode == constants.LOCATION: if direction.lower() == "up": self.deltaY -= 1 self.vsY -= 1 elif direction.lower() == "down": self.deltaY += 1 self.vsY += 1 elif direction.lower() == "left": self.deltaX -= 1 self.vsX -= 1 elif direction.lower() == "right": self.deltaX += 1 self.vsX += 1 elif self.controlMode == constants.SIZE: if direction.lower() == "up": self.vsHeight -= 1 elif direction.lower() == "down": self.vsHeight += 1 elif direction.lower() == "left": self.vsWidth -= 1 elif direction.lower() == "right": self.vsWidth += 1 def convertDegreesToMM(self, degrees): return 2 * self.DishRadiusSize * sin(degrees * (pi / 180) / 2) def convertMMToPixels(self, mm, direction): if direction.lower() == "width": return (mm * self.vsWidth) / self.VirtualScreenWidthActualSize else: return (mm * self.vsHeight) / self.VirtualScreenHeightActualSize def convertDegreestoPixels(self, degrees, direction): """[summary] Args: degrees ([int]): [degrees to be convereted] direction ([string]): [width or height] """ return (self.convertMMToPixels(self.convertDegreesToMM(degrees), direction)) def setDebugText(self, str): if self.debug: s = f'VS WxH {self.vsWidth} X {self.vsHeight}' s1 = f'1 degree/ms (LtR) = {round(self.convertDegreestoPixels(1, "widht"), 1)} pixels/ms' self.textVar.set(s + '\n' + s1 + '\n' + str) def turnDebug(self, event): if self.debug: logging.info("disable debug") self.debug = False self.label.grid_remove() else: logging.info("enable debug") self.debug = True self.label.grid() def get_monitors_dimensions(self, monitor_number): monitors = [] for m in get_monitors(): print(f'monitor = {m}') monitors.append({"width": m.width, "height": m.height}) return monitors[monitor_number] def calcConvertPositionToPixelsTable(self): for i in range(0, 181): if i <= 90: d = 90 - i v = 500 - 500 * sin(radians(d)) * cos(radians(d / 2)) / sin( radians(90 - d / 2)) else: d = i - 90 v = 500 + 500 * sin(radians(d)) * cos(radians(d / 2)) / sin( radians(90 - d / 2)) self.positionDegreesToVSTable.append(v)
class Visual(Frame): '''Class that takes a world as argument and present it graphically on a tkinter canvas.''' def __init__(self): ''' Sets up a simulation GUI in tkinter. ''' Frame.__init__(self) self.master.title("The Schelling Segregation Model in Python") self.master.wm_resizable(0, 0) self.grid() self.movement_possible = True # --------------------------------------- # # --------- FRAMES FOR GUI -------------- # # --------------------------------------- # # The pane for user values self._entryPane = Frame(self, borderwidth=5, relief='sunken') self._entryPane.grid(row=0, column=0, sticky='n') # The buttons pane self._buttonPane = Frame(self, borderwidth=5) self._buttonPane.grid(row=1, column=0, sticky='n') # A temp pane where graph is located, just for cosmetic reasons width, height = 425, 350 self._graph = Canvas(self, width=width, height=height, background="black") self._graph.configure(relief='sunken', border=2) self._graph.grid(row=3, column=0) # The pane where the canvas is located self._animationPane = Frame(self, borderwidth=5, relief='sunken') self._animationPane.grid(row=0, column=1, rowspan=4, pady=10, sticky="n") # --------------------------------------- # # --------- FILLING THE FRAMES ---------- # # --------------------------------------- # self._canvas() # Create graphics canvas self._entry() # Create entry widgets self._buttons() # Create button widgets def _plot_setup(self, time): '''Method for crudely annotating the graph window.''' time = time # Main plot width, height = 425, 350 y0 = -time/10 self._graph = Canvas(self, width=width, height=height, background="black", borderwidth=5) self._graph.grid(row=3, column=0) self.trans = Plotcoords(width, height, y0, -0.2, time, 1.3) x, y = self.trans.screen(time // 2, 1.2) x1, y1 = self.trans.screen(time // 2, 1.13) self._graph.create_text(x, y, text="% Happy", fill="green", font="bold 12") self._graph.create_text(x1, y1, text="% Unhappy", fill="red", font="bold 12") # Line x-axis x, y = self.trans.screen((-5 * (time / 100)), -0.05) x1, y = self.trans.screen(time, -0.05) self._graph.create_line(x, y, x1, y, fill="white", width=1.5) # Text x-axis x_text, y_text = self.trans.screen(time / 2, -0.15) self._graph.create_text(x_text, y_text, text="Time", fill="white", font="bold 12") # Line y-axis x, y = self.trans.screen((-0.5 * (time / 100)), -0.05) x, y1 = self.trans.screen((-5 * (time / 100)), 1) self._graph.create_line(x, y, x, y1, fill="white", width=1.5) def _entry(self): '''Method for creating widgets for collecting user input.''' # N (no of turtles) dim = 30*30 self.fill_label = Label(self._entryPane, anchor='w', justify='left', text='Fill', relief='raised', width=12, height=1, font='italic 20') self.fill_label.grid(row=0, column=1, ipady=14) self.fill = Scale(self._entryPane, from_=0, to=1, resolution=0.01, bd=3, relief='sunken', orient='horizontal', length=235, tickinterval=20) self.fill.grid(row=0, column=2) self.fill.set(0.8) self._N_label = Label(self._entryPane, anchor='w', justify='left', text="N:", relief='raised', width=12, height=1, font="italic 20") self._N_label.grid(row=1, column=1, ipady=14) self._N = Scale(self._entryPane, from_=0, to=100, resolution=1, bd=3, relief='sunken', orient='horizontal', length=235, tickinterval=20) self._N.set(30) self._N.grid(row=1, column=2) # Ticks (length of simulation) self._Ticks_label = Label(self._entryPane, anchor='w', justify='left', text="Time:", relief='raised', width=12, height=1, font="bold 20") self._Ticks_label.grid(row=2, column=1, ipady=14) self._Ticks = Scale(self._entryPane, from_=10, to=1000, resolution=1, bd=3, relief='sunken', orient='horizontal', length=235, tickinterval=990) self._Ticks.set(500) self._Ticks.grid(row=2, column=2) # % similar wanted self._Similar_label = Label(self._entryPane, anchor='w', justify='left', text="Similar wanted:", relief='raised', width=12, height=1, font="bold 20") self._Similar_label.grid(row=3, column=1, ipady=14) self._Similar = Scale(self._entryPane, from_=0.0, to=1.0, resolution=0.01, bd=3, relief='sunken', orient='horizontal', length=235, tickinterval=0.5) self._Similar.set(0.76) self._Similar.grid(row=3, column=2) # Delay between steps self._delay_label = Label(self._entryPane, anchor='w', justify='left', text="Delay (s):", relief='raised', width=12, height=1, font="bold 20") self._delay_label.grid(row=4, column=1, ipady=14) self._delay = Scale(self._entryPane, from_=0.0, to=1.0, resolution=0.01, bd=3, relief='sunken', orient='horizontal', length=235, tickinterval=0.5) self._delay.set(0.15) self._delay.grid(row=4, column=2) def _buttons(self): '''Method for creating button widgets for setting up, running and plotting results from simulation.''' width = 7 height = 1 # The 'Setup' button self._setupButton = Button(self._buttonPane, text="Setup", command=self._setup, width=width, height=height, font="bold 30", relief='raised', borderwidth=5) self._setupButton.grid(row=0, column=0) # The 'Go' button self._goButton = Button(self._buttonPane, text="Go", command=self._go, width=width, height=height, font="bold 30", relief='raised', borderwidth=5) self._goButton.grid(row=0, column=1) # The 'Quit' button self._quitButton = Button(self._buttonPane, text="Quit", command=self._quit, width=width, height=height, font="bold 30", relief='raised', borderwidth=5) self._quitButton.grid(row=1, column=0, columnspan=2) def _canvas(self): '''Creates the canvas on which everything happens.''' # The tick counter information self._Tick_counter = Label(self._animationPane, anchor='w', justify='left', text="Time:", width=5, font="bold 20") self._Tick_counter.grid(row=0, column=0, sticky="e") self._Tick_counter1 = Label(self._animationPane, justify='center', text="", relief='raised', width=5, font="bold 20") self._Tick_counter1.grid(row=0, column=1, sticky='w') self.canvas_w, self.canvas_h = 750, 750 self.canvas = Canvas(self._animationPane, width=self.canvas_w, height=self.canvas_h, background="black") self.canvas.grid(row=1, column=0, columnspan=2) def _setup(self): '''Method for 'Setup' button.''' # Clearing the canvas and reset the go button self.canvas.delete('all') self._goButton['relief'] = 'raised' self.N = int(self._N.get()) self.Ticks = int(self._Ticks.get()) self.similar = float(self._Similar.get()) self.data = [] self.tick_counter = 0 self._Tick_counter1['text'] = str(self.tick_counter) self._plot_setup(self.Ticks) self.grid_size = self.N self.world = World(750, 750, self.grid_size) self.create_turtles() self.neighbouring_turtles() self.draw_turtles() def _go(self): '''Method for the 'Go' button, i.e. running the simulation.''' self._goButton['relief'] = 'sunken' if self.tick_counter <= self.Ticks: self._Tick_counter1['text'] = str(self.tick_counter) self.canvas.update() self._graph.update() self._graph.after(0) # Data collection turtles_unhappy = self.check_satisfaction() prop_happy, prop_unhappy = self.calc_prop_happy(self.tick_counter) self.data_collection(self.tick_counter, prop_happy, prop_unhappy) if self.tick_counter >= 1: # HAPPY values (%) x0 = self.tick_counter-1 x1 = self.tick_counter # Collecting values from stored data y0 = self.data[self.tick_counter-1][1] y1 = self.data[self.tick_counter][1] # Transforming to tkinter x1, y1 = self.trans.screen(x1, y1) x0, y0 = self.trans.screen(x0, y0) self._graph.create_line(x0, y0, x1, y1, fill="green", width=1.3, tag="happy") # Draw "happy lines # UNHAPPY values (%) x0 = self.tick_counter-1 x1 = self.tick_counter # Collecting values from stored data y0 = self.data[self.tick_counter-1][2] y1 = self.data[self.tick_counter][2] # Transforming to tkinter x1, y1 = self.trans.screen(x1, y1) x0, y0 = self.trans.screen(x0, y0) self._graph.create_line(x0, y0, x1, y1, fill="red", width=1.1, tag="unhappy") # Draw unhappy lines if prop_happy < 1: self.turtle_move(turtles_unhappy) time.sleep(self._delay.get()) self.update_neighbours() self.tick_counter += 1 self.canvas.after(0, self._go()) self._goButton['relief'] = 'raised' def _quit(self): '''Method for the 'Quit' button.''' self.master.destroy() # ------------------------------------------------------ # # ---------- FUNCTIONS CALLED AT EACH TICK ------------- # # ------------------------------------------------------ # def turtle_move(self, unhappy_turtles): '''Moves all the unhappy turtles (randomly).''' while unhappy_turtles: i = random.randint(0, len(unhappy_turtles)-1) turtle = unhappy_turtles.pop(i) turtle.move(self) def update_neighbours(self): '''Updates the turtles neigbour attributes. Called after all turtles have moved.''' for turtle in self.turtles: turtle.update_neighbours() def check_satisfaction(self): '''Checks to see if turtles are happy or not. Returns a list of unhappy turtles, i.e. turtles that should move. Called before the move method.''' for turtle in self.turtles: turtle.is_happy() unhappy_turtles = [] for element in self.turtles: if not element.happy: unhappy_turtles.append(element) return unhappy_turtles def calc_prop_happy(self, i): '''Calculates the proportion of happy turtles.''' happy = 0 unhappy = 0 for turtle in self.turtles: if turtle.happy: happy += 1 else: unhappy += 1 prop_happy = happy/len(self.turtles) prop_unhappy = unhappy/len(self.turtles) return prop_happy, prop_unhappy def data_collection(self, i, prop_happy, prop_unhappy): '''Method for collecting data at each tick.''' self.data.append((i, prop_happy, prop_unhappy)) # ------------------------------------------------------ # # ---------- INITIALISATION FUNCTIONS ------------------ # # ------------------------------------------------------ # def create_turtles(self): '''Method for creating a new list of turtles. Upon creation they are registered in the World object.''' if self.N*self.N <= self.grid_size*self.grid_size: counter = 0 self.turtles = [] while counter < self.N * self.N * self.fill.get(): s = "S"+str(counter) if counter <= int(self.N * self.N * self.fill.get() / 2): color = "green" else: color = "red" x = random.randint(0, self.grid_size-1) y = random.randint(0, self.grid_size-1) if not self.world.patch_list[x][y]: new_turtle = Schelling(world=self.world, x=x, y=y, s=s, color=color, similar_wanted=self.similar) self.world.register(new_turtle) counter += 1 self.turtles.append(new_turtle) else: print("Number of turtles exceeds world!") def draw_turtles(self): '''Method for drawing turtles on canvas. Calls each turtle's own method for drawing.''' for turtle in self.turtles: turtle.draw(self.canvas) def neighbouring_turtles(self): '''Method for updating turtles' neighbours. Calls on each turtle's own method for updating neighbours.''' for turtle in self.turtles: turtle.get_neighbouring_patches()
fen = Tk() size = (15, 15) img_size = (32, 32) photo = PhotoImage(file="sm-feu.gif") photo_pompier = PhotoImage(file="sm-pomp.gif") canvas = Canvas(fen, width=img_size[0] * size[0], height=img_size[1] * size[1]) canvas.pack() i = 0 def next_move(): global i canvas.delete("all") canvas.create_image(img_size[0] // 2, img_size[1] // 2, image=photo) canvas.create_image(i * img_size[0] + img_size[0] // 2, i * img_size[1] + img_size[1] // 2, image=photo_pompier) i += 1 if i < 12: canvas.after(500, next_move) canvas.after(500, next_move) fen.mainloop()
class GameController: def __init__(self, mode, dinos_per_gen = 10): #can be either a train or a game self.mode = mode self.master = Tk() self.width = 800 self.height = 800 self.canvas = Canvas(self.master, width=800, height=800, bg='#fff') self.infoPanel = Frame(self.master, bg='#fff') self.colisionMonitor = ColisionMonitor(self.master, self.canvas, self.stopGround) self.dinos = [] self.dinosOnScreen = 0 self.obstacles = [] self.colisionMonitor = None self.obstacleGenerator = None self.initialDinoNum = dinos_per_gen self.game_params = {'distance': 100, 'speed': 25, 'height': 0, 'width': 50} self.master.bind('<r>', self.restart) self.scoresCheckPoint = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 80, 110, 140, 200, 250] self.imgs_pil_ground = [ Image.open("./assets/ground.png"), Image.open("./assets/ground-1.png")] self.ground = ImageTk.PhotoImage(self.imgs_pil_ground[0]) self.ground_1 = ImageTk.PhotoImage(self.imgs_pil_ground[1]) # display image on canvas self.ground_id = self.canvas.create_image(0, 695, image=self.ground, anchor=NW) self.ground_id_1 = self.canvas.create_image(400, 695, image=self.ground_1, anchor=NW) self.ground_id_2 = self.canvas.create_image(800, 695, image=self.ground, anchor=NW) self.ground_animation_id = None self.interfaceObject = {} self.score = 0 self.record = 0 try: general_data = np.load('data/general/game.npy') self.general_record = general_data[0] except IOError as err: self.general_record = 0 np.save('data/general/game.npy', np.array([0])) self.n_generations = 0 self.game_modes = { "train": "train", "game": "game", "simulation": "simulation" } self.nn_elements = { 'neurons': [], 'connections': [] } def saveGeneralRecord(self): if(self.general_record<=self.score): print(self.general_record) np.save('data/general/game.npy', np.array([self.general_record])) def prepareInterface(self): #l1.grid(row = 0, column = 0, sticky = W, pady = 2) self.infoPanel.pack(fill='x') speedLabel = Label(self.infoPanel, text="Speed: "+str(self.game_params['speed'])+"/"+str(len(self.scoresCheckPoint)), bg='#fff') speedLabel.grid(row=0, column=0, pady=10, sticky = W) self.interfaceObject['speedLabel'] = speedLabel dinosAlive = Label(self.infoPanel, text="Dinos: "+str(self.initialDinoNum), bg='#fff') dinosAlive.grid(row=1, column=0, pady=10, sticky = W) self.interfaceObject['dinosAlive'] = dinosAlive scoreLabel = Label(self.infoPanel, text="Score: "+str(self.score), bg='#fff') scoreLabel.grid(row=2, column=0, pady=10, sticky = W) self.interfaceObject['score'] = scoreLabel record = Label(self.infoPanel, text="Record: "+str(self.record), bg='#fff') record.grid(row=0, column=1, padx=20, pady=10, sticky = W) self.interfaceObject['record'] = record n_generation = Label(self.infoPanel, text="Generation: "+str(self.n_generations), bg='#fff') n_generation.grid(row=1, column=1, padx=20, pady=10, sticky = W) self.interfaceObject['n_generation'] = n_generation general_record = Label(self.infoPanel, text="General record: "+str(self.general_record), bg='#fff') general_record.grid(row=2, column=1, padx=20, pady=10, sticky = W) self.interfaceObject['general_record'] = general_record weights = np.load('data/brain/best_w.npy') weights_flatten = weights.flatten() biases = np.load('data/brain/best_b.npy').flatten() self.nn_elements = draw_nn(width=self.width, height = self.height, nn_shape=[5, 2], weights = weights, weights_flatten = weights_flatten,biases = biases, canvas = self.canvas, padding=[50, 10, 400, 300], neuron_size=10) def animateGround(self): self.canvas.move(self.ground_id, -9, 0) self.canvas.move(self.ground_id_1, -9, 0) self.canvas.move(self.ground_id_2, -9, 0) #[left top right bottom] if(self.canvas.coords(self.ground_id)[0]<-400): self.canvas.move(self.ground_id, 1200, 0) if(self.canvas.coords(self.ground_id_1)[0]<-400): self.canvas.move(self.ground_id_1, 1200, 0) if(self.canvas.coords(self.ground_id_2)[0]<-400): self.canvas.move(self.ground_id_2, 1200, 0) self.ground_animation_id = self.canvas.after(20, self.animateGround) def run(self): if(self.mode == self.game_modes["game"]): self.prepareInterface() self.canvas.pack() self.prepareGame() self.animateGround() mainloop() elif(self.mode == self.game_modes["train"]): self.prepareInterface() self.canvas.pack() self.prepareTrain() self.animateGround() mainloop() elif(self.mode == self.game_modes["simulation"]): self.prepareInterface() self.canvas.pack() self.prepareSimulation() self.animateGround() mainloop() def decreaseDinos(self): self.dinosOnScreen-=1 self.colisionMonitor.dinosOnScreen = self.dinosOnScreen self.updateLabels() def updateGameParams(self, distance=None, speed=None, height=None, width=None): if(not distance is None): self.game_params['distance'] = distance if(not speed is None): self.game_params['speed'] = speed if(not height is None): self.game_params['height'] = height if(not width is None): self.game_params['width'] = width #print(self.game_params) def updateLabels(self): self.interfaceObject['speedLabel'].config(text="Speed: "+str(25 - self.game_params['speed'])+"/"+str(len(self.scoresCheckPoint))) self.interfaceObject['dinosAlive'].config(text="Dinos: "+str(self.dinosOnScreen)+"/"+str(self.initialDinoNum)) self.interfaceObject['score'].config(text="Score: "+str(self.score)) self.interfaceObject['record'].config(text="Record: "+str(self.record)) self.interfaceObject['n_generation'].config(text="Generation: "+str(self.n_generations)) self.interfaceObject['general_record'].config(text="General record: "+str(self.general_record)) # create game elements def prepareGame(self): self.dinos.append(Dino(self.master, self.canvas, DinoBrain(), self.game_params, self.decreaseDinos, mode=self.mode, game_modes=self.game_modes, color="black")) self.dinos.append(Dino(self.master, self.canvas, DinoBrain(), self.game_params, self.decreaseDinos, mode="train", game_modes=self.game_modes, color="red")) self.dinos[-1].brain.load() self.dinosOnScreen = 2 self.obstacleGenerator = ObstacleGenerator(self.master, self.canvas, self.updateGameParams, self.increaseScore) self.obstacleGenerator.updateObstaclesSpeed(self.game_params['speed']) self.obstacleGenerator.run() self.colisionMonitor = ColisionMonitor(self.master, self.canvas, self.stopGround, self.dinos, self.obstacleGenerator.obstacles, self.dinosOnScreen) self.colisionMonitor.run() # create train elements def prepareTrain(self): for i in range(self.initialDinoNum): self.dinosOnScreen+=1 dino = Dino(self.master, self.canvas, DinoBrain(), self.game_params, self.decreaseDinos, mode=self.mode, game_modes=self.game_modes) dino.brain.load() self.dinos.append(dino) for dino in self.dinos[1:]: dino.brain.mutate() self.obstacleGenerator = ObstacleGenerator(self.master, self.canvas, self.updateGameParams, self.increaseScore) self.obstacleGenerator.updateObstaclesSpeed(self.game_params['speed']) self.obstacleGenerator.run() self.colisionMonitor = ColisionMonitor(self.master, self.canvas, self.stopGround, self.dinos, self.obstacleGenerator.obstacles, self.dinosOnScreen) self.colisionMonitor.run() # create simulation elements def prepareSimulation(self): for i in range(self.initialDinoNum): self.dinosOnScreen+=1 dino = Dino(self.master, self.canvas, DinoBrain(), self.game_params, self.decreaseDinos, mode=self.mode, game_modes=self.game_modes) self.dinos.append(dino) self.obstacleGenerator = ObstacleGenerator(self.master, self.canvas, self.updateGameParams, self.increaseScore) self.obstacleGenerator.updateObstaclesSpeed(self.game_params['speed']) self.obstacleGenerator.run() self.colisionMonitor = ColisionMonitor(self.master, self.canvas, self.stopGround, self.dinos, self.obstacleGenerator.obstacles, self.dinosOnScreen) self.colisionMonitor.run() def stopGround(self): print("New gen") if(self.general_record<=self.score): self.general_record = self.score np.save('data/general/game.npy', np.array([self.general_record])) self.n_generations+=1 if(self.record<self.score): self.record = self.score self.resetGameParams() self.canvas.after_cancel(self.ground_animation_id) brain_index = None for i, dino in enumerate(self.dinos): if(dino.best): brain_index = i print("best: ", brain_index) if(self.mode == "train"): dino.brain.save() self.obstacleGenerator.updateObstaclesSpeed(self.game_params['speed']) self.obstacleGenerator.reset() for i, dino in enumerate(self.dinos): dino.reset() if(i != brain_index): dino.setBrain(self.dinos[brain_index].brain.getClone(True)) for i, dino in enumerate(self.dinos): dino.game_params = self.game_params dino.animate() dino.run() self.score = 0 self.dinosOnScreen = len(self.dinos) self.colisionMonitor.dinosOnScreen = self.dinosOnScreen self.updateLabels() self.animateGround() self.colisionMonitor.run() self.obstacleGenerator.run() def increaseScore(self, score): self.score+=score if(self.score in self.scoresCheckPoint): self.game_params['speed']-=1 self.obstacleGenerator.updateObstaclesSpeed(self.game_params['speed']) if(self.score==350 and self.mode == self.game_modes['train']): for dino in self.dinos: if(dino.onScreen): dino.brain.save() if(self.general_record<self.score): self.general_record = self.score self.updateLabels() def resetGameParams(self): self.game_params = {'distance': 100, 'speed': 25, 'height': 0, 'width': 50} def restart(self, event): for dino in self.dinos: dino.reset() self.resetGameParams() self.animateGround() self.obstacleGenerator.reset() self.obstacleGenerator.run()
class CellMapWidget(Frame): def __init__(self, master, cell_size: int, step_interval: int, cell_map: CellMap): self.cells_count = cell_map.cells_count self.cell_size = cell_size self.cell_map = cell_map self.step_interval = step_interval self.simulating = False self.logging = False self.canvas = Canvas(master, width=(self.cells_count * cell_size), height=(self.cells_count * cell_size), bg='white') self.canvas.pack(side=TOP) self.canvas.bind('<Button-1>', self.on_click) self.draw() def draw(self): self.draw_grid() self.draw_map() def on_click(self, event): x, y = event.x // self.cell_size, event.y // self.cell_size self.cell_map.map[x, y] = (self.cell_map.map[x, y] + 1) % 2 self.canvas.delete('all') self.draw() def draw_cell(self, x: int, y: int): self.canvas.create_rectangle(self.cell_size * x, self.cell_size * y, self.cell_size * (x + 1), self.cell_size * (y + 1), fill='black') def draw_grid(self): draw_line_func = self.canvas.create_line for i in range(0, self.cells_count * self.cell_size, self.cell_size): draw_line_func(0, i, self.cells_count * self.cell_size, i) for i in range(0, self.cells_count * self.cell_size, self.cell_size): draw_line_func(i, 0, i, self.cells_count * self.cell_size) def draw_map(self): draw_cell_func = self.draw_cell cells_count = self.cells_count for i in range(cells_count): for j in range(cells_count): if self.cell_map.map[i, j] == 1: draw_cell_func(i, j) def step(self): self.canvas.delete('all') self.cell_map.step() if self.logging: self.logger.log(self.cell_map.map) self.draw() def simulate_loop(self): if self.simulating: self.step() self.canvas.after(self.step_interval, self.simulate_loop) def on_simulate(self, indicator): self.simulating = not self.simulating self.simulate_loop() if indicator: if self.simulating: indicator.configure(bg='red') else: indicator.configure(bg='white') def on_randomize(self): self.canvas.delete('all') self.cell_map.randomize() if self.logging: self.logger.log(self.cell_map.map) self.draw() def on_clear(self): self.canvas.delete('all') self.cell_map.clear() if self.logging: self.logger.log(self.cell_map.map) self.draw() def on_set_config(self, new_map: np.ndarray): self.canvas.delete('all') self.cell_map.map = new_map if self.logging: self.logger.log(self.cell_map.map) self.draw() def on_start_log(self, session_name: str = 'default'): self.logging = True self.logger = Logger() self.logger.start_session(self.cell_map.map, session_name) def on_end_log(self): self.logger.end_session() self.logging = False def on_log(self, indicator, session_name: str = 'default'): if not self.logging: indicator.configure(bg='red') self.on_start_log(session_name) else: indicator.configure(bg='white') self.on_end_log()
class ConnectedFrame: def __init__(self, logicManager, root): self.logicManger = logicManager self.deviceName = self.logicManger.getDeviceName() self.battery = self.logicManger.getBattery() # images setup self.backgroundImg = None self.batteryImg = None self.logoutImg = None self.initPictures() # frame setup self.frame = None self.nameLabel = None self.batteryLabel = None self.moveLabel = None self.files_list = None self.logout_button = None self.timeUpdate = 1000 # in ms self.initFrame(root) def initPictures(self): self.backgroundImg = getPhoto('\\img\\MainScreen.png') self.batteryImg = getPhoto('\\img\\battery.png') self.logoutImg = getPhoto('\\img\\LogoutButton.png') def initFrame(self, root): self.frame = Canvas(root, bg=BLACK) self.frame.create_image(0, 0, anchor=NW, image=self.backgroundImg) self.frame.pack(expand="true", fill="both") y_grid = 1 x_grid = 0 pady = (45, 20) padx = 20 y_grid = self.initHeader(self.frame, y_grid, x_grid, pady, padx) pady = 0 y_grid = self.initMainBlock(self.frame, y_grid, x_grid, pady, padx) pady = 15 padx = 10 self.initButton(self.frame, y_grid, pady, padx) self.frame.after(self.timeUpdate, self.updateFrame) def initHeader(self, frame, y_grid, x_grid, pady, padx): rapper_frame = Frame(frame, bg=WHITE) inner_frame = Frame(rapper_frame, bg=DARK_GRAY_BLUE, height=100) inner_frame.pack() devicename = self.deviceName if devicename is not None and len(devicename) > 12: devicename = devicename[0:14] + '\n' + devicename[14:] self.nameLabel = Label(inner_frame, text=devicename, width=16, font=DEVICE_HEADER_FONT, bg=DARK_GRAY_BLUE, fg=WHITE) self.nameLabel.grid(row=0, column=0) battery = str(self.battery) + '% ' self.batteryLabel = Label(inner_frame, text=battery, width=85, font=BATTERY_HEADER_FONT, bg=DARK_GRAY_BLUE, image=self.batteryImg, fg=BLACK, compound="center") self.batteryLabel.grid(row=0, column=1, padx=(15, 0)) rapper_frame.grid(row=y_grid, column=x_grid, rowspan=1, columnspan=1, padx=padx, pady=pady) return y_grid + 1 def initMainBlock(self, frame, y_grid, x_grid, pady, padx): rapper_frame = Frame(frame, bg=WHITY_BLUE) rapper_frame.grid(row=y_grid, column=x_grid, rowspan=1, columnspan=2) self.initMouseMovementView(rapper_frame, y_grid, 0, pady, padx) self.initFilesView(rapper_frame, y_grid + 1, 0, pady, 0) return y_grid + 2 def initMouseMovementView(self, frame, y_grid, x_grid, pady, padx): inner_frame = Frame(frame, bg=WHITY_BLUE) inner_frame.grid(row=y_grid, column=x_grid, rowspan=1, columnspan=1, padx=(4, 11)) label = Label(inner_frame, text='Last Mouse Move:', width=18, font=BATTERY_HEADER_FONT, bg=DARK_GRAY_BLUE, fg=WHITE) label.pack(side="left") self.moveLabel = Label(inner_frame, text='', width=7, font=BATTERY_HEADER_FONT, bg=WHITY_BLUE, fg=BLACK) self.moveLabel.pack(side="right") return y_grid + 2 def initFilesView(self, frame, y_grid, x_grid, pady, padx): inner_frame = Frame(frame, bg=BLACK) inner_frame.grid(row=y_grid, column=x_grid, rowspan=2, columnspan=2, padx=padx, pady=pady) title = Label(inner_frame, text='Recived Files:', width=26, font=BATTERY_HEADER_FONT, bg=DARK_GRAY_BLUE, fg=WHITE) title.pack() def open(event): file = self.files_list.curselection() file = self.files_list.get(file) self.logicManger.openFile(file) self.files_list = Listbox(inner_frame, bd=0, font=LISTBOX_FONT, width=29, height=10) self.files_list.pack(side="left", fill="y", padx=(1, 0), pady=1) self.files_list.contains = lambda x: x in self.files_list.get(0, "end") self.files_list.bind('<Double-1>', open) scrollbar = Scrollbar(inner_frame, orient="vertical") scrollbar.config(command=self.files_list) scrollbar.pack(side="right", fill="y", padx=(0, 2), pady=1) self.files_list.config(yscrollcommand=scrollbar.set) return y_grid + 2 def initButton(self, frame, y_grid, pady, padx): rapper_frame = Frame(frame, bg=WHITE) self.logout_button = Button(rapper_frame, image=self.logoutImg, bg=GRAY, font=SMALL_BUTTON_FONT) self.logout_button.pack(anchor=E) rapper_frame.grid(row=y_grid, column=0, columnspan=2, pady=pady) def setLogoutButtonFunction(self, func): self.logout_button["command"] = func def hideFrame(self): self.frame.pack_forget() def updateFrame(self): self.getFiles() self.getDirection() self.getBattery() self.frame.after(self.timeUpdate, self.updateFrame) def getFiles(self): files = self.logicManger.getFiles() for file in files: if not self.files_list.contains(file): name = self.logicManger.getFileName(file) arr = name.split('.') print('name recived ', name) path = filedialog.asksaveasfilename(initialfile=name, filetypes=[(arr[-1], '*.' + arr[-1]) ]) arr_p = path.split('/') if name != arr_p[-1]: path += '.' + arr[-1] self.logicManger.saveFileWithPath(file, path) index = self.files_list.size() self.files_list.insert(index, file) def getDirection(self): direction = self.logicManger.getDirection() self.moveLabel['text'] = direction def getBattery(self): battery = self.logicManger.getBattery() battery = str(battery) + '% ' self.batteryLabel['text'] = battery
class Jeu(): def __init__(self): # crée ma fanetre du jeu space invader self.vie = 3 self.score = 0 self.nb_aliens = 12 self.liste_alien = [] #Contient les instances de la classe Alien #Crée la fenetre principale self.fenetre_principale = Tk() self.fenetre_principale.title("Space invaders") def f_lancerjeu( self): #lance le jeu apres avoir appuyé sur le bouton jouer # dimension écran_jeu self.dim_ecran_jeu_x = 800 self.dim_ecran_jeu_y = 600 #enleve les boutons de lecran self.boutonJouer.destroy() self.ecran_menu.destroy() # crée l'écran de jeu self.ecran_jeu = Canvas( self.fenetre_principale, bg='white' ) #creation d'un canvas a linterieur de la fenetre tkinter auquel on peut ajouter des éléments self.ecran_jeu.pack( padx=5, pady=5) #inclusion, affichage du canvas dans la fenetre self.ecran_jeu.config(height=self.dim_ecran_jeu_y, width=self.dim_ecran_jeu_x) #dimension ecran_jeu #Crée 12 instances de Alien et les place dans la liste for indice_alien in range(self.nb_aliens): self.alien = Alien(self, indice_alien) #cree les aliens self.liste_alien.append(self.alien) #cree les aliens self.joueur = Joueur(self) #cree le vaisseau self.f_comportement_alien( ) # fct qui définit le comportement des aliens. def f_comportement_alien(self): for alien in self.liste_alien: #comportement a adopter pour chacun des aliens en vie alien.f_deplacement() alien.f_tirer() if self.liste_alien != []: #se répete tant qu'il y a toujours un alien sur le terrain self.ecran_jeu.after(30 * len(self.liste_alien), self.f_comportement_alien) def f_quit(self): #fenetre confirmation quitter le jeu self.Quitt = Tk() self.Quitt.title("Etes vous sur de quitter ?") self.Quitt.geometry('50x25') #dimension fentre quitter self.boutonOui = Button( self.Quitt, bg='red', text="Oui", command=self.f_quitter) #bouton qui lance la fct quitter self.boutonNon = Button(self.Quitt, bg='blue', text="Non", command=self.Quitt.destroy ) # bouton qui renvoie a la fenetre principale self.boutonOui.grid(row=1, column=1) #placement boutons self.boutonNon.grid(row=1, column=2) self.Quitt.mainloop() def f_quitter(self): # quitte le jeu apres avoir cliqué sur oui self.Quitt.destroy() self.fenetre_principale.destroy() def f_affichage(self): #cree le menu # canvas ecran de jeu self.ecran_menu = Canvas( self.fenetre_principale, bg='white' ) #creation d'un canvas, zone de dessin a linterieur de la fenetre tkinter auquel on peut ajouter des éléments self.ecran_menu.pack( padx=5, pady=5) #inclusion, affichage du canvas dans la fenetre # affichage image menu self.img_ouverture = PhotoImage(file="image_menu.gif") self.ecran_menu.create_image(0, 0, anchor="nw", image=self.img_ouverture) self.ecran_menu.config(height=self.img_ouverture.height(), width=self.img_ouverture.width()) self.ecran_menu.pack() #bouton jouer self.boutonJouer = Button(self.fenetre_principale, text="Jouer !", fg='red', command=self.f_lancerjeu) self.boutonJouer.pack() #bouton quitter self.boutonQuit = Button(self.fenetre_principale, text="Quitter", activebackground='red', activeforeground='white', command=self.f_quit) self.boutonQuit.pack(side='bottom') #Label vie self.affichage_vie = StringVar() self.affichage_vie.set('Vie : ' + str(self.vie)) self.texteLabel_vie = Label(self.fenetre_principale, textvariable=self.affichage_vie) self.texteLabel_vie.pack(side='bottom') #label score self.affichage_score = StringVar() self.affichage_score.set('Score : ' + str(self.score)) self.texteLabel_score = Label(self.fenetre_principale, textvariable=self.affichage_score) self.texteLabel_score.pack(side='bottom') self.fenetre_principale.mainloop()
class OrbitViewWindow(): def __init__(self, auscale, timestep, time_increment=1, start_time=None): """time_increment is in days. start_time is a an ephem.Date object. """ self.auscale = auscale self.timestep = timestep self.stepping = True self.year = 0 if start_time: self.time = start_time else: self.time = ephem.Date(datetime.now()) - ephem.hour * 24 * 7 print("Start time:", ephem.Date(self.time)) self.opp_date, self.closest_date = find_next_opposition(self.time) # print("Next opposition:", self.opp_date) # print("Next closest:", self.closest_date) self.time_increment = ephem.hour * time_increment * 24 self.linewidth = 3 self.width = 1024 self.height = 768 self.halfwidth = self.width / 2. self.halfheight = self.height / 2. self.dist_scale = self.halfheight / self.auscale tkmaster = Tk() tkmaster.title("Mars Oppositions") self.canvas = Canvas(tkmaster, bg="black", width=self.width, height=self.height) # Start with just the Sun sunrad = 20 self.canvas.create_oval(self.width / 2 - sunrad, self.height / 2 - sunrad, self.width / 2 + sunrad, self.height / 2 + sunrad, fill="yellow") self.canvas.pack() tkmaster.bind("<KeyPress-q>", sys.exit) tkmaster.bind("<KeyPress-space>", self.toggle_stepping) print(table_header) # Schedule the first draw self.step_draw() def toggle_stepping(self, key): self.stepping = not self.stepping def step_draw(self): """Calculate and draw the next position of each planet. """ # If we don't call step_draw at all, we'll never get further key events # that could restart the animation. So just step at a much slower pace. if not self.stepping: self.canvas.after(500, self.step_draw) return # Adding a float to ephem.Date turns it into a float. # You can get back an ephem.Date with: ephem.Date(self.time). self.time += self.time_increment for p in (earth, mars): p["obj"].compute(self.time) # ephem treats Earth specially, what a hassle! # There is no ephem.Earth body; ephem.Sun gives the Earth's # hlon as hlon, but I guess we need to use earth_distance. oppy = False if p["name"] == "Earth": hlon = p["obj"].hlon sundist = p["obj"].earth_distance earthdist = 0 size = 0 else: hlon = p["obj"].hlon sundist = p["obj"].sun_distance earthdist = p["obj"].earth_distance size = p["obj"].size if abs(self.time - self.opp_date) <= .5: oppy = True if self.opp_date < self.closest_date: print(table_format % (self.opp_date, earthdist, size), "Opposition") print( table_format % (self.closest_date, earthdist, size), "Closest approach") else: print( table_format % (self.closest_date, earthdist, size), "Closest approach") print(table_format % (self.opp_date, earthdist, size), "Opposition") xn, yn = self.planet_x_y(hlon, sundist) radius = 10 if oppy: # Create outline circles for Mars and Earth at opposition. # xn, yn should be Mars since Earth was done first. self.canvas.create_oval(xn - radius, yn - radius, xn + radius, yn + radius, outline=p["color"], width=3) earthx = earth["xypath"][-2] earthy = earth["xypath"][-1] self.canvas.create_oval(earthx - radius, earthy - radius, earthx + radius, earthy + radius, outline=earth["color"], width=3) localtz = datetime.now().astimezone().tzinfo oppdate = ephem.to_timezone(self.opp_date, localtz) opp_str = oppdate.strftime("%Y-%m-%d") + \ '\n%.3f AU\n%.1f"' % (earthdist, size) if xn < self.width / 2: if yn < self.height / 2: anchor = "se" else: anchor = "ne" xtxt = xn - radius else: if yn < self.height / 2: anchor = "sw" else: anchor = "nw" xtxt = xn + radius ytxt = yn txtobj = self.canvas.create_text(xtxt, ytxt, fill="white", justify=LEFT, font=('sans', 14, 'bold'), anchor=anchor, text=opp_str) # Make sure it's not offscreen xt1, yt1, xt2, yt2 = self.canvas.bbox(txtobj) if xt1 < 0: xtxt -= xt1 elif xt2 > self.width: xtxt -= (xt2 - self.width) if yt1 < 0: ytxt -= yt1 elif yt2 > self.height: ytxt -= yt2 - self.height self.canvas.coords(txtobj, xtxt, ytxt) # Done with this opposition: find the next one. self.opp_date, self.closest_date \ = find_next_opposition(self.time + 500) p["xypath"].append(int(xn)) p["xypath"].append(int(yn)) if p["line"]: self.canvas.coords(p["line"], p["xypath"]) self.canvas.coords(p["disk"], xn - radius, yn - radius, xn + radius, yn + radius) else: p["line"] = self.canvas.create_line(xn, yn, xn, yn, width=self.linewidth, fill=p["color"]) p["disk"] = self.canvas.create_oval(xn - radius, yn - radius, xn + radius, yn + radius, fill=p["color"]) p["path"].append((hlon, sundist, earthdist, size)) if self.stepping: self.canvas.after(self.timestep, self.step_draw) def planet_x_y(self, hlon, dist): return (dist * self.dist_scale * math.cos(hlon) + self.halfwidth, dist * self.dist_scale * math.sin(hlon) + self.halfheight)
if (event.delta > 0): mscale *= 1.1 canvas.config(width=neural.XMAP * mscale, height=neural.YMAP * mscale) canvas.scale("all", 0, 0, 1.1, 1.1) elif (event.delta < 0): mscale *= 0.9 canvas.config(width=neural.XMAP * mscale, height=neural.YMAP * mscale) canvas.scale("all", 0, 0, 0.9, 0.9) root = Tk() root.title("Darwin") root.resizable(0, 0) canvas = Canvas(root, width=neural.XMAP, height=neural.YMAP, bd=0, highlightthickness=0, background='white') canvas.pack() # full view to see all creatures, else we follows one (global ugly variable) fullview = True world = World(Animal, Plant) canvas.bind("<KeyRelease>", world.keyup) canvas.focus_set() canvas.bind("<MouseWheel>", zoomer) # Hack to make zoom work on Windows root.bind_all("<MouseWheel>", zoomer) canvas.after(100, world.display) root.mainloop()