def __init__(self, turtle_window, id_number): # comment here self.turtle_window = turtle_window self.id_number = id_number # comment here self.speed_params = [20, 0.2, 6] self.turn_parameters = [20] # comment here self.turtle_object = RawTurtle(self.turtle_window.wn) self.turtle_object.hideturtle() self.turtle_object.shape('turtle') self.turtle_object.turtlesize(1) self.turtle_object.penup() # comment here self.likes_food_dict = {'Sugar': random.choice([True, False])} # comment here if self.likes_food_dict['Sugar']: self.turtle_object.color("red", (1, 0.85, 0.85)) else: self.turtle_object.color("blue", (0.85, 0.85, 1)) # comment here self.place() self.turtle_object.showturtle()
def __init__(self,x): self.it=x S="D+D+D+D" for i in range(self.it): pesan="" for j in range(len(S)): if S[j]=="D": pesan+="D+D-D-DD+D+DD-D-D+D" else: pesan+=S[j] S=pesan root3=tk.Tk() if self.it!=1: root3.title('Batik Fractal with '+str(self.it)+' iterations') else: root3.title('Batik 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(90) else: self.turtle.left(90) self.canvas.bind('<MouseWheel>',self.zoom) screen.mainloop()
def juhuslikud_konnad(n=100, t=100): """ Tekitab n juhuslikult liikuvat konna """ ekraan = Screen() konnad = [] for i in range(n): # Paigutame konna i juhuslikele koordinaatidele konn_i = RawTurtle(ekraan) konn_i.up() x = randint(-100, 100) y = randint(-100, 100) konn_i.goto(x, y) konn_i.down() # Värvime konna juhusliku värviga varv = choice(['green', 'brown', 'black', 'red', 'blue']) konn_i.color(varv) # Lisame konna i konnade hulka konnad.append(konn_i) # Teeme t juhuslikku liikumist juhusliku konnaga for ti in range(t): suunamuutus = randint(-60, 60) konn = choice(konnad) konn.left(suunamuutus) konn.fd(20)
def __init__(self,turtleScreen,player_type,posVector,k_to_high,k_to_middle,k_to_low,k_to_producer,m,R): RawTurtle.__init__(self,turtleScreen) #タートル生成 self.up() #軌跡は書かない self.setpos(posVector) #初期位置 self.resizemode("user") self.shape("circle") #プレイヤーの形 self.shapesize(0.5) if player_type == "high_level_predator": self.color("red") #高域捕食者 self.strengthpower = 3 self.shape("triangle") elif player_type == "middle_level_predator": self.color("yellow") #中域捕食者 self.strengthpower = 2 self.shape("square") elif player_type == "low_level_predator": self.color("blue") #低域捕食者 self.strengthpower = 1 self.shape("turtle") else : self.color("dark green") #生産者 self.strengthpower = 0 self.shape("circle") #このクラスで新しく追加した変数 self.acc = Vec2D(0,0) #初期加速度ゼロ self.v= Vec2D(0,0) #初期速度ゼロ self.m = m #質量 self.k_to_high = k_to_high #高域捕食者に対するK self.k_to_middle = k_to_middle #中域捕食者に対するK self.k_to_low = k_to_low #低域捕食者に対するK self.k_to_producer = k_to_producer #生産者に対するK self.R = R #視野半径 self.energy = 10
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None): """Sets Canvas to play on as well as default values for number of discs and animation-speed. moveCntDisplay is a function with 1 parameter, which communicates the count of the actual move to the GUI containing the Hanoi-engine-canvas.""" self.ts = canvas self.ts.tracer(False) # setup scene self.designer = RawTurtle(canvas, shape="square") self.designer.penup() self.designer.shapesize(0.5, 21) self.designer.goto(0, -80) self.designer.stamp() self.designer.shapesize(7, 0.5) self.designer.fillcolor('darkgreen') for x in -140, 0, 140: self.designer.goto(x, -5) self.designer.stamp() self.nrOfDiscs = nrOfDiscs self.speed = speed self.moveDisplay = moveCntDisplay self.running = False self.moveCnt = 0 self.discs = [Disc(canvas) for i in range(10)] self.towerA = Tower(-140) self.towerB = Tower(0) self.towerC = Tower(140) self.ts.tracer(True)
def __init__(self, scene, robot_id): #sets variables self.robot_id = robot_id self.turtle = RawTurtle(scene.canvas) self.scene = scene self.scr = self.turtle.getscreen() self.scr.setworldcoordinates(0, scene.height, scene.width, 0) self.turtle.penup() if robot_id == 1: self.turtle.color("blue") else: self.turtle.color("red") #create turtles sprite ## self.turtle.register_shape("ship",((-7,-2),(-6,-1),(-3,0),(-3,1),(-2,5), ## (0,7),(2,5),(3,1),(3,0),(6,-1),(7,-2), ## (3,-1),(3,-2),(2,-7),(-2,-7),(-3,-2), ## (-3,-1),(-2,-1),(-2,-2),(-1,-6),(1,-6), ## (2,-2),(2,-1),(-2,-1),(-2,0),(2,0), ## (2,1),(1,4),(0,5),(-1,4),(-2,1), ## (-2,-1),(-3,-1)) ## ) ## self.turtle.shape("ship") ## self.turtle.shapesize(2,2) #place robot using reset self.reset()
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None): self.ts = canvas self.ts.tracer(False) # setup scene self.designer = RawTurtle(canvas, shape="square") self.designer.penup() self.designer.shapesize(0.4, 25) self.designer.goto(0, -81) self.designer.stamp() self.designer.shapesize(4, 0.5) self.designer.fillcolor('Black') for x in -150, 0, 150: self.designer.goto(x, -5) self.designer.stamp() self.nrOfDiscs = nrOfDiscs self.speed = speed self.moveDisplay = moveCntDisplay self.running = False self.moveCnt = 0 self.discs = [Disc(canvas) for i in range(10)] self.towerA = Tower(-150) self.towerB = Tower(0) self.towerC = Tower(150) self.ts.tracer(True)
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")
def test_board_full_4(board4): """Testing the board fulness""" root = tkinter.Tk() canvas = tkinter.Canvas(root) t = RawTurtle(canvas) screen = t.getscreen() board = Board(None, screen) root.destroy()
def board0(): root = tkinter.Tk() canvas = tkinter.Canvas(root) t = RawTurtle(canvas) screen = t.getscreen() board = Board(None, screen) board.reset() # root.destroy() return board
def get_pen(self): self.pen = RawTurtle(self.screen) self.pen.color("#f0d1bf") xpos = 0 ypos = self.screen.height - 30 self.pen.up() self.pen.ht() self.pen.goto(xpos, ypos) self.pen.down()
def start_message(self): """ Creates Pen for drawing game update messages above the board. """ self.pen = RawTurtle(self) self.pen.ht() self.pen.up() self.pen.color(self.font[1]) self.pen.goto(0, self.y) self.pen.write("New Game", align="center", font=self.font[0]) return
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 __init__(self, window, content, x, y): self.headline = RawTurtle(window) self.headline.speed(0) self.headline.shape("square") self.headline.color("white") self.headline.penup() self.headline.hideturtle() self.headline.goto(x, y) self.headline.write(content, align="center", font=("Courier", 18, "normal"))
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 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 __init__(self,screen,corners,width,height,x,y): self.corners = corners self.screen = screen self.pen = RawTurtle(screen) self.pen.speed(8) self.width = width self.height = height self.x = x self.y = y self.spaces = [] self.draw() self.draw_spaces()
def __init__(self, turtle_window, id_number): self.turtle_window = turtle_window self.id_number = id_number self.heat_source = RawTurtle(self.turtle_window.wn) self.heat_source.hideturtle() self.heat_source.shape('circle') self.heat_source.penup() self.heat_source.color("orange") self.place() self.heat_source.showturtle() self.heat_source.ondrag(self.drag_heat_source)
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, screen, index=0, base=0, height=0, parent=None, color="#000"): RawTurtle.__init__(self,screen) self.base = base self.height = height self.__color = color self.color(color) self.value = str(height) self.stage = parent self.speed(screen.speed) self.index = index self.__tracer = self.screen.tracer() self.ht() self.up()
def create_widgets(self): tk.Label(self.parent, text="Robot Driver Inc.", font=('Arial', 25)).grid(row=0, column=0, columnspan=6) self.forward_btn = tk.Button(self.parent, text="Jazda do przodu") self.rotate_btn = tk.Button(self.parent, text="Obrót") self.wait_btn = tk.Button(self.parent, text="Czekaj") self.undo_btn = tk.Button(self.parent, text="Cofnij") self.generate_btn = tk.Button(self.parent, text="Generuj kod") self.canvas = tk.Canvas(self.parent, width=640, height=480) self.draw = RawTurtle(self.canvas) self.forward_btn.grid(row=1, column=0, sticky=tk.E + tk.W) self.rotate_btn.grid(row=2, column=0, sticky=tk.E + tk.W) self.wait_btn.grid(row=3, column=0, sticky=tk.E + tk.W) self.undo_btn.grid(row=4, column=0, sticky=tk.E + tk.W) self.generate_btn.grid(row=5, column=0, sticky=tk.E + tk.W) self.canvas.grid(row=6, column=0, columnspan=6) tk.Label(self.parent, text="Moc:").grid(row=1, column=1) self.power_input = tk.Entry(self.parent, textvariable=self.power_var) tk.Label(self.parent, text="Czas:").grid(row=1, column=3) self.forward_wait_input = tk.Entry(self.parent, textvariable=self.forward_wait_var) tk.Label(self.parent, text="Stopnie:").grid(row=2, column=1) self.rotate_input = tk.Entry(self.parent, textvariable=self.degrees_var) tk.Label(self.parent, text="Czas:").grid(row=3, column=1) self.wait_wait_input = tk.Entry(self.parent, textvariable=self.wait_wait_var) tk.Label(self.parent, text="Ścieżka:").grid(row=4, column=1, rowspan=2) self.filepath_label = tk.Label(self.parent, text=self.filepath, wraplength=150, justify='center') self.filepath_btn = tk.Button(self.parent, text="Wybierz") self.power_input.grid(row=1, column=2) self.forward_wait_input.grid(row=1, column=4) self.rotate_input.grid(row=2, column=2) self.wait_wait_input.grid(row=3, column=2) self.filepath_label.grid(row=4, column=2, rowspan=2) self.filepath_btn.grid(row=5, column=3, columnspan=2, sticky=tk.E + tk.W)
def __init__(self, screen, cor, idx, population): RawTurtle.__init__(self, screen) x, y = cor self.filled = False self.color(gen_color()) self.idx = idx self.pop = population nw = (x - 12, y) ne = (x, y) sw = (x - 12, y - 12) se = (x, y - 12) self.corners = (nw, sw, se, ne) self.speed(0) self.ht()
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 __init__(self, window, shape): self.speed = 0.1 self.score = 0 self.highScore = 0 self.mouth = RawTurtle(window) self.mouth.speed(0) self.mouth.shape(shape) self.mouth.home() self.mouth.direction = "stop" self.mouth.penup() self.deadFromPoison = False self.tempScore = 1 self.body = []
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,board,center,radius,color,idx): RawTurtle.__init__(self,board.screen) self.board = board self.center = center self.radius = radius self.state = None self.idx = idx self._bgcolor = color self.color(color) self.up() self.speed(5) self.goto(self.center[0],self.center[1]-self.radius) self.ht() self.down() self.draw()
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 test_minimax_param(board, evaluation): """Testing the minimax""" root = tkinter.Tk() canvas = tkinter.Canvas(root) t = RawTurtle(canvas) screen = t.getscreen() tkboard = Board(None, screen) tkboard.reset() for i in range(3): for j in range(3): if board[i][j] == "O": tkboard[i][j] = O(canvas) elif board[i][j] == "X": tkboard[i][j] = X(canvas) # root.destroy() assert minimax(1, tkboard, 4) == evaluation
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None): """Sets Canvas to play on as well as default values for number of discs and animation-speed. moveCntDisplay is a function with 1 parameter, which communicates the count of the actual move to the GUI containing the Hanoi-engine-canvas.""" self.ts = canvas self.ts.tracer(False) # setup scene self.designer = RawTurtle(canvas, shape="square") self.designer.penup() self.designer.shapesize(0.5, 21) self.designer.goto(0,-80); self.designer.stamp() self.designer.shapesize(7, 0.5) self.designer.fillcolor('darkgreen') for x in -140, 0, 140: self.designer.goto(x,-5); self.designer.stamp() self.nrOfDiscs = nrOfDiscs self.speed = speed self.moveDisplay = moveCntDisplay self.running = False self.moveCnt = 0 self.discs = [Disc(canvas) for i in range(10)] self.towerA = Tower(-140) self.towerB = Tower(0) self.towerC = Tower(140) self.ts.tracer(True)
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 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,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, scene, robot_id): self.robot_id = robot_id self.done = False self.signal = None self.turtle = RawTurtle(scene.canvas) self.scene = scene self.scr = self.turtle.getscreen() self.scr.setworldcoordinates(0, scene.height, scene.width, 0) self.turtle.penup() self.reset()
def render_system(system, n=0): """Renders the given system using a new turtle""" # Expand if requested system.expand(n) # Draw it turtle = RawTurtle(Screen()) turtle.speed(0) turtle.ht() turtle.lt(90) system.render_turtle(turtle)
def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None): self.ts = canvas self.ts.tracer(False) self.designer = RawTurtle(canvas, shape="square") self.designer.penup() self.designer.shapesize(0.5, 21) self.designer.goto(0,-80); self.designer.stamp() self.designer.shapesize(7, 0.5) self.designer.fillcolor('black') for x in -140, 0, 140: self.designer.goto(x,-5); self.designer.stamp() self.nrOfDiscs = nrOfDiscs self.speed = speed self.moveDisplay = moveCntDisplay self.running = False self.moveCnt = 0 self.discs = [Disc(canvas) for i in range(10)] self.towerA = Tower(-140) self.towerB = Tower(0) self.towerC = Tower(140) self.ts.tracer(True)
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()
class Robot: def __init__(self, scene, robot_id): self.robot_id = robot_id self.done = False self.signal = None self.turtle = RawTurtle(scene.canvas) self.scene = scene self.scr = self.turtle.getscreen() self.scr.setworldcoordinates(0, scene.height, scene.width, 0) self.turtle.penup() self.reset() def reset(self): positions = [((15,15), 45), ((self.scene.width-15, 15), 135), ((15, self.scene.height-15), 315), ((self.scene.height-15, self.scene.width-15), 135)] self.turtle.speed(0) self.turtle.setpos(positions[self.robot_id][0]) print positions[self.robot_id] self.turtle.left(positions[self.robot_id][1]) self.turtle.forward(20) self.turtle.speed("normal") def process(self): ##sets variables for checking collision turtle_x = self.turtle.xcor() turtle_y = self.turtle.ycor() t_heading = self.turtle.heading() ##variables used to check right xr = turtle_x + 15*math.cos(math.radians(self.turtle.heading()+30)) yr = turtle_y + 15*math.sin(math.radians(self.turtle.heading()+30)) ##variables used to check left xl = turtle_x + 15*math.cos(math.radians(self.turtle.heading()-30)) yl = turtle_y + 15*math.sin(math.radians(self.turtle.heading()-30)) ##turns the robot at window boundries st_orient = [0, 90, 180, 270] bounce_d = 20 if turtle_x - bounce_d < 0: self.turtle.setheading(180-t_heading) if turtle_x + bounce_d > self.scene.width: self.turtle.setheading(180-t_heading) if turtle_y - bounce_d < 0: self.turtle.setheading(360-t_heading) if turtle_y + bounce_d > self.scene.height: self.turtle.setheading(360-t_heading) ##check collisions left = self.scene.canvas.find_overlapping(xl-1,yl-1,xl+1,yl+1) right = self.scene.canvas.find_overlapping(xr-1,yr-1,xr+1,yr+1) if self.goal_id in left + right: self.done = True elif left: ##turn away self.turtle.left(10) elif right: ##turn away self.turtle.right(10) else: ##else move forward self.turtle.forward(5) ##if goal not reached: if self.signal: if self.signal == "STOP": self.signal = None return elif not self.done: self.scene.master.after(20, self.process)
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) for t in p, q: t.begin_fill()
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"
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", "white") p.width(3) q.color("blue", "black") q.width(3) for t in p,q: t.shape("turtle") t.lt(36) q.lt(180) for i in range(5): for t in p, q:
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): """
def __init__(self, cv): RawTurtle.__init__(self, cv, shape="square", visible=False) self.pu() self.goto(-140,200)
class HanoiEngine: def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None): self.ts = canvas self.ts.tracer(False) self.designer = RawTurtle(canvas, shape="square") self.designer.penup() self.designer.shapesize(0.5, 21) self.designer.goto(0,-80); self.designer.stamp() self.designer.shapesize(7, 0.5) self.designer.fillcolor('black') for x in -140, 0, 140: self.designer.goto(x,-5); self.designer.stamp() self.nrOfDiscs = nrOfDiscs self.speed = speed self.moveDisplay = moveCntDisplay self.running = False self.moveCnt = 0 self.discs = [Disc(canvas) for i in range(10)] self.towerA = Tower(-140) self.towerB = Tower(0) self.towerC = Tower(140) self.ts.tracer(True) def setspeed(self): for disc in self.discs: disc.speed(self.speed) def hanoi(self, n, src, dest, temp): if n > 0: for x in self.hanoi(n-1, src, temp, dest): yield None yield self.move(src, dest) for x in self.hanoi(n-1, temp, dest, src): yield None def move(self, src_tower, dest_tower): dest_tower.push(src_tower.pop()) self.moveCnt += 1 self.moveDisplay(self.moveCnt) def reset(self): self.ts.tracer(False) self.moveCnt = 0 self.moveDisplay(0) for t in self.towerA, self.towerB, self.towerC: while t != []: t.pop(200) for k in range(self.nrOfDiscs-1,-1,-1): self.discs[k].config(k, self.nrOfDiscs) self.towerA.push(self.discs[k]) self.ts.tracer(True) self.HG = self.hanoi(self.nrOfDiscs, self.towerA, self.towerC, self.towerB) def run(self): self.running = True try: while self.running: result = self.step() return result except StopIteration: return True def step(self): try: next(self.HG) return 2**self.nrOfDiscs-1 == self.moveCnt except TclError: return False def stop(self): self.running = False
class HanoiEngine: """Play the Hanoi-game on a given TurtleScreen.""" def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None): """Sets Canvas to play on as well as default values for number of discs and animation-speed. moveCntDisplay is a function with 1 parameter, which communicates the count of the actual move to the GUI containing the Hanoi-engine-canvas.""" self.ts = canvas self.ts.tracer(False) # setup scene self.designer = RawTurtle(canvas, shape="square") self.designer.penup() self.designer.shapesize(0.5, 21) self.designer.goto(0,-80); self.designer.stamp() self.designer.shapesize(7, 0.5) self.designer.fillcolor('darkgreen') for x in -140, 0, 140: self.designer.goto(x,-5); self.designer.stamp() self.nrOfDiscs = nrOfDiscs self.speed = speed self.moveDisplay = moveCntDisplay self.running = False self.moveCnt = 0 self.discs = [Disc(canvas) for i in range(10)] self.towerA = Tower(-140) self.towerB = Tower(0) self.towerC = Tower(140) self.ts.tracer(True) def setspeed(self): for disc in self.discs: disc.speed(self.speed) def move(self, src_tower, dest_tower): """move uppermost disc of source tower to top of destination tower.""" dest_tower.push(src_tower.pop()) self.moveCnt += 1 self.moveDisplay(self.moveCnt) def reset(self): """Setup of (a new) game.""" self.ts.tracer(False) self.moveCnt = 0 self.moveDisplay(0) for t in self.towerA, self.towerB, self.towerC: while t != []: t.pop(200) for k in range(self.nrOfDiscs-1,-1,-1): self.discs[k].config(k, self.nrOfDiscs) self.towerA.push(self.discs[k]) self.ts.tracer(True) def run(self): """run game ;-) return True if game is over, else False""" self.running = True ex7.play_hanoi(self, self.nrOfDiscs, self.towerA, self.towerC, self.towerB) return True
class HanoiEngine: """Play the Hanoi-game on a given TurtleScreen.""" def __init__(self, canvas, nrOfDiscs, speed, moveCntDisplay=None): """Sets Canvas to play on as well as default values for number of discs and animation-speed. moveCntDisplay is a function with 1 parameter, which communicates the count of the actual move to the GUI containing the Hanoi-engine-canvas.""" self.ts = canvas self.ts.tracer(False) # setup scene self.designer = RawTurtle(canvas, shape="square") self.designer.penup() self.designer.shapesize(0.5, 21) self.designer.goto(0,-80); self.designer.stamp() self.designer.shapesize(7, 0.5) self.designer.fillcolor('darkgreen') for x in -140, 0, 140: self.designer.goto(x,-5); self.designer.stamp() self.nrOfDiscs = nrOfDiscs self.speed = speed self.moveDisplay = moveCntDisplay self.running = False self.moveCnt = 0 self.discs = [Disc(canvas) for i in range(10)] self.towerA = Tower(-140) self.towerB = Tower(0) self.towerC = Tower(140) self.ts.tracer(True) def setspeed(self): for disc in self.discs: disc.speed(self.speed) def hanoi(self, n, src, dest, temp): """The classical recursive Towers-Of-Hanoi algorithm, implemented as a recursive generator, yielding always None plus an 'important' side effect - the next Hanoi move.""" if n > 0: for x in self.hanoi(n-1, src, temp, dest): yield None yield self.move(src, dest) for x in self.hanoi(n-1, temp, dest, src): yield None def move(self, src_tower, dest_tower): """move uppermost disc of source tower to top of destination tower.""" dest_tower.push(src_tower.pop()) self.moveCnt += 1 self.moveDisplay(self.moveCnt) def reset(self): """Setup of (a new) game.""" self.ts.tracer(False) self.moveCnt = 0 self.moveDisplay(0) for t in self.towerA, self.towerB, self.towerC: while t != []: t.pop(200) for k in range(self.nrOfDiscs-1,-1,-1): self.discs[k].config(k, self.nrOfDiscs) self.towerA.push(self.discs[k]) self.ts.tracer(True) self.HG = self.hanoi(self.nrOfDiscs, self.towerA, self.towerC, self.towerB) def run(self): """run game ;-) return True if game is over, else False""" self.running = True try: while self.running: result = self.step() return result # True iff done except StopIteration: # game over return True def step(self): """perform one single step of the game, returns True if finished, else False""" try: next(self.HG) return 2**self.nrOfDiscs-1 == self.moveCnt except TclError: return False def stop(self): """ ;-) """ self.running = False