Add files via upload

Alphaproj.py

@@ -1,8 +1,9 @@
 import time
-from construct import createRoad, createTurtles, randomTurtles
-
+from construct import createRoad, createTurtles, randomTurtles,createRanking
 
 length = createRoad.create()
 t = createTurtles.create()
 time.sleep(1)
-randomTurtles.maktIMove(t, length)
+time_r = randomTurtles.makeItMove(t, length)
+createRanking.create(time_r,t)
+input()

construct/createRanking.py

@@ -0,0 +1,57 @@
+from turtle import *
+
+
+def create(timeindex, tur):
+    # Clear drawer's line and pen-it-up
+    clear ()
+    pu ()
+    # Clear turtles' lines
+    for i in range (4):
+        tur[timeindex[2 * i]].clear ()
+    # Penup turtles
+    for i in range (4):
+        tur[timeindex[2 * i]].pu ()
+    # Hide turtles
+    for i in range (4):
+        tur[timeindex[2 * i]].ht ()
+    # Draw the ranking
+    ht ()
+    y = 100
+    setpos (-220, y)
+    pd ()
+    for i in range (3):
+        forward (480)
+        pu ()
+        y -= 100
+        goto (-220, y)
+        pd ()
+    pu ()
+    x = -220
+    setpos (x, 100)
+    pd ()
+    right (90)
+    forward (200)
+    for i in range (4):
+        pu ()
+        x += 120
+        goto (x, 100)
+        pd ()
+        forward (200)
+    # Write something :v
+    pu ()
+    goto (-280, 40)
+    write ("Turtle", move=False, align="center", font=("Arial", 15, "normal"))
+    goto (-280, -60)
+    write ("Time", move=False, align="center", font=("Arial", 15, "normal"))
+    # Turtle's rank
+    x = -160
+    for i in range (4):
+        tur[timeindex[2 * i]].goto (x, 50)
+        tur[timeindex[2 * i]].left (90)
+        x += 120
+        tur[timeindex[2 * i]].st ()
+    x = -165
+    for i in range (4):
+        goto (x, -55)
+        x += 120
+        write (("%0.2f" % timeindex[2 * i + 1]), move=False, align="center", font=("Arial", 10, "bold"))

construct/createRoad.py

@@ -1,16 +1,21 @@
-
 from turtle import *
 from construct.createTurtles import gencolor
+
+
+#Create road's length buttons
 def makeshort(n):
     n = int(10)
 def makelong(n):
     n = int(20)
 def makemedium(n):
     n = int(15)
+
+
+#Create road of course
 def create():
     speed(0)
-    penup()     #set the default position
-    goto(-140,140)
+    penup()
+    goto(-140,140)  #Set the default position
     n = 0
     bgcolor("white")
     # onkey(makeshort(n),"U")
@@ -22,17 +27,18 @@ def create():
 
     n = int(textinput("Noti from Pornhub ", "Please enter the length of the road:  "))
     n = n + 1
-    for step in range(n):   #draw lines of the road
+    #Draw lines of the road
+    for step in range(n):
         write(step, align = 'center')
         right(90)
-        forward(10)
-        for step in range (15): #draw dashed lines
+        #Draw dashed lines
+        for step in range (15):
             forward(10)
             if (step % 2 == 0): penup()
             else: pendown()
-
-        penup() #return and start drawing the next line
-        backward(160)
+        #Start drawing the next line
+        penup()
+        backward(150)
         left(90)
         forward(20)
     return n

construct/createTurtles.py

@@ -1,22 +1,31 @@
 from turtle import *
 from random import randint
+
+
+#Generate colours of turtles
+def gencolor():
+    r = lambda: randint(0, 255)
+    return ('#%02X%02X%02X' % (r(), r(), r()))
+
+
+#Create turtles absolutely
 def create():
-    x, y, spin = -150, 100, 0    #set the default coordinates
+    x, y, spin = -150, 100, 0    #Set the default coordinates
     tur = []
 
-    for n in (gencolor(),gencolor(),gencolor(),gencolor()):   #create the turtles
-    #customize the turtles
+    for n in (gencolor(),gencolor(),gencolor(),gencolor()):   #Create the turtles
+    #Customize the turtles
         t = Turtle()
         t.color(n)
         t.shape('turtle')
 
