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등을 맞추지 못했습니다.")
class Sugar:
def __init__(self, turtle_window, id_number):
# comment here
self.turtle_window = turtle_window
self.id_number = id_number
self.name = 'Sugar'
# comment here
self.turtle_object = RawTurtle(self.turtle_window.wn)
self.turtle_object.hideturtle()
self.turtle_object.shape('square')
self.turtle_object.penup()
self.turtle_object.color("black", "white")
self.place()
self.turtle_object.showturtle()
# comment here
self.turtle_object.ondrag(self.drag)
def place(self):
# comment here
self.turtle_object.goto(random.randint(-MAX_LOCATION, MAX_LOCATION),
random.randint(-MAX_LOCATION, MAX_LOCATION))
def drag(self, x, y):
# comment here
self.turtle_object.goto(x, y)
self.turtle_window.wn.update()
def draw_polygon(self, node, screen):
pen = RawTurtle(screen)
pen.speed(0)
pen.hideturtle()
pen.penup()
try:
linecolor = node.attrs['color']
except KeyError:
linecolor = None
try:
fillcolor = node.attrs['fillcolor']
except KeyError:
fillcolor = None
if linecolor is not None:
pen.pencolor(*linecolor)
else:
pen.pencolor(*(0, 0, 0))
polygon = node.data
polygon = [self.translate_coords(screen, x) for x in polygon]
points = to_tups(polygon)
pen.goto(*(points[0]))
pen.pendown()
if fillcolor:
pen.fillcolor(*fillcolor)
pen.pencolor(*fillcolor)
pen.begin_fill()
for point in points[::-1]:
pen.goto(*point)
if fillcolor:
pen.end_fill()
class Object:
"""Die Klasse Beschreibt wie ein Obst oder Gift aussieht"""
def __init__(self, window, shape):
self.obj = RawTurtle(window)
self.obj.speed(0)
self.obj.shape(shape)
self.obj.penup()
self.obj.goto(0, 100)
def getObj(self):
return self.obj
def getYPos(self):
return self.obj.ycor()
def getXPos(self):
return self.obj.xcor()
# In Dieser Methode wird ein Obst oder ein Gift genau auf die Stelle gesetzt, an der der Schlangenkopf es genau im richtige Pixel treffen kann.
def setPos(self, x, y):
self.obj.goto(x, y)
self.obj.sety(self.obj.ycor() - (self.obj.ycor() % 20))
self.obj.setx(self.obj.xcor() - (self.obj.xcor() % 20))
return
def hideObj(self):
self.obj.hideturtle()
def randomPos(self):
x = random.randint(-280, 280)
y = random.randint(-280, 280)
self.setPos(x, y)
def getReady():
for i in [ 5, 4, 3, 2, 1 ,0]:
time.sleep(1)
line = RawTurtle(myGameField.getRootWindow())
line.speed(0)
line.shape("square")
line.color("white")
line.penup()
line.hideturtle() # Versteckte Überschrift
line.goto(0,0)
line.write("Get ready %s" % i , align= "center", font=("Courier", 18 ,"normal"))
line.clear()
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)
def draw(list_rectangles, list_squares):
"""
Opens a window and draws all the Rectangles and Squares using turtle module
Args:
list_rectangles (list): list of rectangles to draw
list_squares (list): list of squares to draw
"""
screen = Screen()
screen.setup()
screen.bgcolor("black")
colors = ["cyan", "red", "blue", "white",
"purple", "green", "brown", "#285078"]
square = RawTurtle(screen)
rectangle = RawTurtle(screen)
# square.speed(10)
# rectangle.speed(10)
for sq in list_squares:
square.penup()
square.home()
square.color(random.choice(colors))
square.goto(sq.x, sq.y)
square.pendown()
square.begin_fill()
i = 0
while i < 4:
square.forward(sq.size)
square.left(90)
i += 1
square.end_fill()
square.hideturtle()
for rect in list_rectangles:
rectangle.penup()
rectangle.home()
rectangle.color(random.choice(colors))
rectangle.goto(rect.x, rect.y)
rectangle.pendown()
i = 0
while i < 2:
rectangle.forward(rect.width)
rectangle.left(90)
rectangle.forward(rect.height)
rectangle.left(90)
i += 1
rectangle.hideturtle()
done()
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()
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()
root.title("cambio de tamaño")
canvas = TK.Canvas(root, width=1000, height=1000,
bg="white")
canvas.pack()
screen = TurtleScreen(canvas)
turtle = RawTurtle(screen)
while True:
x = getInput()
if x in ["","0","00", None]:
break
turtle.reset()
turtle.hideturtle()
ops = [int(y) for y in x.split()]
x = ops[0]
if x == 1:
invoca(rectangulo, 2, ops[1:])
elif x == 2:
invoca(cuadrado, 1, ops[1:])
elif x == 3:
invoca(triangulo, 1, ops[1:])
elif x == 4:
invoca(casa, 1, ops[1:])
elif x == 5:
invoca(doodle, 1, ops[1:])
elif x == 6:
invoca(patron01, 1, ops[1:])
elif x == 7:
class HP(tk.Tk):
"""
* In requirements analysis there was method called configure(). I used method called config(),
* because tk has method configure and don't know if it's meant to override that method and don't know how to get
* around this without overriding tk method..
* Currently there might not be enough words in expert level to play the game through..
"""
class THangman(Hangman):
def __init__(self, parent):
self.level = parent.config()
self.points = 0
self._Hangman__words = self.readWords()
super().__init__()
def readWords(self):
"""
* Overrides Hangman class method to use Classifier class method
"""
c = Classifier()
return c.readWords(self.level)
def newLevel(self):
"""
* game has levels 0-4. Method updates level to next one. If player is in level 4, next one is 0.
* After the level is updated, corresponding words are read to attribute _Hangman__words
"""
if self.level < 4:
self.level += 1
message = "Congratulations! You have reached new level. You are now at " + levels[
self.level] + " level"
messagebox.showinfo("New level reached", message)
else:
self.level = 0
message = "Congratulations! You are now master of Hangman game, a Yoda of words!. Game will now start" \
" again in the demonstration level"
messagebox.showinfo("New level reached", message)
self._Hangman__words = self.readWords()
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 deserialize(self):
"""
* deserializes HP.THangman object from file hangman.dat
* reads object in binary mode
"""
file = None
try:
file = open(self.dataPath + self.dataFile, 'br')
hp = pickle.load(file)
if hp is not None and isinstance(hp, type(self.__hp)):
self.__hp = hp
except IOError as e:
print(f'Tapahtui virhe: {e}')
finally:
if file:
file.close()
def restoreGUI(self):
"""
* restores already drawn hanging tree from saved game
* and restores already pressed buttons from saved game
"""
missed = len(self.__hp.missed)
if missed > 0:
drawer = Drawer(self.turtle_screen, self.raw_turtle)
for i in range(1, missed + 1):
step_to_draw = {
1: drawer.basement,
2: drawer.main_bar,
3: drawer.upper_bar,
4: drawer.rope,
5: drawer.head,
6: drawer.body,
7: drawer.left_foot,
8: drawer.right_foot,
9: drawer.left_arm,
10: drawer.right_arm
}
step_to_draw[i]()
if missed > 0 or len(self.__hp.corrects) > 0:
for button in self.Buttons.buttons:
letter = button['text'].lower()
if letter in self.__hp.missed or letter in self.__hp.corrects:
button.config(state='disabled')
def serialize(self):
"""
* Saves the state of HP.THangman object to file
* writes in binary mode and creates file if it doesn't exist
"""
file = None
try:
file = open(self.dataPath + self.dataFile, 'bw+')
pickle.dump(self.__hp, file)
except IOError as e:
print(f'Tapahtui virhe: {e}')
finally:
if file:
file.close()
def close(self):
"""
* Called when main window's exit is pressed
* Ask from user if one want's to save game before quitting
"""
msg_box = messagebox.askquestion(
"Save",
"Do you want to save your game before closing?",
icon='warning')
if msg_box == "yes":
self.serialize()
self.destroy()
def config(self, write=False):
"""
* write=False:
* creates new dir for data if there isn't one
* creates new conf. file if there isn't one
* returns level if write=False, default is 0
* write=True:
* writes level to conf. file
"""
file = None
level = None
if not write:
if not os.path.exists("data/"):
os.makedirs("data")
try:
file = open(self.dataPath + self.configurationFile,
'r',
encoding="utf-8")
for row in file:
row = row.strip()
if len(row) > 0:
level = int(row.split(":", 1)[1])
file.close()
except (FileNotFoundError, IOError):
c = Classifier()
c.read()
c.classify()
level = 0
try:
file = open(self.dataPath + self.configurationFile,
'w',
encoding="utf-8")
file.write("level:" + str(level) + "\n")
file.close()
except IOError as e:
print(
f'Tiedostoa {self.configurationFile} ei voitu luoda: {e}'
)
finally:
if file is not None:
file.close()
return level
else:
try:
file = open(self.dataPath + self.configurationFile,
'w',
encoding="utf-8")
file.write("level:" + str(self.__hp.level) + '\n')
file.close()
except IOError as e:
print(
f'Tiedostoon {self.configurationFile} ei voitu kirjoittaa: {e}'
)
finally:
if file is not None:
file.close()
def check(self, c_letter):
"""
* every (wrong) or right guessed letter is worth (-)100 points.
* e.g. guessable word includes three times letter 'A' -> only worth 100 points
* if word is guessed right then 100*[length_of_word] is added to points
* player can reach next level only then when word is guessed right and one has 10 000 or more points
"""
letter = c_letter.lower()
if letter not in self.__hp.corrects and letter not in self.__hp.missed:
if self.__hp.check(letter):
self.__hp.points += 100
self.output.set(self.__hp.getLetters)
if self.__hp.isWin():
self.__hp.points = 100 * len(
self.__hp.getWord) + self.__hp.points
self.Buttons.disableAll()
self.info.set("You guessed right, well done!!")
if self.__hp.points >= 10000:
self.__hp.newLevel()
self.config(True)
else:
self.__hp.points -= 100
drawer = Drawer(self.turtle_screen, self.raw_turtle)
step_to_draw = {
1: drawer.basement,
2: drawer.main_bar,
3: drawer.upper_bar,
4: drawer.rope,
5: drawer.head,
6: drawer.body,
7: drawer.left_foot,
8: drawer.right_foot,
9: drawer.left_arm,
10: drawer.right_arm
}
step_to_draw[len(self.__hp.missed)]()
if len(self.__hp.missed) == len(step_to_draw):
self.info.set("HANGED! You failed to guess " +
str(self.__hp.getWord))
def new(self):
self.__hp.reset()
self.output.set(self.__hp.getLetters)
self.Buttons.enableAll()
self.info.set("")
self.raw_turtle.reset()
self.raw_turtle.hideturtle()
self.raw_turtle.speed(0)
pen2.left(40)
pen1.left(140)
pen2.forward(100)
pen1.forward(100)
for side in range(185):
pen2.forward(1)
pen1.forward(1)
pen2.left(1)
pen1.right(1)
# Filling the figure
pen2.end_fill()
pen1.end_fill()
# Deleting the arrows of the pens when the figure is finished
pen2.hideturtle()
pen1.hideturtle()
# Third and forth pen that write the sentence after the figure is finished
pen3 = RawTurtle(turtle_screen)
pen3.speed(0)
pen3.color("deep pink")
pen3.width(3)
pen3.penup()
pen3.goto(0, 150)
pen3.pendown()
pen3.write('I Love You!', font=('Courier', 40, 'bold'), align='center')
pen3.penup()
pen3.goto(0, -150)
pen3.pendown()
pen3.write('Facciapi!', font=('Courier', 40, 'bold'), align='center')
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):
"""
TODO: docstring
"""
def buildWindow(self):
canvas = ScrolledCanvas(self, 600, 600, 600, 600)
canvas.pack(side=tkinter.LEFT)
t = RawTurtle(canvas)
screen = t.getscreen()
screen.tracer(100000)
screen.setworldcoordinates(screenMin, screenMin, screenMax, screenMax)
screen.bgcolor("white")
t.hideturtle()
frame = tkinter.Frame(self)
frame.pack(side=tkinter.RIGHT, fill=tkinter.BOTH)
board = Board(None, screen)
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()
drawGrid()
def newGame():
# drawGrid()
self.turn = HUMAN
board.reset()
self.locked = False
screen.update()
def startHandler():
newGame()
btn_Start = tkinter.Button(frame, text="New Game", command=startHandler)
btn_Start.pack()
tkvar = tkinter.StringVar(self)
tkvar.set(self.level)
def levelHandler(*args):
self.level = tkvar.get()
lbl_Level = tkinter.Label(frame, text="AI level")
lbl_Level.pack()
dd_Level = tkinter.OptionMenu(frame, tkvar, command=levelHandler, *AILVLS)
dd_Level.pack()
def quitHandler():
self.master.quit()
btn_Quit = tkinter.Button(frame, text="Quit", command=quitHandler)
btn_Quit.pack()
def computerTurn():
"""
The locked variable prevents another event from being
processed while the computer is making up its mind.
"""
self.locked = True
maxMove = None
# Call Minimax to find the best move to make.
# After writing this code, the maxMove tuple should
# contain the best move for the computer. For instance,
# if the best move is in the first row and third column
# then maxMove would be (0,2).
# TODO: IMPLEMENT THE DESCRIBED LOGIC
row, col = maxMove
board[row][col] = X(canvas)
self.locked = False
def mouseClick(x, y):
if not self.locked:
row = int(y // 100)
col = int(x // 100)
if board[row][col].eval() == 0:
board[row][col] = O(canvas)
self.turn = COMPUTER
board.drawXOs()
if not board.full() and not abs(board.eval()) == 1:
computerTurn()
self.turn = HUMAN
board.drawXOs()
else:
self.locked = True
if board.eval() == 1:
tkinter.messagebox.showwarning(
"Game Over", "Expectedly, Machine wins."
)
elif board.eval() == -1:
tkinter.messagebox.showerror(
"Game Over", "Suprisingly, Human wins."
)
elif board.full():
tkinter.messagebox.showinfo("Game Over", "It was a tie.")
screen.onclick(mouseClick)
screen.listen()
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
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
class HP(tk.Tk):
"""
* In requirements analysis there was method called configure(). I used method called config(),
* because tk has method configure and don't know if it's meant to override that method and don't know how to get
* around this without overriding tk method..
* Currently there might not be enough words in expert level to play the game through..
"""
class THangman(Hangman):
def __init__(self, parent):
self.level = parent.config()
self.points = 0
self._Hangman__words = self.readWords()
super().__init__()
def readWords(self):
"""
* Overrides Hangman class method to use Classifier class method
"""
c = Classifier()
return c.readWords(self.level)
def newLevel(self):
"""
* game has levels 0-4. Method updates level to next one. If player is in level 4, next one is 0.
* After the level is updated, corresponding words are read to attribute _Hangman__words
"""
if self.level < 4:
self.level += 1
message = "Congratulations! You have reached new level. You are now at " + levels[
self.level] + " level"
messagebox.showinfo("New level reached", message)
else:
self.level = 0
message = "Congratulations! You are now master of Hangman game, a Yoda of words!. Game will now start" \
" again in the demonstration level"
messagebox.showinfo("New level reached", message)
self._Hangman__words = self.readWords()
def __init__(self, title="Hangman"):
super().__init__()
self.title(title)
self.geometry("720x600")
self.configurationFile = "level.conf"
self.__hp = HP.THangman(self)
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="Start a new game",
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)
message = "You are currently playing in " + levels[
self.__hp.level] + " level"
messagebox.showinfo("Level of difficulty", message)
def config(self, write=False):
file = None
level = None
if not write:
try:
file = open(self.configurationFile, 'r', encoding="utf-8")
for row in file:
row = row.strip()
if len(row) > 0:
level = int(row.split(":", 1)[1])
file.close()
except (FileNotFoundError, IOError):
c = Classifier()
c.read()
c.classify()
level = 0
try:
file = open(self.configurationFile, 'w', encoding="utf-8")
file.write("level:" + str(level) + "\n")
file.close()
except IOError as e:
print(
f'Tiedostoa {self.configurationFile} ei voitu luoda: {e}'
)
finally:
if file is not None:
file.close()
return level
else:
try:
file = open(self.configurationFile, 'w', encoding="utf-8")
file.write("level:" + str(self.__hp.level) + '\n')
file.close()
except IOError as e:
print(
f'Tiedostoon {self.configurationFile} ei voitu kirjoittaa: {e}'
)
finally:
if file is not None:
file.close()
def check(self, c_letter):
"""
* every (wrong) or right guessed letter is worth (-)100 points.
* e.g. guessable word includes three times letter 'A' -> only worth 100 points
* if word is guessed right then 100*[length_of_word] is added to points
* player can reach next level only then when word is guessed right and one has 10 000 or more points
"""
letter = c_letter.lower()
if letter not in self.__hp.corrects and letter not in self.__hp.missed:
if self.__hp.check(letter):
self.__hp.points += 100
self.output.set(self.__hp.getLetters)
if self.__hp.isWin():
self.__hp.points = 100 * len(
self.__hp.getWord) + self.__hp.points
self.Buttons.disableAll()
self.info.set("You guessed right, well done!!")
if self.__hp.points >= 10000:
self.__hp.newLevel()
self.config(True)
else:
self.__hp.points -= 100
drawer = Drawer(self.turtle_screen, self.raw_turtle)
step_to_draw = {
1: drawer.basement,
2: drawer.main_bar,
3: drawer.upper_bar,
4: drawer.rope,
5: drawer.head,
6: drawer.body,
7: drawer.left_foot,
8: drawer.right_foot,
9: drawer.left_arm,
10: drawer.right_arm
}
step_to_draw[len(self.__hp.missed)]()
if len(self.__hp.missed) == len(step_to_draw):
self.info.set("HANGED! You failed to guess " +
str(self.__hp.getWord))
def new(self):
self.__hp.reset()
self.output.set(self.__hp.getLetters)
self.Buttons.enableAll()
self.info.set("")
self.raw_turtle.reset()
self.raw_turtle.hideturtle()
self.raw_turtle.speed(0)
class Basilisk:
"""Die Klasse Basilisk beschreibt die Eigenschaften und das Verhalten einer Schlange auf dem Spielfeld"""
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 getMouth(self):
return self.mouth
def getBodyList(self):
return self.body
def getTempScore(self):
return self.tempScore
def setTempScore(self, tempScore):
self.tempScore = tempScore
def getBodyLen(self):
return len(self.body)
def getYPos(self):
return self.mouth.ycor()
def getXPos(self):
return self.mouth.xcor()
def setMouthPos(self, x, y):
self.mouth.goto(x, y)
def getSpeed(self):
return self.speed
def getScore(self):
return self.score
def getHighScore(self):
return self.highScore
def setSpeed(self, speed):
self.speed = speed
def setScore(self, score):
self.score = score
def setHighScore(self, highScore):
self.highScore = highScore
def getMouthDirection(self):
return self.mouth.direction
# Mit der setMouthDirection Methode bewegt sich die Schlange in eine bestimmte Richtung.
def setMouthDirection(self, mouthDirection):
if mouthDirection == "left":
self.moveLeftwards()
elif mouthDirection == "right":
self.moveRightwards()
elif mouthDirection == "up":
self.moveUpwards()
else:
self.moveDownwards()
# Mit der moveUpwards Methode bewegt sich die Schlange nach oben.
def moveUpwards(self):
gifUp = "model/resources/up.gif"
if self.mouth.direction != "down":
self.mouth.direction = "up"
self.mouth.shape(gifUp)
# Mit der moveDownwards Methode bewegt sich die Schlange nach unten.
def moveDownwards(self):
gifDown = "model/resources/down.gif"
if self.mouth.direction != "up":
self.mouth.direction = "down"
self.mouth.shape(gifDown)
# Mit der moveLeftwards Methode bewegt sich die Schlange nach links.
def moveLeftwards(self):
gifLeft = "model/resources/left.gif"
if self.mouth.direction != "right":
self.mouth.direction = "left"
self.mouth.shape(gifLeft)
# Mit der moveRightwards Methode bewegt sich die Schlange nach rechts.
def moveRightwards(self):
gifRight = "model/resources/right.gif"
if self.mouth.direction != "left":
self.mouth.direction = "right"
self.mouth.shape(gifRight)
# Mit der move Methode wird beschrieben, wie groß ein Sritt der Schlange in alle Richtungen ist.
def move(self):
if self.mouth.direction == "up":
self.mouth.sety(self.mouth.ycor() + 20)
if self.mouth.direction == "down":
self.mouth.sety(self.mouth.ycor() - 20)
if self.mouth.direction == "left":
self.mouth.setx(self.mouth.xcor() - 20)
if self.mouth.direction == "right":
self.mouth.setx(self.mouth.xcor() + 20)
def bodyFollowMouth(self):
for index in range(len(self.body) - 1, 0, -1):
self.body[index].goto(self.body[index - 1].xcor(),
self.body[index - 1].ycor())
if len(self.body) > 0:
self.body[0].goto(self.mouth.xcor(), self.mouth.ycor())
# Erweitere den Körper um einen Teil.
def basiliskFeeded(self, window, shape):
oneBodyBlock = RawTurtle(window)
oneBodyBlock.speed(0)
oneBodyBlock.shape(shape)
oneBodyBlock.penup()
self.body.append(oneBodyBlock)
# Gib ein Dictionary mit der Position von jedem Teil des Körpers zurück.
def getBodyPosInListOfDic(self):
if len(self.body) > 0:
allBlockskPos = []
for i in range(0, len(self.body)):
x = self.body[i].xcor()
y = self.body[i].ycor()
allBlockskPos.append({"bodyBlock" + str(i): {'x': x, 'y': y}})
return allBlockskPos
def setBodyBlockPos(self, i, x, y):
self.body[i].goto(x, y)
def basiliskPoisoned(self):
if len(self.body) > 0:
self.body[-1].goto(1000, 1000)
self.body.pop()
return
else:
self.deadFromPoison = True
def basiliskLives(self):
self.deadFromPoison = False
# Die Schlange darf durch Wände laufen.
def basiliskPushTheWall(self):
if self.mouth.xcor() > 290:
self.mouth.setx(self.mouth.xcor() - 580)
elif self.mouth.xcor() < -290:
self.mouth.setx(self.mouth.xcor() + 580)
elif self.mouth.ycor() > 290:
self.mouth.sety(self.mouth.ycor() - 580)
elif self.mouth.ycor() < -290:
self.mouth.sety(self.mouth.ycor() + 580)
# Die Schlange ist tod, wenn sie gegen ihre Körperteile stößt.
def basiliskIsDead(self):
if self.deadFromPoison:
return True
for item in self.body:
basiliskEatsHerself = item.distance(self.mouth) < 20
if basiliskEatsHerself:
return True
def basiliskEats(self, obj):
return self.mouth.distance(obj) < 20
def basiliskGoHome(self):
self.mouth.home()
self.mouth.direction = "stop"
def basiliskDeleteBody(self):
for item in self.body:
item.goto(1000, 1000)
self.body.clear()
def hideMouth(self):
self.mouth.hideturtle()
def isVisible(self):
return self.mouth.isvisible()
def showMouth(self):
self.mouth.showturtle()
WIDTH = 1200
HEIGHT = 675
START_POS = (-WIDTH / 2), (-HEIGHT / 2) + HEIGHT / 20
# print(START_POS)
root = Tk()
# set up canvas
canvas = Canvas(root, width=WIDTH, height=HEIGHT, highlightthickness=0)
turtle_screen = TurtleScreen(canvas)
turtle_screen.bgcolor("black")
canvas.pack()
# set up turtle
turt = RawTurtle(turtle_screen)
turt.hideturtle()
turt.speed(0)
turt.pencolor("RED")
turt.width(3)
turt.up()
turt.setx(START_POS[0])
turt.sety(START_POS[1])
turt.down()
farthest_pos = [0, 0]
def update_pos():
tpos = turt.pos()
pos = [tpos[0] - START_POS[0], tpos[1] - START_POS[1]]
if abs(pos[0]) > abs(farthest_pos[0]):
def build_window(self):
"""Build a window."""
canvas = ScrolledCanvas(self, 600, 600, 600, 600)
canvas.pack(side=tkinter.LEFT)
t = RawTurtle(canvas)
screen = t.getscreen()
screen.tracer(100000)
screen.setworldcoordinates(SCREENMIN, SCREENMIN, SCREENMAX, SCREENMAX)
screen.bgcolor("white")
t.hideturtle()
frame = tkinter.Frame(self)
frame.pack(side=tkinter.RIGHT, fill=tkinter.BOTH)
board = Board(None, screen)
def draw_grid():
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()
draw_grid()
def new_game():
# draw_grid()
self.turn = HUMAN
board.reset()
self.locked = False
screen.update()
def start_handler():
new_game()
btn_start = tkinter.Button(frame, text="New Game", command=start_handler)
btn_start.pack()
tkvar = tkinter.StringVar(self)
tkvar.set(self.level)
def level_handler(*args):
self.level = tkvar.get()
lbl_level = tkinter.Label(frame, text="AI Level")
lbl_level.pack()
dd_level = tkinter.OptionMenu(frame, tkvar, command=level_handler, *AI_LEVELS)
dd_level.pack()
def quit_handler():
self.master.quit()
btn_quit = tkinter.Button(frame, text="Quit", command=quit_handler)
btn_quit.pack()
def computer_turn():
"""
The locked variable prevents another event from being
processed while the computer is making up its mind.
"""
self.locked = True
max_move = None
# Call Minimax to find the best move to make.
# After writing this code, the maxMove tuple should
# contain the best move for the computer. For instance,
# if the best move is in the first row and third column
# then max_move would be (0,2).
depth = AI_LEVELS[self.level]
best_move = -float("inf")
for i, j in board.available():
temp = board.clone()
temp.items[i][j] = X(None)
value = minimax(HUMAN, temp, depth)
if value > best_move:
best_move = value
row, col = i, j
max_move = (row, col)
row, col = max_move
board[row][col] = X(canvas)
self.locked = False
def mouse_click(x, y):
"""Defines what happens on a mouse click."""
if not self.locked:
row = int(y // 100)
col = int(x // 100)
if board[row][col].eval() == 0:
board[row][col] = O(canvas)
self.turn = COMPUTER
board.draw_xos()
if not board.is_full() and not abs(board.eval()) == 1:
computer_turn()
self.turn = HUMAN
board.draw_xos()
else:
self.locked = True
if board.eval() == 1:
tkinter.messagebox.showwarning("Game Over", "Expectedly, Machine wins.")
elif board.eval() == -1:
tkinter.messagebox.showerror("Game Over", "Suprisingly, Human wins.")
elif board.is_full():
tkinter.messagebox.showinfo("Game Over", "It was a tie.")
screen.onclick(mouse_click)
screen.listen()
