def drawGrid():
screen.clear()
screen.tracer(1000000)
screen.setworldcoordinates(screenMin, screenMin, screenMax, screenMax)
screen.bgcolor("white")
screen.tracer(0)
t = RawTurtle(canvas)
t.hideturtle()
t.penup()
t.width(10)
t.color("black")
for i in range(2):
t.penup()
t.goto(i * 100 + 100, 10)
t.pendown()
t.goto(i * 100 + 100, 290)
t.penup()
t.goto(10, i * 100 + 100)
t.pendown()
t.goto(290, i * 100 + 100)
screen.update()
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"
class HeatSource:
###############################################################################################################
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 place(self):
max_location = self.turtle_window.screen_size / 2 - 10
self.heat_source.goto(random.randint(-max_location, max_location),
random.randint(-max_location, max_location))
def drag_heat_source(self, x, y):
self.heat_source.goto(x, y)
self.turtle_window.wn.update()
class Headline:
"""Die Klasse beschreibt das Aussehen einer Headline zum Anzeigen des Scores, HighScores, und der HighScoreListe."""
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 setPos(self, x, y):
self.headline.goto(x, y)
def writeHeadlineForGameOver(self):
self.headline.clear()
self.headline.write("Game Over",
align="center",
font=("Courier", 18, "normal"))
def writeNewHeadline(self, score, newScore):
self.headline.clear()
self.headline.write("Score:{} High Score: {}".format(score, newScore),
align="center",
font=("Courier", 18, "normal"))
def clearHideline(self):
self.headline.clear()
def writeNewHeadlineForBestList(self, content):
self.headline.clear()
self.headline.write(content,
align="center",
font=("Courier", 18, "normal"))
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:
t.fd(50)
t.lt(72)
for t in p, q:
class Vehicle:
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 place(self):
# comment here
self.turtle_object.goto(random.randint(-MAX_LOCATION, MAX_LOCATION),
random.randint(-MAX_LOCATION, MAX_LOCATION))
self.turtle_object.right(random.randint(0, 360))
def move(self):
# comment here
cumulative_speed = 0
cumulative_turn_amount = 0
# comment here
for food_source in self.turtle_window.food_source_list:
# comment here
likes_food = self.likes_food_dict[food_source.name]
# comment here
input_distance = self.turtle_object.distance(
food_source.turtle_object.pos())
# comment here
input_angle = self.turtle_object.heading(
) - self.turtle_object.towards(food_source.turtle_object.pos())
# comment here
sin_angle = math.sin(math.radians(input_angle))
# comment here
left_sensor_distance = input_distance - sin_angle
right_sensor_distance = input_distance + sin_angle
# comment here
left_speed, right_speed, combined_speed = self.compute_speed(
left_sensor_distance, right_sensor_distance, likes_food)
# comment here
turn_amount = self.turn_parameters[0] * (right_speed - left_speed)
# comment here
cumulative_speed += combined_speed
cumulative_turn_amount += turn_amount
# comment here
if isinstance(cumulative_turn_amount, complex):
cumulative_turn_amount = 0
# comment here
if cumulative_speed < 0:
cumulative_speed = 0
# comment here
self.turtle_object.right(cumulative_turn_amount)
self.turtle_object.forward(cumulative_speed)
# comment here
self.check_border_collision()
def check_border_collision(self):
'''
comment here. Make one big comment for the function, but it must be more specific and detailed then
just repeating the function name...
'''
if self.turtle_object.xcor() > MAX_LOCATION:
self.turtle_object.goto(MAX_LOCATION, self.turtle_object.ycor())
if self.turtle_object.xcor() < -MAX_LOCATION:
self.turtle_object.goto(-MAX_LOCATION, self.turtle_object.ycor())
if self.turtle_object.ycor() > MAX_LOCATION:
self.turtle_object.goto(self.turtle_object.xcor(), MAX_LOCATION)
if self.turtle_object.ycor() < -MAX_LOCATION:
self.turtle_object.goto(self.turtle_object.xcor(), -MAX_LOCATION)
if self.turtle_object.ycor() <= -MAX_LOCATION:
if 0 <= self.turtle_object.heading() <= 180:
turn_angle = 180 - self.turtle_object.heading()
self.turtle_object.setheading(turn_angle)
else:
turn_angle = abs(360 - self.turtle_object.heading())
self.turtle_object.setheading(turn_angle)
if self.turtle_object.ycor() >= MAX_LOCATION:
if 0 <= self.turtle_object.heading() <= 180:
turn_angle = 360 - self.turtle_object.heading()
self.turtle_object.setheading(turn_angle)
else:
turn_angle = 360 - (self.turtle_object.heading() - 180)
self.turtle_object.setheading(turn_angle)
if self.turtle_object.xcor() <= -MAX_LOCATION:
if 0 <= self.turtle_object.heading() <= 90:
turn_angle = 360 - self.turtle_object.heading()
self.turtle_object.setheading(turn_angle)
if 270 < self.turtle_object.heading() <= 360:
turn_angle = 360 - self.turtle_object.heading()
self.turtle_object.setheading(turn_angle)
if 90 < self.turtle_object.heading() < 180:
turn_angle = self.turtle_object.heading() - 90
self.turtle_object.setheading(turn_angle)
if 180 <= self.turtle_object.heading() <= 360:
turn_angle = self.turtle_object.heading() + 90
self.turtle_object.setheading(turn_angle)
if self.turtle_object.xcor() >= MAX_LOCATION:
if 0 <= self.turtle_object.heading() <= 180:
turn_angle = self.turtle_object.heading() + 90
self.turtle_object.setheading(turn_angle)
else:
turn_angle = self.turtle_object.heading() - 90
self.turtle_object.setheading(turn_angle)
###############################################################################################################
def compute_speed(self, left_distance, right_distance, likes_food):
'''
comment here. Make one big comment for the function, but it must be more specific and detailed then
just repeating the function name... explain this in Braitenberg's terms
'''
if likes_food:
left_speed = (
self.speed_params[0] /
(right_distance**self.speed_params[1])) - self.speed_params[2]
right_speed = (
self.speed_params[0] /
(left_distance**self.speed_params[1])) - self.speed_params[2]
else:
left_speed = (
self.speed_params[0] /
(left_distance**self.speed_params[1])) - self.speed_params[2]
right_speed = (
self.speed_params[0] /
(right_distance**self.speed_params[1])) - self.speed_params[2]
combined_speed = (left_speed + right_speed) / 2
return left_speed, right_speed, combined_speed
def loadAndDraw(load, draw, indicatorList, trades):
def get_mouse_click_coor(x, y):
print(x, y)
barNumber = round(x / 10)
barNumber = max(1, barNumber)
print("Bar Number: ", barNumber, " ", d[startPt + barNumber - 1], " ",
o[startPt + barNumber - 1], " ", highestHigh)
# tkMessageBox("Information",str(barNumber)
# # trtl.write('Vivax Solutions', font=("Arial", 20, "bold")) # chosing the font
## trtl.goto(10,highestHigh-.05*(highestHigh - lowestLow))
## trtl.pendown()
indexVal = startPt + barNumber - 1
outPutStr = str(d[indexVal]) + " " + str(o[indexVal]) + " " + str(
h[indexVal]) + " " + str(l[indexVal]) + " " + str(
c[indexVal]) # chosing the font
root.focus_set()
T.focus_set()
T.insert(tk.END, outPutStr + "\n")
## trtl.goto(20,highestHigh-60)
## trtl.write(str(o[50-(50-barNumber)]), font=("Arial", 8, "bold")) # chosing the font
## trtl.goto(20,highestHigh-80)
## trtl.write(str(h[50-(50-barNumber)]), font=("Arial", 8, "bold")) # chosing the font
## trtl.goto(20,highestHigh-100)
## trtl.write(str(l[50-(50-barNumber)]), font=("Arial", 8, "bold")) # chosing the font
## trtl.goto(20,highestHigh-120)
## trtl.write(str(c[50-(50-barNumber)]), font=("Arial", 8, "bold")) # chosing the font
##
## #root.withdraw()
if load == True:
cnt = 0
file = askopenfilename(
filetypes=(('CSV files', '*.csv'), ('TXT files', '*.txt'),
('POR files', '*.por')),
title='Select Markets or Ports. To Test- CSV format only!')
with open(file) as f:
f_csv = csv.reader(f)
numDecs = 0
for row in f_csv:
numCols = len(row)
cnt += 1
d.append(int(row[0]))
dt.append(datetime.datetime.strptime(row[0], '%Y%m%d'))
o.append(float(row[1]))
h.append(float(row[2]))
l.append(float(row[3]))
c.append(float(row[4]))
v.append(float(row[5]))
oi.append(float(row[6]))
oString = str(o[-1])
if '.' in oString:
decLoc = oString.index('.')
numDecs = max(numDecs, len(oString) - decLoc - 1)
xDate = list()
yVal = list()
zVal = list()
w.Button5.configure(state="normal")
w.Entry1.insert(0, str(d[-1]))
if draw == True:
startDrawDateStr = w.Entry1.get()
startDrawDate = int(startDrawDateStr)
cnt = -1
for x in range(0, len(d)):
cnt += 1
if startDrawDate >= d[x]: startPt = x
numBarsPlot = 60
if startPt + numBarsPlot > len(d): startPt = len(d) - (numBarsPlot + 1)
print(startPt, " ", len(d), " ", numBarsPlot)
indicCnt = 0
screen = TurtleScreen(w.Canvas1)
trtl = RawTurtle(screen)
screen.tracer(False)
screen.bgcolor('white')
clr = ['red', 'green', 'blue', 'yellow', 'purple']
trtl.pensize(6)
trtl.penup()
trtl.color("black")
highestHigh = 0
lowestLow = 99999999
# scaleMult = 10**numDecs
scaleMult = 1
for days in range(startPt, startPt + numBarsPlot):
if h[days] * scaleMult > highestHigh:
highestHigh = h[days] * scaleMult
if l[days] * scaleMult < lowestLow: lowestLow = l[days] * scaleMult
hhllDiffScale = (highestHigh - lowestLow) / 1.65
hhllDiff = highestHigh - lowestLow
botOfChart = lowestLow
screen.setworldcoordinates(-10, highestHigh - hhllDiffScale, 673,
highestHigh)
print(highestHigh, " ", lowestLow)
m = 0
trtl.setheading(0)
trtl.penup()
for i in range(startPt, startPt + numBarsPlot + 1):
m = m + 1
trtl.goto(m * 10, h[i] * scaleMult)
trtl.pendown()
trtl.goto(m * 10, l[i] * scaleMult)
trtl.penup()
trtl.goto(m * 10, c[i] * scaleMult)
trtl.pendown()
trtl.goto(m * 10 + 5, c[i] * scaleMult)
trtl.penup()
trtl.goto(m * 10, o[i] * scaleMult)
trtl.pendown()
trtl.goto(m * 10 - 5, o[i] * scaleMult)
trtl.penup()
trtl.goto(10, highestHigh)
print("Indicator List: ", indicatorList)
if len(indicatorList) != 0:
movAvgParams = list([])
if "movAvg" in indicatorList:
movAvgVal = 0
movAvgParamIndexVal = indicatorList.index("movAvg")
movAvgParams.append(indicatorList[movAvgParamIndexVal + 1])
movAvgParams.append(indicatorList[movAvgParamIndexVal + 2])
movAvgParams.append(indicatorList[movAvgParamIndexVal + 3])
for j in range(0, 3):
n = 0
trtl.penup()
if j == 0: trtl.color("red")
if j == 1: trtl.color("green")
if j == 2: trtl.color("blue")
for i in range(startPt, startPt + numBarsPlot):
n = n + 1
movAvgVal = 0
for k in range(i - movAvgParams[j], i):
movAvgVal = movAvgVal + c[k] * scaleMult
if movAvgParams[j] != 0:
movAvgVal = movAvgVal / movAvgParams[j]
if i == startPt: trtl.goto(n * 10, movAvgVal)
trtl.pendown()
trtl.goto(n * 10, movAvgVal)
trtl.penup()
# print("PlotTrades : ",plotTrades)
if trades.draw:
debugTradeDate = tradeDate[0]
debugDate = d[startPt]
n = 0
while debugTradeDate <= debugDate:
n += 1
debugTradeDate = tradeDate[n]
m = 0
for i in range(startPt, startPt + numBarsPlot):
m = m + 1
debugDate = d[i]
if debugDate == debugTradeDate:
trtl.penup()
tradeValue = tradePrice[n]
if tradeType[n] == "buy":
trtl.color("Green")
trtl.goto(m * 10 - 5, tradeValue - hhllDiff * .03)
trtl.pensize(3)
trtl.pendown()
trtl.goto(m * 10, tradeValue)
trtl.goto(m * 10 + 5, tradeValue - hhllDiff * .03)
trtl.penup()
if tradeType[n] == "sell":
trtl.color("Red")
trtl.goto(m * 10 - 5, tradeValue + hhllDiff * .03)
trtl.pensize(3)
trtl.pendown()
trtl.goto(m * 10, tradeValue)
trtl.goto(m * 10 + 5, tradeValue + hhllDiff * .03)
trtl.penup()
if tradeType[n] == "longLiq":
trtl.color("Blue")
trtl.penup()
trtl.goto(m * 10 - 5, tradeValue)
trtl.pensize(3)
trtl.pendown()
trtl.goto(m * 10 + 5, tradeValue)
trtl.penup()
trtl.pensize(1)
print("Found a trade: ", tradeValue, " ", debugTradeDate,
" m= ", m, " ", tradeValue - hhllDiff * .05)
n += 1
if n < len(tradeDate): debugTradeDate = tradeDate[n]
trtl.color("black")
trtl.goto(-10, botOfChart)
trtl.pendown()
trtl.goto(673, botOfChart)
trtl.penup()
trtl.goto(-10, botOfChart)
m = 0
for i in range(startPt, startPt + numBarsPlot):
if i % 10 == 0:
m = m + 1
trtl.pendown()
trtl.write(str(d[i]),
font=("Arial", 8, "bold")) # chosing the font
trtl.penup()
trtl.goto(m * 100, botOfChart)
trtl.penup()
trtl.goto(628, highestHigh)
trtl.pendown()
trtl.goto(628, botOfChart)
trtl.penup()
m = 0
vertIncrement = hhllDiff / 10
for i in range(0, 11):
trtl.goto(630, highestHigh - m * vertIncrement)
trtl.pendown()
trtl.write(str(highestHigh - m * vertIncrement),
font=("Arial", 8, "bold"))
trtl.penup()
m += 1
# turtle.done()
screen.onscreenclick(get_mouse_click_coor)
class Board:
""" Area of the screen dedicated to the connect 4 game board.
"""
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 draw(self):
self.pen.up()
self.pen.goto(self.corners[-1])
self.pen.color("#ddd")
self.pen.down()
self.pen.begin_fill()
for i in self.corners:
self.pen.goto(i)
self.pen.ht()
self.pen.end_fill()
return
def check_winner(self,space):
r, c = space.idx
if self.check_row(space,r,c) or \
self.check_column(space,r,c) or \
self.check_direction(space,r,c):
return True
return False
def check_row(self,space,r,c):
if space.state*4 in "".join([str(i.state) for i in self.spaces[r]]):
return True
def check_column(self,space,r,c):
if space.state*4 in "".join([str(i[c].state) for i in self.spaces]):
return True
def check_direction(self,space,r,c):
direct,score = [(-1,-1),(-1,1),(1,1),(1,-1)],[0,0]
for i,(x,y) in enumerate(direct):
idx = 0 if i % 2 == 0 else 1
score[idx] += self.check_angle(space,r,c,x,y,(x,y))
if max(score) >= 3: return True
return False
def check_angle(self,space,r,c,x,y,i):
if r+x >= 0 and r+x < 6 and c+y >= 0 and c+y < 7:
if self.spaces[r+x][c+y].state == space.state:
return 1 + self.check_diag(space,r,c,x+i[0],y+i[1],i)
return 0
return 0
def animate_drop(self,space):
r,c = space.idx
for i in range(r):
self.spaces[i][c].draw()
self.spaces[i][c].remove()
return
def space_empty(self,space):
r,c = space.idx
if r == len(self.spaces)-1 or self.spaces[r+1][c].state:
return space
for row in range(r+1,len(self.spaces)):
if self.spaces[row][c].state:
return self.spaces[row-1][c]
return self.spaces[len(self.spaces)-1][c]
def find_space(self,x,y):
for row in self.spaces:
cent,rad = row[0].center, row[0].radius
if y > cent[1] - rad and y < cent[1] + rad:
return self.search_column(row,x)
return False
def search_column(self,row,x):
for space in row:
x2 = space.center[0]
if x > x2-space.radius and x < x2 + space.radius:
return space
return False
def draw_spaces(self):
row,size = [],self.width/7
radius = (size*.9)/2
x,y = self.corners[0]
for j in range(6):
for i in range(7):
space_x = x + (size*i)
space_y = y - (size*j)
center = space_x+(size/2),space_y-(size/2)
color = "#643"
idx = (j,i)
space = Space(self,center,radius,color,idx)
row.append(space)
self.spaces.append(row)
row = []
return
x = (win_width / 2) - (app_width / 2)
y = (win_height / 2) - (app_height / 2)
master.geometry(f"{app_width}x{app_height}+{int(x)}+{int(y)}")
master.overrideredirect(True)
master.after(2000, lambda: master.destroy())
WIDTH, HEIGHT = 450, 450
canvas = Canvas(master, width=WIDTH, height=HEIGHT, bg="green")
canvas.pack(ipadx=30)
root = TurtleScreen(canvas)
turtle = RawTurtle(root, visible=False)
root.bgcolor("white")
turtle.color('#F09F13')
turtle.pensize(4)
turtle.speed(15)
turtle.hideturtle()
turtle.penup()
turtle.setposition(70, 90)
turtle.pendown()
turtle.fillcolor("#F09F13")
turtle.begin_fill()
turtle.circle(40)
turtle.end_fill()
turtle.hideturtle()
turtle.color('#fe7d96')
pen = RawTurtle(cv)
#create shape names and index for dropdown menu
shapes = [
"Revolver", "Tree", "Circle", "Cross", "Sun", "Biohazard", "Sierpinksi",
"More Circles", "Hexes and Circles", "Fern"
]
shapesIndex = 0
#create pen speeds and index for dropdown
speed = ["Fastest", "Medium", "Slowest"]
speedIndex = 0
#define initial pen speed and color
pen.speed(0)
pen.color('#0f0f0f')
root.update()
#end win setup
#========================== HANDLERS =============================#
def onChangeColorF():
#randomizes window background color
r = random.randint(0, 255)
red = str(hex(int(r)))[2:] #forces r as a string hex value minus '0x'
if len(red) < 2: #hex val needs to be 6 alphanumeric
return
#Tekitame rakendus
root = Tk()
root.title("Nuppudega Konn")
#mAARAME REA JA VEERY INDEKSIGA 0 KOIGE KAALUMATEKS
root.rowconfigure(index=0, weight=1)
root.columnconfigure(index=0, weight=1)
#Tekita louend,seo see root objektiga
c = Canvas(root, bg='green')
#Loendi nahtavaks muutmiseks paigutame ta lahtrisse 0,0
c.grid(column=0, row=0, sticky=(N, S, W, E))
#Seo loendiga TurtleScreen ja seo TurtleScreeniga konn
ts = TurtleScreen(c)
ts.bgcolor('cyan')
konn = RawTurtle(ts)
konn.color('green')
def edasi():
konn.forward(kiirus.get())
def vasakule():
konn.left(90)
def paremale():
konn.right(90)
#Tekitame nuppude paneeli f
class Vehicle:
###############################################################################################################
def __init__(self, turtle_window, id_number):
self.speed_params = [20, 0.2, 6]
self.turn_parameters = [20]
self.turtle_window = turtle_window
self.max_location = self.turtle_window.screen_size / 2 - 10
self.vehicle = RawTurtle(self.turtle_window.wn)
self.vehicle.hideturtle()
self.id_number = id_number
self.type = random.choice(["crossed", "direct"])
self.vehicle.shape('turtle')
self.vehicle.turtlesize(1)
self.vehicle.penup()
if self.type == 'crossed':
self.vehicle.color("red", (1, 0.85, 0.85))
else:
self.vehicle.color("blue", (0.85, 0.85, 1))
self.place()
self.vehicle.showturtle()
def place(self):
self.vehicle.goto(
random.randint(-self.max_location, self.max_location),
random.randint(-self.max_location, self.max_location))
self.vehicle.right(random.randint(0, 360))
###############################################################################################################
def move(self):
cumulative_speed = 0
cumulative_turn_amount = 0
for heat_source in self.turtle_window.heat_source_list:
input_distance = self.vehicle.distance(
heat_source.heat_source.pos())
input_angle = self.vehicle.heading() - self.vehicle.towards(
heat_source.heat_source.pos())
sin_angle = math.sin(math.radians(input_angle))
left_sensor_distance = input_distance - sin_angle
right_sensor_distance = input_distance + sin_angle
left_speed, right_speed, combined_speed = self.compute_speed(
left_sensor_distance, right_sensor_distance)
turn_amount = self.turn_parameters[0] * (right_speed - left_speed)
cumulative_speed += combined_speed
cumulative_turn_amount += turn_amount
if isinstance(cumulative_turn_amount, complex):
cumulative_turn_amount = 0
if cumulative_speed < 0:
cumulative_speed = 0
self.vehicle.right(cumulative_turn_amount)
self.vehicle.forward(cumulative_speed)
self.check_border_collision()
def check_border_collision(self):
if self.vehicle.xcor() > self.max_location:
self.vehicle.goto(self.max_location, self.vehicle.ycor())
if self.vehicle.xcor() < -self.max_location:
self.vehicle.goto(-self.max_location, self.vehicle.ycor())
if self.vehicle.ycor() > self.max_location:
self.vehicle.goto(self.vehicle.xcor(), self.max_location)
if self.vehicle.ycor() < -self.max_location:
self.vehicle.goto(self.vehicle.xcor(), -self.max_location)
if self.vehicle.ycor() <= -self.max_location:
if 0 <= self.vehicle.heading() <= 180:
turn_angle = 180 - self.vehicle.heading()
self.vehicle.setheading(turn_angle)
else:
turn_angle = abs(360 - self.vehicle.heading())
self.vehicle.setheading(turn_angle)
if self.vehicle.ycor() >= self.max_location:
if 0 <= self.vehicle.heading() <= 180:
turn_angle = 360 - self.vehicle.heading()
self.vehicle.setheading(turn_angle)
else:
turn_angle = 360 - (self.vehicle.heading() - 180)
self.vehicle.setheading(turn_angle)
if self.vehicle.xcor() <= -self.max_location:
if 0 <= self.vehicle.heading() <= 90:
turn_angle = 360 - self.vehicle.heading()
self.vehicle.setheading(turn_angle)
if 270 < self.vehicle.heading() <= 360:
turn_angle = 360 - self.vehicle.heading()
self.vehicle.setheading(turn_angle)
if 90 < self.vehicle.heading() < 180:
turn_angle = self.vehicle.heading() - 90
self.vehicle.setheading(turn_angle)
if 180 <= self.vehicle.heading() <= 360:
turn_angle = self.vehicle.heading() + 90
self.vehicle.setheading(turn_angle)
if self.vehicle.xcor() >= self.max_location:
if 0 <= self.vehicle.heading() <= 180:
turn_angle = self.vehicle.heading() + 90
self.vehicle.setheading(turn_angle)
else:
turn_angle = self.vehicle.heading() - 90
self.vehicle.setheading(turn_angle)
###############################################################################################################
def compute_speed(self, left_distance, right_distance):
if self.type == 'crossed':
left_speed = (
self.speed_params[0] /
(right_distance**self.speed_params[1])) - self.speed_params[2]
right_speed = (
self.speed_params[0] /
(left_distance**self.speed_params[1])) - self.speed_params[2]
else:
left_speed = (
self.speed_params[0] /
(left_distance**self.speed_params[1])) - self.speed_params[2]
right_speed = (
self.speed_params[0] /
(right_distance**self.speed_params[1])) - self.speed_params[2]
combined_speed = (left_speed + right_speed) / 2
return left_speed, right_speed, combined_speed
import tkinter as tk
from turtle import RawTurtle, TurtleScreen, ScrolledCanvas
root = tk.Tk()
width, height = root.winfo_screenwidth(), root.winfo_screenheight()
root.overrideredirect(True)
root.attributes('-alpha', 0.08)
canvas = ScrolledCanvas(root)
canvas.pack(fill=tk.BOTH, expand=tk.YES)
screen = TurtleScreen(canvas)
root.state('zoomed')
turtle = RawTurtle(screen)
turtle.color('red', 'red')
turtle.speed('fastest')
turtle.pensize(4)
# left, top, right, bottom = 100, 100, 900, 900
# def draw_rect(left, top, right, bottom):
# turtle.penup()
# turtle.goto(left, top) # left, top
# turtle.pendown()
# turtle.goto(right, top)
# turtle.goto(right, bottom)
# turtle.goto(left, bottom)
# turtle.goto(left, top)
# turtle.penup()
#
class Stage:
@classmethod
def create(cls, screen):
stage = cls(screen)
start = screen.start
blocks = screen.blocks
for i in range(blocks):
stop = start + screen.blockwidth
stage.positions.append((start,stop))
base = -screen.base
height = screen.increment * (i+1)
color = next(screen.gradient)
block = Block(screen, base=base, index=i, height=height, parent=stage, color=color)
stage.blocks.append(block)
block.draw()
start = stop + 1
stage.get_pen()
return stage
def append(self, other):
if other.index:
other.clear()
l = len(self)
other.index = (l)
self.blocks.append()
def slice(self, *args):
if len(args) > 2: raise Exception
if len(args) == 2: start, stop = args
if len(args) == 1: start, stop = 0, args[0]
if len(args) == 0: start, stop = 0, len(self.blocks)
stage = Stage(self.screen)
for idx, i in enumerate(range(start,stop)):
stage.positions.append(self.positions[i])
block = self.blocks[i].new()
block.index = idx
stage.blocks.append(block)
return stage
def __init__(self, screen):
self.screen = screen
self.positions = []
self.blocks = []
self.operations = 0
self.pen = None
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 __getitem__(self, idx):
return self.blocks[idx]
def __setitem__(self, idx, other):
if other.index not in [idx, None]:
other.clear()
self.blocks[other.index] = None
if self.blocks[idx] != None:
self.blocks[idx].clear()
self.blocks[idx].delindex()
self.blocks[idx] = other
self.blocks[idx].setindex(idx)
other.draw()
def __str__(self):
return str([i.value for i in self.blocks])
def __repr__(self):
return str(self)
def __len__(self):
return len(self.blocks)
def __iter__(self):
self.iterable = iter(self.blocks)
return self.iterable
def __next__(self):
try:
block = next(self.iterable)
return block
except StopIteration:
raise StopIteration
class TurtleCanvas():
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 changeDirection(self,event):
#print(self.rightDirection)
if(self.rightDirection):
self.rightDirection = False
else:
self.rightDirection = True
def changeColor(self,event):
currentColorIndex = colors.index(self.turtle.color()[0])
if (currentColorIndex == (len(colors) - 1)):
self.turtle.color(colors[0])
else:
self.turtle.color(colors[currentColorIndex + 1])
def scroll_start(self,event):
self.canvas.scan_mark(event.x, event.y)
def scroll_move(self,event):
self.canvas.scan_dragto(event.x, event.y, gain=1)
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):
for i in range(3):
self.turtle.forward(sidelength)
self.turtle.right(120)
def star(self,sidelength = 50):
for i in range(5):
self.turtle.forward(sidelength)
self.turtle.right(144)
def shapeDriver(self, shapeFunc, steps):
self.turtle.st()
i = 0
for j in range(steps):
shapeFunc(1 + i)
if(self.rightDirection == True):
self.turtle.right(1)
else:
self.turtle.left(1)
i += 0.1
self.turtle.ht()
def helperDriver(self, shape, steps, color):
print(color)
self.turtle.color(color)
if(shape == "Square"):
self.shapeDriver(self.square,steps)
if(shape == "Triangle"):
self.shapeDriver(self.triangle,steps)
if(shape == "Star"):
self.shapeDriver(self.star,steps)
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:
t.fd(50)
t.lt(72)
for t in p,q:
class Window(Screen):
"""Class to generate game window, tkcanvas subclass.
"""
def __init__(self, color="#643", mode=1):
""" Constructor for TK window.
color {str} -- hex color string (default: {None})
"""
super().__init__()
self.player_mode = mode
self.new_game(color)
def new_game(self, color):
""" Starts a New Game, Draws game board and creates Players.
Args: color{str} - Hex-Color passed along from constructor.
"""
self.setup(.8, .9, 1000, 0)
self.width = (self.window_width() * .9)
self.height = (self.window_height() * .9)
self.x = self.width / 2
self.y = self.height / 2
# ^ dimensions of game board
self.font = ('Arial', 20, 'bold'), "#f50"
# ^ Game Status Messages written above Game Board
self.winner = None
# ^ slot is adjusted once a winner is established.
self.bgcolor(color)
self.start_message()
self.delay(8)
self.tracer(2)
# functions for controlling animation speed
self.game_board()
self.create_players()
self.player.turn()
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 create_players(self):
""" Creates 2 player objects. Either AI controlled of User controlled
Player_mode 1 = User vs User
Player_mode 2 = User vs AI
Player_mode 3 = AI vs AI
"""
if self.player_mode in [1, 2]:
player_1 = Player(1, "#f00")
if self.player_mode == 1: player_2 = Player(2, "#000")
else: player_2 = Ai(2, "#000", self.board, self)
else:
player_1 = Ai(1, "#f00", self.board, self)
player_2 = Ai(2, "#000", self.board, self)
self.player = player_1
self.players = (player_1, player_2)
def activate_space(self, x, y):
"""
Onclick callback: assigns the bottom most space to active player.
Arguements: (x{int},y{int}) = window coordinates for click position.
"""
space = self.board.find_space(x, y)
#find the space associated with the position given by onclick method
if space and not space.state:
space = self.board.space_empty(space)
self.board.animate_drop(space)
""" if space is valid... check if it is the bottommost empty
space in column or return the bottom space and render
dropping animation
"""
space.draw(color=self.player.color)
space.state = self.player.name
""" fill bottommost empty space with players color
set space state to filled by active player """
if self.board.check_winner(space):
# check if game over
self.draw_message(f"GAME OVER {self.player} WINS")
return
# switch active players
self.player = self.players[
0] if self.players[0] != self.player else self.players[1]
self.draw_message(str(self.player) + " Turn")
self.player.turn()
else:
# if click is not in valid empty space player turn continues
self.draw_message("Try Again")
self.player.turn()
def draw_message(self, msg):
""" Write game state update messages to top of the window """
self.pen.clear()
self.pen.write(msg, align="center", font=self.font[0])
return
def play(self):
self.onclick(self.activate_space)
def game_board(self):
""" Calculates and generates the board object. """
board_height = (self.height // 42) * 42
board_width = (board_height * 7) / 6
bx = board_width / 2
by = board_height / 2
board_corners = [(-bx, by), (-bx, -by), (bx, -by), (bx, by)]
self.board = Board(self, board_corners, board_width, board_height, bx,
by)
return
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)
canvas = tk.Canvas(master=root, bg="black", width=500, height=500)
# The next 2 lines are mandatory if we want to change the background color
turtle_screen = TurtleScreen(canvas)
turtle_screen.bgcolor("black")
# This is mandatory if we want to use Turtle
canvas.pack()
# Creating the two pens
# Using RawTurtle is mandatory for the integration
pen1 = RawTurtle(turtle_screen)
pen2 = RawTurtle(turtle_screen)
# Configuring the first pen
# The first color is the color of the pen
# The second is color we want to use to fill the figure
pen1.color("misty rose", "violet")
pen1.width(3)
# Configuring the second pen
pen2.color("violet", "misty rose")
pen2.width(3)
# Drawing the figure
pen1.begin_fill()
pen2.begin_fill()
pen1.goto(0, 100)
pen2.goto(0, 100)
pen1.goto(0, -50)
pen2.goto(0, -50)
pen2.left(40)
pen1.left(140)
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)
class Robot:
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 reset(self):
#set start positions for robots
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)]
#move robot to starting possition
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(0)
self.turtle.screen.bgcolor("sky blue")
def orientate(self, landmarks, canvas, goal):
##sd = shortest distance
##x1,x2,y1,y2 = circles corners
##lx,ly = length x/y
##h = hypothinus
##ln = landmark number
sd = 40000000
ln = 0
for ID in landmarks:
if canvas.itemcget(ID, "fill") == "dark green":
ln+=1
x1,y1,x2,y2 = canvas.coords(ID)
lx = ((x1+x2)/2) - self.turtle.xcor()
ly = ((y1+y2)/2) - self.turtle.ycor()
h = math.sqrt(lx*lx + ly*ly)
if h < sd:
sd = h
stored_ID = ID
stored_x = lx
stored_y = ly
if ln == 0:
stored_ID = goal
x1,y1,x2,y2 = canvas.coords(goal)
lx = ((x1+x2)/2) - self.turtle.xcor()
ly = ((y1+y2)/2) - self.turtle.ycor()
sd = math.sqrt(lx*lx + ly*ly)
stored_x = ((x1+x2)/2) - self.turtle.xcor()
stored_y = ((y1+y2)/2) - self.turtle.ycor()
if sd < 37:
return stored_ID
if stored_x < 0:
if stored_y < 0:
new_heading = 180 + math.degrees(math.atan((-stored_y)/(-stored_x)))
else:
new_heading = 180 - math.degrees(math.atan(stored_y/(-stored_x)))
elif stored_y < 0:
new_heading = 360 - math.degrees(math.atan((-stored_y)/stored_x))
else:
new_heading = math.degrees(math.atan(stored_y/stored_x))
self.turtle.seth(new_heading)
return False
def collisions_move(self, speed, depth):
##breaks the recursion if the robots get to close
if depth > 10:
return
##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))
##check for the collision
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 left:
##turn away
self.turtle.left(20)
self.collisions_move(speed, depth+1)
#self.turtle.forward(speed/5)
elif right:
##turn away
self.turtle.right(20)
self.collisions_move(speed, depth+1)
#self.turtle.forward(speed/5)
else:
##else move forward
self.turtle.forward(speed)
return