-    #move turtles to the start point
+    #Move turtles to the start point
         t.penup()
         t.goto(x,y)
         t.pendown()
         y -= 30
 
-    #spin each turtle
+    #Spin each turtle
         spin += 1
         if (spin % 2 == 0):
             t.right(360)
@@ -25,8 +34,4 @@ def create():
 
         tur.append(t)
 
-    return tur  #return the list of turtles
-def gencolor():
-    r = lambda: randint(0, 255)
-    return ('#%02X%02X%02X' % (r(), r(), r()))
-
+    return tur  #Return the list of turtles

construct/randomTurtles.py

@@ -1,74 +1,103 @@
 from turtle import *
-from random import randint
+from random import randint, shuffle
 from random import random
-import datetime
 from construct.createTurtles import gencolor
+from time import perf_counter
 
 
+# Apply de Bruijn sequence to create events of turtles
 def eventRand():
     Bruijn = [0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1]
-    i = randint(0, 26)
+    i = randint (0, 26)
     X = []
-    for o in range(8):
+    for o in range (8):
         Bitarr1 = [Bruijn[i], Bruijn[i + 1], Bruijn[i + 2], Bruijn[i + 3], Bruijn[i + 4]]
         S = Bitarr1[0] * 2 + Bitarr1[1]
         T = Bitarr1[2] * 4 + Bitarr1[3] * 2 + Bitarr1[4] * 1
         i = i - 1
-        X.append(S)
-        X.append(T)
+        X.append (S)
+        X.append (T)
     return X
 
-def makeTutlePos(Tur,n):
+
+#
+def makeTutlePos(Tur, n):
     X = []
-    for i in range(n):
+    for i in range (n):
         temp = Tur[i].position ()
-        temp = list(temp)
-        X.append(temp[0])
+        temp = list (temp)
+        X.append (temp[0])
     return X
 
 
-def maktIMove(valTurtle, step):
-    event = eventRand()
-    min_s = 1
-    max_s = 3
-    currentDT = datetime.datetime.now()
-    time_r = [datetime.datetime.now(), datetime.datetime.now(), datetime.datetime.now(), datetime.datetime.now()]
+# Sort list of turtle's index and time records
+def makeTrueTime_r(time_r):
+    index = []
+    time = []
+    for j in range (4):
+        time.append (time_r[2 * j + 1])
+    time.sort (reverse=True)
+    for i in range (4):
+        for j in range (i, 4):
+            if (time[i] == time_r[2 * j + 1]):
+                # Swap index
+                temp = time_r[2 * j]
+                time_r[2 * j] = time_r[2 * i]
+                time_r[2 * i] = temp
+                # Swap time
+                temp = time_r[2 * j + 1]
+                time_r[2 * j + 1] = time_r[2 * i + 1]
+                time_r[2 * i + 1] = temp
+
+
+# Making random events
+def makeItMove(valTurtle, step):
+    event = eventRand ()
+    minSpeed = 1
+    maxSpeed = 3
+    StartTime = perf_counter ()
+    RankTimeTable = [0, 0, 1, 0, 2, 0, 3, 0]
     road_l = step * 20
     flag = [1, 1, 1, 1]
