Add files via upload

Alphaproj.py

@@ -1,8 +1,10 @@
 import time
-from construct import createRoad, createTurtles, randomTurtles, createRanking
+from construct import createRoad, createTurtles, randomTurtles,createRanking
 
-Length = createRoad.create()
-t = createTurtles.create()
-time.sleep(1)
-randomTurtles.makeItMove(t, Length)
-createRanking.create(t)
+def createtheWorld(length):
+	createRoad.create(length + 1)
+	t = createTurtles.create()
+	time.sleep(1)
+	time_r = randomTurtles.makeItMove(t, length)
+	createRanking.create(time_r,t)
+

construct/createRanking.py

@@ -1,57 +1,59 @@
 from turtle import *
 
-def create(tur):
-    #Clear drawer's line and pen-it-up
-    clear()
-    pu()
-    #Clear turtles' lines
-    for i in range(4):
-        tur[2*i].clear()
-    #Penup turtles
-    for i in range(4):
-        tur[2*i].pu()
-    #Hide turtles
-    for i in range(4):
-        tur[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[2*i].goto(x, 50)
-        tur[2*i].left(90)
-        x += 120
-        tur[2*i].st()
-    x = -160
-    for i in range(4):
-        goto(x, 100)
-        x += 120
-        write(tur[2*i+1])
-
+
+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"))
+	#Medals
+

construct/createRoad.py

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

construct/createTurtles.py

@@ -1,17 +1,19 @@
 from turtle import *
 from random import randint
 
-#Generate each turtle colors
+
+#Generate colours of turtles
 def gencolor():
     r = lambda: randint(0, 255)
     return ('#%02X%02X%02X' % (r(), r(), r()))
 
-#Create turtles (Absolutely) :v
+
+#Create turtles absolutely
 def create():
     x, y, spin = -150, 100, 0    #Set the default coordinates
     tur = []
 
-    for n in (gencolor(),gencolor(),gencolor(),gencolor()):
+    for n in (gencolor(),gencolor(),gencolor(),gencolor()):   #Create the turtles
     #Customize the turtles
         t = Turtle()
         t.color(n)

construct/randomTurtles.py

@@ -1,82 +1,107 @@
 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 encode the events of turtles and the turtles theirself
-##2 first bits encode which turtles
-##3 bits after encode the events
+# 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
 
 
-#Maketime Function
+# 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()
-    min_s = 1
-    max_s = 3
-    currentDT = perf_counter()
-    time_r = [0,0,0,0]
+    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 = step/4
+    revStep = step/4
+    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/2),randint(-140,endPos/2),randint(-140,endPos/2),randint(-140,endPos/2)]
+    pos3 = [randint(endPos/2,endPos),randint(endPos/2,endPos),randint(endPos/2,endPos),randint(endPos/2,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 and(pos2[event[i*2]] - maxSpeed < turRoadLengh[event[i*2]] < pos2[event[i*2]]))or((event[i*2+1]==3)and(pos3[event[i*2]] - maxSpeed < turRoadLengh[event[i*2]] < pos3[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)
+                    if (pos2[j] - maxSpeed<turRoadLengh[j]<pos2[j]):
+                        pos2[j] = pos2[j] - maxSpeed*revStep
+                    if (pos3[j] - maxSpeed<turRoadLengh[j]<pos3[j]):
+                        pos3[j] = pos3[j] - maxSpeed*revStep
             else:
-                valTurtle[j].goto(endPos, tur_set[j])
+                valTurtle[j].goto (endPos, SetTurPosition[j])
                 if (flag[j] == 1):
-                    time_r[j] = perf_counter()
+                    RankTimeTable[j * 2 + 1] = perf_counter ()
                     flag[j] = flag[j] - 1
-    valTurtle[0].write(time_r[0] - currentDT)
-    valTurtle[1].write(time_r[1] - currentDT)
-    valTurtle[2].write(time_r[2] - currentDT)
-    valTurtle[3].write(time_r[3] - currentDT)
+
+    for j in range (4):
+        RankTimeTable[2 * j + 1] = RankTimeTable[2 * j + 1] - StartTime
+    makeTrueTime_r (RankTimeTable)
+    return RankTimeTable