def __init__(self, width=1024, height=600): """ Create pong court of 'width' and 'height' """ # Get __init__ from _Screen super().__init__() # Get __init__ from TurtleScreen (parent class of _Screen) TurtleScreen.__init__(self, self._canvas) # Borrow piece of code from turtle module, to initialize screen if Turtle._screen is None: Turtle._screen = self # Setup court self.width = width self.height = height self.setup(self.width + 100, self.height + 50) self.screensize(self.width, self.height) self.title("Pong") self.bgcolor("black") self.delay(8) # Define size of score board, above the play field self.score_height = self.height / 10 # Offset 0 axis line, due to score bar self.yzero = -(self.height / 2 - (self.height - self.score_height) / 2) self.top_border = ((self.height / 2) - self.score_height) self.low_border = -self.height / 2 self.right_border = self.width / 2 self.left_border = -self.width / 2
def __init__(self, parent, levels): self.levels = levels # Toggles screen update rate self.slow_drawing = False # Draw button button = Button(parent, text='Draw Fractal', command=self._draw_click) button.pack() width, height = (600, 600) self.canvas = Canvas(parent, width=600, height=600) # Constrain resizing to a 1:1 aspect ratio self.canvas.winfo_toplevel().aspect(1, 1, 1, 1) self.canvas.pack(fill=BOTH, expand=YES) # Setup a turtle self.turtleScreen = TurtleScreen(self.canvas) # 5px of padding self.turtleScreen.setworldcoordinates(-5, -height - 5, width + 5, 5) self.turtle = RawTurtle(self.turtleScreen) self.turtleScreen.colormode(255) # Listen to resize events self.canvas.bind('<Configure>', self._resize_and_draw) # Do an initial draw self.slow_drawing = True self._resize_and_draw() self.slow_drawing = False
class Ventana(): def __init__(self, titulo, alto, ancho): assert isinstance(titulo, str) assert isinstance(alto, int) and alto > 0 assert isinstance(ancho, int) and ancho > 0 ## Crea la ventana y un canvas para dibujar self.root = TK.Tk() self.root.title(titulo) self.canvas = TK.Canvas(self.root, width=ancho, height=alto) self.canvas.pack() ## Crea un TurtleScreen y la tortuga para dibujar self.fondo_ventana = TurtleScreen(self.canvas) self.fondo_ventana.setworldcoordinates(0, alto, ancho, 0) ## Establece el color de fondo self.canvas["bg"] = "blue" self.canvas.pack() ## Crea una tortuga para dibujar self.pencil = RawTurtle(self.fondo_ventana) self.pencil.pencolor("white")
class TkRenderer(BaseRenderer): def __init__(self, width, height, title="NinjaTurtle"): self.width = width self.height = height self.window_title = title root = Tk() root.wm_title(self.window_title) window = TK.Canvas(master=root, width=self.width, height=self.height) window.pack() self.screen = TurtleScreen(window) self.screen.tracer(0, 0) self.turtles = dict() def create_turtle(self, model, init=None, shape='classic'): # TODO use init backend = RawTurtle(canvas=self.screen) model.backend = backend self.turtles[model.id] = model def render(self): for model in self.turtles.values(): data = model.data turtle = model.backend if data[0] != turtle.xcor() or data[1] != turtle.ycor(): turtle.setpos(data[0], data[1]) if turtle.heading() != data[4]: turtle.setheading(data[4]) self.screen.update()
def Rank(): root = TK.Tk() cv1 = TK.Canvas(root, width=400, height=200) cv1.pack() s1 = TurtleScreen(cv1) s1.bgcolor("#42f4ad") t = RawTurtle(s1) t.hideturtle() t.penup() t.goto(-50,70) t.write("내가 예측한 1등: "+ guess) t.goto(-50,50) if PlayerNumber>=1: t.write("1등 : "+PlayerRank[0]) t.goto(-50,40) if PlayerNumber>=2: t.write("2등 : "+PlayerRank[1]) t.goto(-50,30) if PlayerNumber>=3: t.write("3등 : "+PlayerRank[2]) t.goto(-50,20) if PlayerNumber>=4: t.write("4등 : "+PlayerRank[3]) t.goto(-50,10) if PlayerNumber>=5: t.write("5등 : "+PlayerRank[4]) t.goto(-100,-20) if(guess==PlayerRank[0]): t.write("축하드립니다. 1등을 맞추셨습니다.") else: t.write("1등을 맞추지 못했습니다.")
def create_window(self): self.root = tk.Tk() self.canvas = tk.Canvas(self.root, width=SCREEN_SIZE, height=SCREEN_SIZE) self.canvas.pack() self.wn = TurtleScreen(self.canvas) self.root.title("Braitenberg's Vehicle #2") self.wn.onkey(self.start_stop, "space") self.wn.listen() self.button_frame = tk.Frame(self.root) self.button_frame.pack() self.start_button = tk.Button(self.button_frame, text="Start", fg="black", command=self.start_stop) self.reset_button = tk.Button(self.button_frame, text="Reset", fg="black", command=self.reset) self.quit_button = tk.Button(self.button_frame, text="Quit", fg="black", command=self.quit) self.start_button.pack(side=tk.LEFT) self.reset_button.pack(side=tk.LEFT) self.quit_button.pack(side=tk.LEFT)
class KonnaRakendus(Frame): """Frame, mida saab suvalises teises rakenduses kasutada""" def __init__(self, parent): super().__init__(parent) # Sisuliselt sama kui Tk() # Määrame rea ja veeru indeksiga 0 kõige kaalukamateks self.rowconfigure(index=0, weight=1) self.columnconfigure(index=0, weight=1) # Tekita lõuend, seo see root objektiga c = Canvas(self) # Lõuendi nähtavaks muutmiseks paigutame ta lahtrisse 0,0 c.grid(column=0, row=0, sticky=(N, S, W, E)) # Seo lõuendiga TurtleScreen ja seo TurtleScreeniga konn self.ts = TurtleScreen(c) self.algseis() # Tekitame nuppude paneeli f f = Frame(self) f.grid(column=0, row=1) # Tekita edasiliikumise nupp b = Button(f, text="Edasi", command=self.edasi) b.grid(column=0, row=0) # Tekita vasakpöörde nupp bv = Button(f, text="Vasakule", command=self.vasakule) bv.grid(column=1, row=0) # Tekita parempöörde nupp bp = Button(f, text="Paremale", command=self.paremale) bp.grid(column=2, row=0) # Tekita muutuja kiirus ja sildiga tekstikast kiiruse sisestamiseks self.kiirus = IntVar() self.kiirus.set(100) lbl_kiirus = Label(f, text=" Kiirus: ") lbl_kiirus.grid(column=3, row=0) entry_kiirus = Entry(f, textvariable=self.kiirus) entry_kiirus.grid(column=4, row=0) # Tekita algseisu nupp ba = Button(f, text="Algseis", command=self.algseis) ba.grid(column=5, row=0) def algseis(self): self.ts.clear() self.ts.bgcolor('cyan') self.konn = Frog(self.ts, x=0, y=0) def edasi(self): self.konn.forward(self.kiirus.get() / 2) self.konn.jump(self.kiirus.get() / 2) def vasakule(self): self.konn.left(10) def paremale(self): self.konn.right(10)
def init_screen(self): # intialise screen and turn off auto-render root = Tk() root.wm_title(self.window_title) window = TK.Canvas(master=root, width=self.width, height=self.height) window.pack() self.screen = TurtleScreen(window) self.screen.tracer(0, 0)
def __init__(self): super().__init__() TurtleScreen.__init__(self, self._canvas) if Turtle._screen is None: Turtle._screen = self self.setup(500,500) self.screensize(1000,1000) self.title("Title") self.bgcolor("black") self.root = self._canvas._root() self.menubar = tk.Menu(self.root)
def initialize(self, hOptions): self.screen = TurtleScreen(self.tkWidget) self.tkTurtle = RawTurtle(self.screen) self.screen.mode('world') self.tkTurtle.setheading(90) if 'speed' in hOptions: self.curSpeed = int(hOptions['speed']) else: self.curSpeed = 1 self.lSaveStack = [] # stack to save/restore state on
def construct(self): """Constructs graphics.""" self.window = TurtleScreen(self.canvas) self.window.setworldcoordinates(*__class__._WORLD_COORDS) self.window.bgcolor(102, 51, 0) self.peg_dir = [] self.arrow_dir = [] self.graveyard = [] self.path_finder = PathFinder() self._draw_board() self._place_pegs() self._add_callbacks()
def setup_keypress( win: turtle.TurtleScreen, current_direction: Callable[[], Direction], update_direction: Callable[[Direction], None], ): win.listen() win.onkeypress( lambda: update_direction(right_pressed(current_direction())), "Right") win.onkeyrelease( lambda: update_direction(right_released(current_direction())), "Right") win.onkeypress(lambda: update_direction(left_pressed(current_direction())), "Left") win.onkeyrelease( lambda: update_direction(left_released(current_direction())), "Left")
def __init__(self, cv): ts = TurtleScreen(cv) RawTurtle.__init__(self, ts) # self.turtleRef = turt self.ts = ts ts.listen() self.isDrawing = False self.penup() self.speed(0) canvas = cv canvas.bind('<Button-1>', self.onDraw) canvas.bind('<Button1-ButtonRelease>', self.onStopDrawing) canvas.bind('<Motion>', self.move)
def main(): root = TK.Tk() cv1 = TK.Canvas(root, width=300, height=200, bg='#ddffff') cv2 = TK.Canvas(root, width=300, height=200, bg='#ffeeee') cv1.pack() cv2.pack() s1 = TurtleScreen(cv1) s1.bgcolor(0.85, 0.85, 1) s2 = TurtleScreen(cv2) s2.bgcolor(1, 0.85, 0.85) p = RawTurtle(s1) q = RawTurtle(s2) p.color('red', (1, 0.85, 0.85)) p.width(3) q.color('blue', (0.85, 0.85, 1)) q.width(3) for t in (p, q): t.shape('turtle') t.lt(36) q.lt(180) for t in (p, q): t.begin_fill() for i in range(5): for t in (p, q): t.fd(50) t.lt(72) for t in (p, q): t.end_fill() t.lt(54) t.pu() t.bk(50) return 'EVENTLOOP'
def main(): root = TK.Tk() cv1 = TK.Canvas(root, width=300, height=200, bg="#ddffff") cv2 = TK.Canvas(root, width=300, height=200, bg="#ffeeee") cv1.pack() cv2.pack() s1 = TurtleScreen(cv1) s1.bgcolor(0.85, 0.85, 1) s2 = TurtleScreen(cv2) s2.bgcolor(1, 0.85, 0.85) p = RawTurtle(s1) q = RawTurtle(s2) p.color("red", (1, 0.85, 0.85)) p.width(3) q.color("blue", (0.85, 0.85, 1)) q.width(3) for t in p,q: t.shape("turtle") t.lt(36) q.lt(180) for t in p, q: t.begin_fill() for i in range(5): for t in p, q: t.fd(50) t.lt(72) for t in p,q: t.end_fill() t.lt(54) t.pu() t.bk(50) return "EVENTLOOP"
def __init__(self, width, height, borders=wrap): self.width = width self.half_width = width // 2 self.height = height self.half_height = height // 2 self.borders = borders # intialise screen and turn off auto-render window = TK.Canvas(width=width, height=height) window.pack() self.screen = TurtleScreen(window) self.screen.tracer(0, 0) self.fps = 0 self.done = True self.turtles = [] self.update_freq = 1000 #int(1 / 30.0 * 1000)
def __init__(self, titulo, alto, ancho): assert isinstance(titulo, str) assert isinstance(alto, int) and alto > 0 assert isinstance(ancho, int) and ancho > 0 self.root = TK.Tk() self.root.title(titulo) self.canvas = TK.Canvas(self.root, width=ancho, height=alto) self.canvas.pack() self.fondo_ventana = TurtleScreen(self.canvas) self.fondo_ventana.setworldcoordinates(0, alto, ancho, 0) self.canvas["bg"] = "gold" self.canvas.pack() self.pencil = RawTurtle(self.fondo_ventana) self.pencil.pencolor("white")
def __init__(self): self.win = tk.Tk() self.win.geometry("640x400") self.canvas = Canvas() self.canvas.pack() self.scr = TurtleScreen(self.canvas) self.t = RawTurtle(self.scr) self.btn = Button(self.win, text="Press me!", command=self.do_action()) self.btn.pack()
def crea_tablero(titulo, alto, ancho): assert isinstance(titulo, str) assert isinstance(alto, int) and alto > 0 assert isinstance(ancho, int) and ancho > 0 ## Crea la ventana y un canvas para dibujar root = TK.Tk() root.title(titulo) canvas = TK.Canvas(root, width=ancho, height=alto) canvas.pack() ## Crea un TurtleScreen y la tortuga para dibujar global fondo_tablero fondo_tablero = TurtleScreen(canvas) ## Establece el fondo de la pizarra electrónica canvas["bg"] = "black" canvas.pack() global pizarra pizarra = RawTurtle(fondo_tablero) dibuja_leds() ## Establece las funciones para capturar las teclas fondo_tablero.onkeypress(lambda: detiene(), "Escape") por_siempre() fondo_tablero.listen() print("terminó") root.mainloop()
def __init__(self,x): self.it=x S="D++D++D" for i in range(self.it): pesan="" for j in range(len(S)): if S[j]=="D": pesan+="D-D++D-D" else: pesan+=S[j] S=pesan root3=tk.Tk() if self.it!=1: root3.title('Koch Fractal with '+str(self.it)+' iterations') else: root3.title('Koch Fractal with an iteration') self.canvas=ScrolledCanvas(master=root3,width=1000,height=1000) self.canvas.pack(fill=tk.BOTH,expand=tk.YES) screen=TurtleScreen(self.canvas) screen.screensize(10000,10000) self.turtle=RawTurtle(screen) self.turtle.ht() self.turtle.speed(0) for i in range(len(S)): if S[i]=="D": self.turtle.forward(10) elif S[i]=="+": self.turtle.right(60) else: self.turtle.left(60) self.canvas.bind('<MouseWheel>',self.zoom) screen.mainloop()
def __init__(self, title="Hangman"): super().__init__() self.title(title) self.geometry("720x600") self.configurationFile = "level.conf" self.dataFile = "hangman.dat" self.dataPath = "data/" self.__hp = HP.THangman(self) if os.path.exists(self.dataPath + self.dataFile): self.deserialize() self.output = tk.StringVar() self.output.set(self.__hp.getLetters) self.info = tk.StringVar() alphabets = 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', \ 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'Å', 'Ä', 'Ö', '-' self.Buttons = ButtonsBlock(self, alphabets, 15) self.Buttons.grid(row=0, column=0, columnspan=3, padx=10, pady=5) self.frame2 = tk.Frame(self).grid(row=2) tk.Label(self.frame2, textvariable=self.output).grid(pady=10, columnspan=5) self.frame3 = tk.Frame(self).grid(row=3) tk.Label(self.frame3, textvariable=self.info).grid(padx=10, pady=10, columnspan=5, sticky=tk.W + tk.E) tk.Button(self, text="Guess a new word", command=self.new).grid(row=5, padx=30, pady=5, sticky=tk.E + tk.W, columnspan=5) self.canvas = Canvas(self, width=500, height=350) self.canvas.grid(row=8, column=0, columnspan=5, padx=10, sticky=tk.W + tk.E + tk.S + tk.N) self.turtle_screen = TurtleScreen(self.canvas) self.raw_turtle = RawTurtle(self.canvas) self.raw_turtle.hideturtle() self.raw_turtle.speed(0) self.restoreGUI() message = "You are currently playing in " + levels[ self.__hp.level] + " level" messagebox.showinfo("Level of difficulty", message) self.protocol("WM_DELETE_WINDOW", self.close)
def __init__(self, width, height, title="NinjaTurtle"): self.width = width self.height = height self.window_title = title root = Tk() root.wm_title(self.window_title) window = TK.Canvas(master=root, width=self.width, height=self.height) window.pack() self.screen = TurtleScreen(window) self.screen.tracer(0, 0) self.turtles = dict()
def draw(ans): """Вывод топологической схемы""" global xax, moves, oboz, window turx, tury = xax - int(xax*0.3), int(yax*0.25) bg_def = window.cget('bg') canvas = Canvas(window, relief='sunken', borderwidth=5, width=turx, height=tury, background=bg_def) canvas.place(relx=0.5, rely=0.1, y=int(yax*0.19), anchor=CENTER) screen = TurtleScreen(canvas) global turtle turtle = RawTurtle(canvas) turtle.speed(5) turtle.hideturtle() allen = (turx - int(xax*0.2)) global let if len(ans) > 7: if ans[5] == 1 and ans[8] == 1: let = allen // 3 else: if ans[5] == 1: let = allen // 4 elif ans[8] == 1: let = allen // 4 else: let = allen // 5 if ans[5] == 2: allen -= let//2 if ans[8] == 2: allen -= let//2 else: if ans[5] == 1: let = allen // 2 else: let = allen // 3 if ans[5] == 2: allen -= let//2 turtle.color('white') turtle.up() turtle.goto(x=-allen // 2, y=-int(yax*0.09)) turtle.down() turtle.color('black') turtle.dot(5, 'black') turtle.write('A') for i in [moves[k + 1][x] for k, x in enumerate(ans) if k + 1 in moves]: print(i) eval(i)
class TurtleCanvas: window = tk.Tk() canvas = ScrolledCanvas(master=window, width=800, height=600) canvas.pack(fill=tk.BOTH, expand=tk.YES) screen = TurtleScreen(canvas) turtle = RawTurtle(screen) def __init__(self, x, y): cWidth = 800 cHeight = 600 self.x = x self.y = y self.turtle.speed("fastest") self.window.geometry('%dx%d+%d+%d' % (cWidth, cHeight, x, y)) self.canvas.bind('<MouseWheel>', self.zoom) def zoom(self, event): amount = 0.9 if event.delta < 0 else 1.1 self.canvas.scale(tk.ALL, 0, 0, amount, amount) def square(self, sidelength=50): for i in range(4): self.turtle.forward(sidelength) self.turtle.right(90) def triangle(self, sidelength=50): point = self.turtle point.color("black") point.speed("fastest") for i in range(3): point.forward(sidelength) point.right(120) self.window.mainloop() def star(self, sidelength=50): point = self.turtle point.color("black") point.speed("fastest") for i in range(5): point.forward(sidelength) point.right(145) self.window.mainloop() def squareDriver(self, steps): i = 0 for j in range(steps): self.square(20 + i) self.turtle.right(2) i += 1
def draw(lines): from tkinter import Tk, LEFT from turtle import Canvas, RawTurtle, TurtleScreen # set up the environment root = Tk() canvas = Canvas(root, width=800, height=800) canvas.pack() s = TurtleScreen(canvas) t = RawTurtle(canvas) t.speed(0) t.width(1) for line in lines: x, y = line[0] t.up() t.goto(x * 800 / 1024 - 400, -(y * 800 / 1024 - 400)) for point in line: t.down() t.goto(point[0] * 800 / 1024 - 400, -(point[1] * 800 / 1024 - 400)) s.mainloop()
class FractalCanvas(object): def __init__(self, parent, levels): self.levels = levels # Toggles screen update rate self.slow_drawing = False # Draw button button = Button(parent, text='Draw Fractal', command=self._draw_click) button.pack() width, height = (600, 600) self.canvas = Canvas(parent, width=600, height=600) # Constrain resizing to a 1:1 aspect ratio self.canvas.winfo_toplevel().aspect(1, 1, 1, 1) self.canvas.pack(fill=BOTH, expand=YES) # Setup a turtle self.turtleScreen = TurtleScreen(self.canvas) # 5px of padding self.turtleScreen.setworldcoordinates(-5, -height - 5, width + 5, 5) self.turtle = RawTurtle(self.turtleScreen) self.turtleScreen.colormode(255) # Listen to resize events self.canvas.bind('<Configure>', self._resize_and_draw) # Do an initial draw self.slow_drawing = True self._resize_and_draw() self.slow_drawing = False def _draw_click(self): """Handler for button click.""" # Draw the fractal slowly when we press the button, but quickly # if we're drawing for a resize self.slow_drawing = True self._resize_and_draw() self.slow_drawing = False def _resize_and_draw(self, event=None): """Handler for when the canvas resizes (due to a window resize).""" self.draw(self.canvas.winfo_width(), self.canvas.winfo_height()) def draw(self, width, height): """Draws the fractal.""" pass def update_screen(self): """ Conditionally updates the screen. If self.slow_drawing is set, then this method forces image data to be pushed to the screen, otherwise it does nothing. """ if self.slow_drawing: self.turtleScreen.update()
def __init__(self,canvas): #self.window = master #self.canvas = ScrolledCanvas(master=self.window, width=800, height=600) #self.canvas.pack(fill=tk.BOTH, expand=tk.YES) self.canvas = canvas self.screen = TurtleScreen(canvas) self.turtle = RawTurtle(self.screen) self.turtle.speed("fastest") #self.window.geometry('%dx%d+%d+%d' % (cWidth, cHeight, x, y)) self.canvas.bind('<MouseWheel>', self.zoom) self.canvas.bind("<ButtonPress-1>", self.scroll_start) self.canvas.bind("<B1-Motion>", self.scroll_move) self.canvas.bind("<ButtonPress-3>", self.changeDirection) #self.canvas.bind("<c>", self.changeColor) self.rightDirection = True
def __init__(self): self.win = Tk() self.btn = Button(self.win, text="확인", command=self.press) self.btn.pack() self.canvas = Canvas(self.win) self.canvas.config(width=600, height=300) self.canvas.pack() self.src = TurtleScreen(self.canvas) self.t = RawTurtle(self.src) self.t.pensize(5) # 서버와 소켓 연결 self.client = socket(AF_INET, SOCK_STREAM) self.client.connect(('127.0.0.1',9999))
def main(pattern: str) -> None: master = Tk() canvas = ScrolledCanvas(master) canvas.pack() screen = TurtleScreen(canvas) screen.colormode(255) turt = RawTurtle(screen) draw_dots(turt) turt.pencolor((178, 34, 34)) draw_pattern(turt, pattern) screen.mainloop()
def __init__(self,canvas,h,k,xr,yr,size,speed,screensize = 500): screen = TurtleScreen(canvas) RawTurtle.__init__(self,screen) self.screen = screen self.screen.tracer(0) self.h = h self.k = k self.xr = xr self.yr = yr self.size = size self.speedturt = speed self.d = 0.05 self.nofunc = 0 self.screensize = screensize self.hideturtle() self.pensize(1) self.reset_var()
def __init__(self, nrOfDiscs, speed): root = Tk() root.title("TOWERS OF HANOI") cv = Canvas(root, width=440, height=210, bg="gray90") cv.pack() cv = TurtleScreen(cv) self.hEngine = HanoiEngine(cv, nrOfDiscs, speed, self.displayMove) fnt = ("Arial", 12, "bold") # set attributes: nr of discs, speed; display move count attrFrame = Frame(root) # contains scales to adjust game's attributes self.discsLbl = Label(attrFrame, width=7, height=2, font=fnt, text="") self.discs = Scale(attrFrame, from_=1, to_=10, orient=HORIZONTAL, font=fnt, length=0, showvalue=0, repeatinterval=10, command=self.adjust_nr_of_discs) self.discs.set(3) self.tempoLbl = Label(attrFrame, width=8, height=2, font=fnt, text="") self.tempo = Scale(attrFrame, from_=1, to_=10, orient=HORIZONTAL, font=fnt, length=0, showvalue=0, repeatinterval=10, command=self.adjust_speed) self.tempo.set(5) self.moveCntLbl = Label(attrFrame, width=5, height=2, font=fnt, padx=20, text="", anchor=CENTER) for widget in (self.discsLbl, self.discs, self.tempoLbl, self.tempo, self.moveCntLbl): widget.pack(side=LEFT) attrFrame.pack(side=TOP) # control buttons: reset, step, start/pause/resume ctrlFrame = Frame(root) # contains Buttons to control the game self.resetBtn = Button(ctrlFrame, width=11, text="reset", font=fnt, state=DISABLED, padx=15, command=self.reset) self.stepBtn = Button(ctrlFrame, width=11, text="step", font=fnt, state=NORMAL, padx=15, command=self.step) self.startBtn = Button(ctrlFrame, width=11, text="start", font=fnt, state=NORMAL, padx=15, command=self.start) for widget in self.resetBtn, self.startBtn: widget.pack(side=LEFT) ctrlFrame.pack(side=TOP) self.state = "START" root.mainloop()
def crea_tablero(titulo, alto, ancho): """ Crea una pizarra electrónica. Entradas: titulo : título de la ventana que contendrá la pizarra electrónica. alto : alto de la ventana en pixeles. ancho : ancho de la ventna en pixeles. Salidas: Ninguna. Restricciones: titulo es una tira, alto y ancho son enteros positivos. """ assert isinstance(titulo, str) assert isinstance(alto, int) and alto > 0 assert isinstance(ancho, int) and ancho > 0 ## Crea la ventana y un canvas para dibujar root = TK.Tk() root.title(titulo) canvas = TK.Canvas(root, width=ancho, height=alto) canvas.pack() ## Crea un TurtleScreen y la tortuga para dibujar global fondo_tablero fondo_tablero = TurtleScreen(canvas) ## Establece el fondo de la pizarra electrónica canvas["bg"] = "black" canvas.pack() global pizarra pizarra = RawTurtle(fondo_tablero) dibuja_leds() ## Establece las funciones para capturar las teclas fondo_tablero.onkeypress(lambda: detiene(), "Escape") por_siempre() fondo_tablero.listen() print("terminó") root.mainloop()
def __init__(self, filas = FILAS, columnas = COLUMNAS, largo = LARGO_SNAKE, cabeza = "blue", cuerpo="red"): """Crea la culebra y su cuadrícula. Entradas: filas : # de filas en la cuadrícula imaginaria. columnas : # de columna en la cuadrícula imaginaria. largo : Tamaño del snake incluyendo la cabeza. Salidas: Snake en una cuadrícula según las dimensiones indicadas. Supuesto: La ventana, según las dimensiones establecidas, cabe en la ventana. El snake cabe en la cuadrícula. """ ## Funciones locales al constructor ## def segmento(color, i, j): """ Dibuja un segmento del snake en posicion i, j con el color indicado. Entradas: color : Color del segmento a dibujar. (i,j) : Ubicación en que se desea dibujar el segmento en la cuadrícula imaginaria. Salidas: Dibujo del segemento con el color indicado en la posición (i,j) de la cuadrícula imaginaria. Supuesto: El color es uno válido en Tkinter. (i,j) es una posición válida en la cuadrícula imaginaria. """ ## Determina la posición en los ejes ## reales de la posición (i,j) de la ## cuadrícula imaginaria. x, y = Snake.deme_posicion(i, j) ## Prepara el lápiz para dibujar ## un rectánculo relleno. self.lapiz.fillcolor(color) self.lapiz.pu() self.lapiz.setpos(x, y) self.lapiz.seth(0) self.lapiz.pd() self.lapiz.begin_fill() ## Dibuja el rectángulo con 4 ## movimientos !!! for i in range(4): self.lapiz.fd(Snake.DIM+1) self.lapiz.left(90) ## Cierra el relleno. self.lapiz.end_fill() def mueva_snake(direccion): """ Mueve el snake en la dirección indicada. Entradas: direccion : Dirección en que se mueve el snake. Salidas: Actualización del snkae en pantalla. Si el snake pega contra un borde o contra ella misma no avanza. Supuesto: dirección es alguno de los valores "Up", "Down", "Left" o "Right". """ ## Obtiene la posición actual de la cabeza del snake. ci, cj = self.snake[-1][0], self.snake[-1][1] ## Calcula la nueva posición de la cabeza según ## la dirección indicada por el usuario. if direccion == "Up": i, j = (ci if ci == 1 else ci - 1, cj) elif direccion == "Down": i, j = (ci if ci == self.filas else ci + 1, cj) elif direccion == "Left": i, j = (ci, cj if cj == 1 else cj - 1) elif direccion == "Right": i, j = (ci, cj if cj == self.columnas else cj + 1) if not((i,j) in self.snake): ## se asegura que el snake ## no choque contra sí mismo !! self.scr.tracer(False) ## Borra la cola. La cola está en la ## posición 0 de la lista self.snake. segmento("white", self.snake[0][0], self.snake[0][1]) del self.snake[0] ## Pinta la antigua cabeza de color azul para que sea ## parte del cuerpo. La cabeza es el último elemento ## de la lista self.snake. segmento(cuerpo, self.snake[-1][0], self.snake[-1][1]) ## Agrega la nueva cabeza. La cabeza nueva cabeza ## se agrega al final de la lista. self.snake.append((i, j)) segmento(cabeza, i, j) self.scr.tracer(True) def dibuja_horizontales(): """ Dibuja las filas+1 lineas horizontales. Entradas: Ninguna. Salidas: Dibujo de las líneas horizontales de la cuadrícula imaginaria en que se moverá el snake. """ dy = Snake.DY ## Posición en eje y de la primera ## línea horizontal. ## Calcula la posición en eje x en que finalizan ## todas la líneas horizontales. posFin_x = Snake.DX + self.columnas * (Snake.DIM + 1) for i in range(self.filas+1): self.lapiz.up() self.lapiz.setpos(Snake.DX, dy) self.lapiz.down() self.lapiz.setpos(posFin_x, dy) dy += Snake.DIM + 1 def dibuja_verticales(): """ Dibuja las columnas+1 lineas verticales Entradas: Ninguna. Salidas: Dibujo de las líneas verticales de la cuadrícula imaginaria en que se moverá el snake. """ dx = Snake.DX ## Posición en eje x de la primera ## línea vertical. ## Calcula la posición en eje y en que finalizan ## todas la líneas verticales. posFin_y = Snake.DY + self.filas * (Snake.DIM + 1) for j in range(self.columnas+1): self.lapiz.up() self.lapiz.setpos(dx,Snake.DY) self.lapiz.down() self.lapiz.setpos(dx, posFin_y) dx += Snake.DIM + 1 def dibuja_escenario(): """ Dibuja la cuadrícula y el snake: el cuerpo en azul y la cabeza en rojo. Entradas: Ninguna. Salidas: Dibujo de la cuadrícula imaginaria en que se moverá el snake. """ self.scr.tracer(False) ## Dibuja la cuadricula dibuja_horizontales() dibuja_verticales() ## Dibuja el cuerpo del snake for x in self.snake[:-1]: segmento(cuerpo,x[0],x[1]) ## Dibuja la cabeza segmento(cabeza, self.snake[-1][0], self.snake[-1][1]) self.scr.tracer(True) ############################################################ ## Inicio de las instrucciones del constructor __init__. ## ############################################################ ## Verifica restricciones, sino se cumplen dispara un ## SnakeError. if not (isinstance(filas,int) and isinstance(columnas,int) and \ isinstance(largo,int)): raise SnakeError("Type Error") else: ## Guarda las dimensiones de la cuadrícula ## imaginaria y del snake en atributos de instancia. self.filas = filas self.columnas = columnas self.largo = largo ## Crea la ventana y estable un título para la misma. self.root = TK.Tk() self.root.title("Snake v1.0 / 2014") ## Obtiene la posición (x,y) en la ventana de la ## última fila y columna de la cuadrícula imaginaria, ## lo anterior con el objetivo de establecer el ## tamaño de la ventana. x, y = Snake.deme_posicion(filas, columnas) ## Calcula el ancho y el alto de la ventana anchoVentana = x + Snake.DX + Snake.DIM + 1 altoVentana = y + Snake.DY + Snake.DIM + 1 ## Crea un área de dibujo (canvas) con un ancho y ## alto que está en función de la cuadrícula ## en que se moverá el snake. self.canvas = TK.Canvas(self.root, width=anchoVentana, height=altoVentana) self.canvas.pack() ## Crea un área de dibujo para tortugas. self.scr = TurtleScreen(self.canvas) ## Establece un sistema de coordenadas en donde ## el punto (0,0) se ubica en la esquina superior ## izquierda. ## El eje x va de 0 a positivos de izquierda a derecha. ## El eje y va de 0 a positivos de arriba hacia abajo. self.scr.setworldcoordinates(0,altoVentana,anchoVentana,0) self.scr.reset() ## Crea la tortuga para dibujar self.lapiz = RawTurtle(self.scr) self.lapiz.ht() ## Crea el snake. ## El snake corresponde a una lista de pares ## ordenados (x, y) en donde cada uno de estos ## elementos corresponde a un segmento del snake. ## La cabeza del snake se ubica en la última ## posición de la lista. ## El snake creado queda en posición horizontal ## y su cabeza mira hacia la derecha. La cola ## se ubica en la posición 1,1. Observe que se ## utilizaron listas por comprensión para ## construir el snake. En este punto el snake ## no es visible. self.snake = [(1,eje_y) for eje_y in range(1, self.largo + 1)] ## Dibuja la cuadrícula y el snake. dibuja_escenario() ## Establece el binding entre las teclas para el movimiento ## del snake y las funciones que atenderán dicho movimiento. ## En todos los casos se utiliza la misma función solo que ## el parámetro con que se invoca es diferente. self.scr.onkeypress(lambda : mueva_snake("Up"), "Up") # Arriba self.scr.onkeypress(lambda : mueva_snake("Right"), "Right") # Derecha self.scr.onkeypress(lambda : mueva_snake("Down"), "Down") # Abajo self.scr.onkeypress(lambda : mueva_snake("Left"), "Left") # Izquierda self.scr.onkeypress(lambda : mueva_snake("Down"), "x") # Otra vez abajo ## Se queda escuchando los eventos. ## El programa termina cuando el usuario cierre la ventana. self.scr.listen()
#!/usr/bin/python ## DEMONSTRATES USE OF 2 CANVASES, SO CANNOT BE RUN IN DEMOVIEWER! """turtle example: Using TurtleScreen and RawTurtle for drawing on two distinct canvases. """ from turtle import TurtleScreen, RawTurtle, TK root = TK.Tk() cv1 = TK.Canvas(root, width=300, height=200, bg="#ddffff") cv2 = TK.Canvas(root, width=300, height=200, bg="#ffeeee") cv1.pack() cv2.pack() s1 = TurtleScreen(cv1) s1.bgcolor(0.85, 0.85, 1) s2 = TurtleScreen(cv2) s2.bgcolor(1, 0.85, 0.85) p = RawTurtle(s1) q = RawTurtle(s2) p.color("red", (1, 0.85, 0.85)) p.width(3) q.color("blue", (0.85, 0.85, 1)) q.width(3) for t in p,q: t.shape("turtle") t.lt(36) q.lt(180)
class TurtleWorld(object): def __init__(self, width, height, borders=wrap): self.width = width self.half_width = width // 2 self.height = height self.half_height = height // 2 self.borders = borders # intialise screen and turn off auto-render window = TK.Canvas(width=width, height=height) window.pack() self.screen = TurtleScreen(window) self.screen.tracer(0, 0) self.fps = 0 self.done = True self.turtles = [] self.obstacles = [] self.update_freq = 1000 #int(1 / 30.0 * 1000) def position_turtle(self, t, pos, angle): # move to location t.hideturtle() t.penup() if pos is None: x = randint(-self.half_width, self.half_width) y = randint(-self.half_height, self.half_height) else: x, y = pos t.goto(x, y) if angle is None: angle = random() * 360 t.setheading(angle) # ready to go t.showturtle() t.pendown() return t def print_fps(self): if not self.done: print(self.fps) self.screen.ontimer(self.print_fps, 1000) self.fps = 0 def create_turtle(self, callback, pos=None, angle=None): t = PowerTurtle(self) t.set_callback(callback) self.position_turtle(t, pos, angle) self.turtles.append(t) return t def add_turtle(self, turtle): turtle.clear() self.turtles.append(turtle) def remove_turtle(self, turtle): turtle.hideturtle() turtle.clear() self.turtles.remove(turtle) def add_obstacle(self, obstacle): self.obstacles.append(obstacle) self.add_turtle(obstacle) def something_at(self, pos): for obstacle in self.obstacles: if obstacle.contains(pos[0], pos[1]): return True return False def run(self, ticks=1000): # run for 1000 ticks self.done = False #self.screen.ontimer(self.print_fps, 1000) self.ticks = ticks self.screen.ontimer(self.tick, 33) mainloop() def tick(self): shuffle(self.turtles) for t in self.turtles: t.callback(self) self.borders(t, self.width, self.height) self.screen.update() self.fps += 1 self.ticks -= 1 if self.ticks == 0: self.done = True else: self.screen.ontimer(self.tick, 33)
def main(): player_N = 15 root = TK.Tk() canvas = TK.Canvas(root, width=1200, height=700, bg="#ddffff") canvas.pack() turtleScreen = TurtleScreen(canvas) turtleScreen.bgcolor("gray") turtleScreen.tracer(0,0) pl = [] for i in range(player_N): #プレイヤーの生成 random.seed() window_h = turtleScreen.window_height()/2 window_w = turtleScreen.window_width()/2 x = random.uniform(-window_w,window_w) y = random.uniform(-window_h,window_h) m = random.uniform(1,5) R = 600 pl_type = random.choice(["high_level_predator","middle_level_predator","low_level_predator","producer"]) k_high = random.uniform(0,150) k_middle = random.uniform(0,150) k_low = random.uniform(0,150) k_producer = random.uniform(0,150) if pl_type == "high_level_predator": #k_high = 0 pass elif pl_type == "middle_level_predator": k_middle = 0 k_high *= -1 elif pl_type == "low_level_predator": #k_low = 0 k_high *= -1 k_middle *= -1 elif pl_type == "producer": #k_producer = 0 k_high *= -1 k_middle *= -1 k_low *= -1 pl.append(Player(turtleScreen,pl_type,(x,y),k_high,k_middle,k_low,k_producer,m,R)) turtleScreen.update() #time.sleep(1) while(1): for me in turtleScreen.turtles(): me.acc -= me.acc for you in turtleScreen.turtles(): r = you.pos()-me.pos() r_d = abs(r) if me != you and r_d<me.R and you.isvisible(): me.acc += (me.get_K(you)/(me.m*pow(r_d,3)))*r if me.strengthpower == you.strengthpower: me.acc = 0.3*me.acc+0.7*((r_d/me.R)*me.acc + ((me.R-r_d)/me.R)*you.acc) if r_d<10 : if me.strengthpower > you.strengthpower: you.hiding() me.energy += you.energy me.v -= 1.1*me.v elif me.strengthpower == you.strengthpower: me.v = -0.1*r me.v += me.acc if abs(me.v)>10: me.v = me.v*(10/abs(me.v)) me.setpos(me.pos()+me.v) if me.xcor()<-600 or me.xcor()>600 or me.ycor()<-350 or me.ycor()>350: me.v = (-0.5/abs(me.pos()))*me.pos() me.acc -= me.acc #print(me.energy) turtleScreen.update() time.sleep(0.01)
from turtle import TurtleScreen, RawTurtle, TK root = TK.Tk() cv1 = TK.Canvas(root, width=500, height=500, bg="#ddffff") cv1.pack() s1 = TurtleScreen(cv1) s1.bgcolor("orange") p = RawTurtle(s1) t = RawTurtle(s1)
from PIL import Image, ImageTk import math # import Image import Tkinter # import turtle from turtle import RawTurtle, TurtleScreen import random import json import os # import time import numpy as np root = Tkinter.Tk() canvas = Tkinter.Canvas(root, width=1200, height=264, state=Tkinter.DISABLED) canvas.pack() screen = TurtleScreen(canvas) turtle = RawTurtle(screen) # screen.setworldcoordinates(0, 399, 999, 0) turtle.hideturtle() turtle.up() turtle.tracer(50000, delay=0) # turtle.register_shape("dot", ((-3,-3), (-3,3), (3,3), (3,-3))) screen.register_shape("tri", ((-3, -2), (0, 3), (3, -2), (0, 0))) turtle.speed(0) UPDATE_EVERY = 0 DRAW_EVERY = 2 class Map(object):
from turtle import TK, TurtleScreen, RawTurtle root=TK.Tk() cv1 = TK.Canvas(root,width=300,height=200,bg='yellow') cv2 = TK.Canvas(root,width=300,height=200,bg='blue') cv1.pack() cv2.pack() top = TurtleScreen(cv1) top.bgcolor('yellow') top_turtle=RawTurtle(top) bottom=TurtleScreen(cv2) bottom.bgcolor('blue') bottom_turtle=RawTurtle(bottom) TK.mainloop()
class TurtleWorld(object): def __init__(self, width, height, borders=wrap, title="TurtlePower"): self.width = width self.half_width = width // 2 self.height = height self.half_height = height // 2 self.borders = borders self.window_title = title self.init_screen() self.fps = 0 self.done = True self.turtles = [] def init_screen(self): # intialise screen and turn off auto-render root = Tk() root.wm_title(self.window_title) window = TK.Canvas(master=root, width=self.width, height=self.height) window.pack() self.screen = TurtleScreen(window) self.screen.tracer(0, 0) def position_turtle(self, t, pos=None, angle=None): # move to location t.hideturtle() t.penup() if pos is None: pos = (randint(-self.half_width, self.half_width), randint(-self.half_height, self.half_height)) x, y = pos t.goto(x, y) if angle is None: angle = random() * 360 t.setheading(angle) # ready to go t.showturtle() t.pendown() return t def random_position(self, turtle): return self.position_turtle(turtle) def _print_fps(self): # pragma: no cover if not self.done: print(self.fps) self.screen.ontimer(self._print_fps, 1000) self.fps = 0 def create_turtle(self, callback, pos=None, angle=None): t = PowerTurtle(self) t.set_callback(callback) self.position_turtle(t, pos, angle) self.add_turtle(t) return t def add_turtle(self, turtle): turtle.clear() self.turtles.append(turtle) def remove_turtle(self, turtle): turtle.hideturtle() turtle.clear() self.turtles.remove(turtle) def run(self, ticks=1000): # run for 1000 ticks self.done = False if DEBUG: self.screen.ontimer(self._print_fps, 1000) self.ticks = ticks self.screen.ontimer(self.tick, 33) self.screen.update() if mainloop: mainloop() else: self.screen.mainloop() def tick(self): shuffle(self.turtles) for t in self.turtles: t._do_callback() self.borders(t, self.half_width, self.half_height) self.screen.update() self.fps += 1 self.ticks -= 1 if self.ticks == 0: self.done = True else: self.screen.ontimer(self.tick, 33)
#! /usr/bin/python3.2 ## DEMONSTRATES USE OF 2 CANVASES, SO CANNOT BE RUN IN DEMOVIEWER! """turtle example: Using TurtleScreen and RawTurtle for drawing on two distinct canvases. """ from turtle import TurtleScreen, RawTurtle, TK root = TK.Tk() cv1 = TK.Canvas(root, width=300, height=200, bg="#ddffff") cv2 = TK.Canvas(root, width=300, height=200, bg="#ffeeee") cv1.pack() cv2.pack() s1 = TurtleScreen(cv1) s1.bgcolor(0.85, 0.85, 1) s2 = TurtleScreen(cv2) s2.bgcolor(1, 0.85, 0.85) p = RawTurtle(s1) q = RawTurtle(s2) p.color("red", (1, 0.85, 0.85)) p.width(3) q.color("blue", (0.85, 0.85, 1)) q.width(3) for t in p,q: t.shape("turtle") t.lt(36) q.lt(180)
if nx is not None: t.setx(nx) if ny is not None: t.sety(ny) # intialise screen and turn off auto-render window = TK.Canvas(width=W, height=H) window.pack() #from turgles import TurgleScreenBase #TurtleScreen.__bases__ = (TurgleScreenBase,) #window = pyglet.window.Window(width=W, height=H) s = TurtleScreen(window) s.tracer(0, 0) # random initial positions turtles = [RawTurtle(s) for i in range(n)] for t in turtles: t.ht() t.penup() t.goto(randint(0, W) - W / 2, randint(0, H) - H / 2) t.right(randint(0, 360)) t.st() t.pendown() def random_walk(t):