-    tur_set = [100, 70, 40, 10]
-    num_e = randint(0, road_l)
-    num_f = randint(num_e, road_l)
-    endPos = -150 + 20 * step
-    i = randint(0,num_e)
-    while(flag[0] == 1 or flag[1] == 1 or flag[2] == 1 or flag[3] == 1):
-        speed = [randint(min_s, max_s), randint(min_s, max_s), randint(min_s, max_s), randint(min_s, max_s)]
-        turRoadLengh = makeTutlePos(valTurtle,4)
-        i = i + 1
-        for j in range(4):
-            if (endPos - turRoadLengh[j] >= max_s):
-                if (((0 == event[2 * j + 1] or event[2 * j + 1] == 1) and (i == num_f)) or ((0 == event[4 * j + 1] or event[4 * j + 1] == 1) and (i == num_e))):
-                    if (1 == event[4 * j + 1] or event[4 * j + 1] == 2):
-                        e_index = event[4*j]
-                    else:
-                        e_index = event[2*j]
-                    valTurtle[e_index].right(180)
-                    valTurtle[e_index].forward(speed[e_index]*4)
-                    valTurtle[e_index].right(180)
-                if ((2 == event[2 * j + 1] or event[2 * j + 1] == 3) or (2 == event[4 * j + 1] or event[4 * j + 1] == 3)) and (num_e < i and i < num_f):
-                    if (3 == event[4 * j + 1] or event[4 * j + 1] == 4):
-                        e_index = event[4*j]
-                    else:
-                        e_index = event[2*j]
-                    speed[e_index] = 0
-                    valTurtle[e_index].color(gencolor())
+    SetTurPosition = [100, 70, 40, 10]
+    stunIndex = [0,0,0,0]
+    stunStep = 6
+    revStep = 6
+    endPos = -150 + road_l
+    pos0 = [randint(-140,endPos),randint(-140,endPos),randint(-140,endPos),randint(-140,endPos)]
+    pos1 = [randint(-140,endPos),randint(-140,endPos),randint(-140,endPos),randint(-140,endPos)]
+    pos2 = [randint(-140,endPos),randint(-140,endPos),randint(-140,endPos),randint(-140,endPos)]
+    while (flag[0] == 1 or flag[1] == 1 or flag[2] == 1 or flag[3] == 1):
+        speed = [randint (minSpeed, maxSpeed), randint (minSpeed, maxSpeed), randint (minSpeed, maxSpeed), randint (minSpeed, maxSpeed)]
+        turRoadLengh = makeTutlePos (valTurtle, 4)
+        TurtleEventFlag = [1, 1, 1, 1]
+        for i in range(8): #Check event
+            #If event is stun
+            if((event[i*2+1]==0  and (pos0[event[2*i]]-maxSpeed)< turRoadLengh[event[i*2]] < pos0[event[2*i]])or (event[2*i+1]==1 and (pos1[event[2*i]]-maxSpeed)<turRoadLengh[event[i*2]]<pos1[event[2*i]])):
+                TurtleEventFlag[event[i*2]] = 0
+                valTurtle[event[2*i]].color(gencolor())
+                stunIndex[event[i*2]] = stunIndex[event[i*2]] + 1
+                if (stunIndex[event[i*2]] % stunStep == 0):
+                    TurtleEventFlag[event[i * 2]] = 1
+            #If event is backward
+            if((event[i*2+1]==2 or event[i*2+1]==3)and(pos2[event[i*2]] - maxSpeed< turRoadLengh[event[i*2]] < pos2[event[i*2]])):
+                TurtleEventFlag[event[i*2]] = -1
+###Make a real move and do event act
+        for j in range (4):
+            if (endPos - turRoadLengh[j] >= maxSpeed):
+                if (TurtleEventFlag[j]==1):
+                    valTurtle[j].forward (speed[j])
 
-                valTurtle[j].forward(speed[j])
+                if (TurtleEventFlag[j] == -1):
+                    valTurtle[j].left (180)
+                    pos2[j] = pos2[j] - speed[j]*revStep
             else:
-                valTurtle[j].goto(endPos, tur_set[j])
+                valTurtle[j].goto (endPos, SetTurPosition[j])
                 if (flag[j] == 1):
-                    time_r[j] = datetime.datetime.now()
+                    RankTimeTable[j * 2 + 1] = perf_counter ()
                     flag[j] = flag[j] - 1
-    valTurtle[0].write(currentDT.microsecond - time_r[0].microsecond)
-    valTurtle[1].write(currentDT.microsecond - time_r[1].microsecond)
-    valTurtle[2].write(currentDT.microsecond - time_r[2].microsecond)
-    valTurtle[3].write(currentDT.microsecond - time_r[3].microsecond)
+
+    for j in range (4):
+        RankTimeTable[2 * j + 1] = RankTimeTable[2 * j + 1] - StartTime
+    makeTrueTime_r (RankTimeTable)
+    return RankTimeTable