Add files via upload

Author: TheRainbowPhoenix

turtle.py

@@ -0,0 +1,389 @@
+# import casioplot
+from math import sqrt, pi, cos, sin, atan2
+import gint
+
+turtleshapes={"classic":[[-9,5],[-9,4],[-8,4],[-8,3],[-8,2],[-8,-2],[-8,-3],[-8,-4],[-9,-4],[-9,-5],[-7,4],[-7,1],[-7,0],[-7,-1],[-7,-4],[-6,3],[-6,-3],[-5,3],[-5,-3],[-4,2],[-4,-2],[-3,2],[-3,-2],[-2,1],[-2,-1],[-1,1],[-1,-1],[0,0]],"turtle": [[-3,3],[2,3],[-2,2],[-1,2],[0,2],[1,2],[-2,1],[-1,1],[1,1],[0,1],[2,1],[3,1],[-2,0],[-1,0],[0,0],[1,0],[-1,-1],[-2,-1],[0,-1],[1,-1],[2,0],[3,0],[-3,-2],[2,-2]]}
+turtle_name="classic"
+turtle_data=turtleshapes[turtle_name]
+turtle_pos=[0,0]
+turtle_angle=0
+turtle_color=(0,0,0)
+writing=True
+pen_pixels=[[0,0]]
+turtle_buffer=[]
+turtle_speed=5
+frame_count=0
+turtle_visible=True
+pen_size=1
+
+def _draw_turtle(x,y,a,c):
+	global turtle_buffer
+	def inbuffer(x,y):
+		inlist=False
+		for i in range(len(turtle_buffer)):
+			if x==turtle_buffer[i][0] and y==turtle_buffer[i][1]:
+				inlist=True
+		return inlist
+	if turtle_visible==True:
+		u=cos(a*pi/180)
+		v=sin(a*pi/180)
+		for point in turtle_data:
+			xx=x+(point[0]*u-point[1]*v)
+			yy=y+(point[1]*u+point[0]*v)
+			xpixel=int(round(xx+192))
+			ypixel=int(round(-yy+96))
+			if (0<=xpixel<=383 and 0<=ypixel<=191):
+				old_color = gint.dgetpixel(xpixel, ypixel)
+				turtle_buffer += [[xpixel, ypixel, old_color]]
+				gint.dpixel(xpixel, ypixel, c)
+
+				# if not inbuffer(xpixel,ypixel):
+				#   turtle_buffer+=[[xpixel,ypixel,casioplot.get_pixel(xpixel,ypixel)]]
+				# casioplot.set_pixel(xpixel,ypixel,c)
+
+def _erase_turtle():
+	global turtle_buffer
+	for i in range(len(turtle_buffer)):
+		xpixel=turtle_buffer[i][0]
+		ypixel=turtle_buffer[i][1]
+		if turtle_buffer[i][2]!=None :
+			lastcolor = turtle_buffer[i][2]
+			# lastcolor = gint.C_RGB(int(turtle_color[0]*31), int(turtle_color[1]*31), int(turtle_color[2]*31))
+		else:
+			lastcolor= gint.C_WHITE # (255,255,255)
+		gint.dpixel(xpixel, ypixel, lastcolor)
+		# casioplot.set_pixel(xpixel,ypixel,lastcolor)
+	turtle_buffer.clear()
+
+def _pen_brush(x,y,turtle_color):
+	global frame_count
+	_erase_turtle()
+	xpixel=int(round(x+192))
+	ypixel=int(round(-y+96))
+	if writing==True and (0<=xpixel<=383 and 0<=ypixel<=191) :
+		colorpixel = gint.C_RGB(int(turtle_color[0]*31), int(turtle_color[1]*31), int(turtle_color[2]*31))
+		# colorpixel=(int(turtle_color[0]*255), int(turtle_color[1]*255),int(turtle_color[2]*255))
+
+		for point in pen_pixels:
+			gint.dpixel(xpixel + point[0], ypixel + point[1], colorpixel)
+		#   casioplot.set_pixel(xpixel+point[0],ypixel+point[1],colorpixel)
+
+		frame_count+=1
+		if turtle_speed!=0:
+			if frame_count%(turtle_speed*4)==0:
+				_draw_turtle(x,y,turtle_angle,colorpixel)
+				gint.dupdate()
+				# casioplot.show_screen()
+		else :
+			if frame_count%500==0:
+				_draw_turtle(x,y,turtle_angle,colorpixel)
+				gint.dupdate()
+				# casioplot.show_screen()
+
+def _refresh_turtle():
+	c = gint.C_RGB(int(turtle_color[0]*31), int(turtle_color[1]*31), int(turtle_color[2]*31))
+	# c=(int(turtle_color[0]*255), int(turtle_color[1]*255),int(turtle_color[2]*255))
+	_erase_turtle()
+	_draw_turtle(turtle_pos[0],turtle_pos[1],turtle_angle,c)
+#   casioplot.show_screen()
+	gint.dupdate()
+
+def _conv_angle(a):
+	a=a%360
+	if a < 0:
+		a=360+a
+	return a
+
+def back(n):
+	forward(-n)
+
+def backward(n):
+	back(n)
+
+def bk(n):
+	backward(n)
+
+def circle(radius,extent=360):
+	global  turtle_angle, turtle_pos
+	x1=turtle_pos[0]
+	y1=turtle_pos[1]
+	if round(radius)==0:
+		_pen_brush(x1,y1,turtle_color)
+		turtle_angle+=extent
+	elif round(extent,8)==0:
+		_pen_brush(x1,y1,turtle_color)
+	else:
+		e=radius/abs(radius)
+		theta=extent*pi/180*e
+		Rx=cos(theta)
+		Ry=sin(theta)
+		Dx=radius*sin(turtle_angle*pi/180)
+		Dy=-radius*cos(turtle_angle*pi/180)
+		xcenter=x1-Dx
+		ycenter=y1-Dy
+		nbpixelarc=int(round(abs(radius*theta*1.05)))
+		angle=turtle_angle
+		if nbpixelarc!=0:
+			alpha=theta/nbpixelarc
+			for k in range(nbpixelarc+1):
+				x=xcenter+Dx*cos(alpha*k)-Dy*sin(alpha*k)
+				y=ycenter+Dx*sin(alpha*k)+Dy*cos(alpha*k)
+				turtle_angle+=alpha*180/pi
+				_pen_brush(x,y,turtle_color)
+		turtle_pos[0]=xcenter+Dx*Rx-Dy*Ry
+		turtle_pos[1]=ycenter+Dx*Ry+Dy*Rx
+		turtle_angle=angle+extent*e
+	turtle_angle=_conv_angle(turtle_angle)
+	_refresh_turtle()
+
+def clear():
+		_erase_turtle()
+		gint.dclear(gint.C_WHITE)
+		#   casioplot.clear_screen()
+		gint.dupdate()
+		#   casioplot.show_screen()
+		_refresh_turtle()
+
+def distance(x,y):
+	return sqrt((x-turtle_pos[0])**2+(y-turtle_pos[1])**2)
+
+def down():
+	global writing
+	writing=True
+
+def fd(d):
+	forward(d)
+
+def forward(d):
+	global turtle_pos
+	dx=d*cos(turtle_angle*pi/180)
+	dy=d*sin(turtle_angle*pi/180)
+	x1=turtle_pos[0]
+	y1=turtle_pos[1]
+	if round(abs(d))==0:
+		_pen_brush(x1+dx,y1+dy,turtle_color)
+	elif abs(dx)>=abs(dy):
+		e=int(dx/abs(dx))
+		m=dy/dx
+		p=y1-m*x1
+		for x in range(int(round(x1)),int(round(x1+dx)),e):
+			_pen_brush(x,m*x+p,turtle_color)
+	else:
+		e=int(dy/abs(dy))
+		m=dx/dy
+		p=x1-m*y1
+		for y in range(int(round(y1)),int(round(y1+dy)),e):
+			_pen_brush(m*y+p,y,turtle_color)
+	turtle_pos[0]+=dx
+	turtle_pos[1]+=dy
+	_refresh_turtle()
+
+def goto(x,y):
+	a=turtle_angle
+	setheading(towards(x,y))
+	forward(distance(x,y))
+	setheading(a)
+	_refresh_turtle()
+
+def heading():
+	return turtle_angle
+
+def hideturtle():
+	global turtle_visible
+	turtle_visible=False
+	_refresh_turtle()
+
+def home():
+	global turtle_angle
+	goto(0,0)
+	turtle_angle=0
+	_refresh_turtle()
+
+def ht():
+	hideturtle()
+
+def isdown():
+	return writing
+
+def isvisible():
+	return turtle_visible
+
+def left(a):
+	right(-a)
+
+def lt(a):
+	left(a)
+
+def pd():
+	down()
+
+def pencolor(*c):
+	global turtle_color
+	colornames={"black":(0,0,0),"blue":(0,0,1),"green":(0,1,0),"red":(1,0,0),"cyan":(0,1,1),"yellow":(1,1,0),"magenta":(1,0,1),"white":(1,1,1),"orange":(1,0.65,0),"purple":(0.66,0,0.66),"brown":(0.75,0.25,0.25),"pink":(1,0.75,0.8),"grey":(0.66,0.66,0.66)}
+	if c==():
+		return turtle_color
+	elif c[0] in colornames:
+		turtle_color=colornames[c[0]]
+	elif isinstance(c[0],(list,tuple)) and len(c[0])==3 and isinstance(c[0][0],(int,float)) and isinstance(c[0][1],(int,float)) and isinstance(c[0][2],(int,float)) and 0<=c[0][0]<=1 and 0<=c[0][1]<=1 and 0<=c[0][2]<=1:
+		turtle_color=list(c[0])
+
+	elif len(c)==3 and isinstance(c[0],(int,float)) and isinstance(c[1],(int,float)) and isinstance(c[2],(int,float)) and 0<=c[0]<=1 and 0<=c[1]<=1 and 0<=c[2]<=1:
+		turtle_color=list(c)
+
+	else:
+		raise ValueError('error using pencolor : enter a color text or 3 floats between 0 and 1')
+	_refresh_turtle()
+
+def pendown():
+	down()
+
+def pensize(n=None):
+	global pen_pixels,pen_size
+	penshape=[[0,0],[1,0],[0,1],[-1,0],[0,-1],[1,1],[1,-1],[-1,1],[-1,-1],[2,0],[0,2],[-2,0],[0,-2],[2,1],[1,2],[-2,1],[-1,2],[2,-1],[1,-2],[-2,-1],[-1,-2]]
+	if n==None:
+		return pen_size
+	elif isinstance(n,(int,float)) and n>=0:
+		pen_size=n
+		if round(n)==0 or round(n)==1 :
+			pen_pixels=[[0,0]]
+		elif round(n)==2 :
+			pen_pixels=penshape[0:5]
+		elif round(n)==3 :
+			pen_pixels=penshape[0:9]
+		elif round(n)==4 :
+			pen_pixels=penshape[0:13]
+		elif round(n)==5 :
+			pen_pixels=penshape[0:21]
+		elif round(n)>5 :
+			pen_pixels=penshape[0:21]
+			pen_size=5
+			print('Userwarning: pensize over 5 automatically set to 5.')
+	else:
+		raise ValueError('Error using function pensize: enter a real between 0 & 5')
+	_refresh_turtle()
+
+def penup():
+	global writing
+	writing=False
+
+def pos():
+	return position()
+
+def position():
+	return (xcor(),ycor())
+
+def pu():
+	penup()
+
+def reset():
+	global turtle_color,writing,pen_pixels,turtle_speed,turtle_visible,pen_size
+	turtle_color=(0,0,0)
+	clear()
+	hideturtle()
+	penup()
+	home()
+	pendown()
+	writing=True
+	pen_size=1
+	pen_pixels=[[0,0]]
+	turtle_speed=5
+	shape("classic")
+	turtle_visible=True
+	_refresh_turtle()
+
+def right(a):
+	global turtle_angle
+	if isinstance(a, (int, float)):
+		turtle_angle = _conv_angle(turtle_angle-a)
+	else:
+		raise ValueError('error')
+	_refresh_turtle()
+
+def rt(a):
+	right(a)
+
+def seth(a):
+	setheading(a)
+
+def setheading(a):
+	global turtle_angle
+	turtle_angle=_conv_angle(a)
+	_refresh_turtle()
+
+def setpos(x,y):
+	goto(x,y)
+
+def setposition(x,y):
+	setpos(x,y)
+
+def setx(x):
+	goto(x,turtle_pos[1])
+
+def sety(y):
+	goto(turtle_pos[0],y)
+
+def shape(name=None):
+	global turtle_name,turtle_data
+	if name==None:
+		return turtle_name
+	elif name in turtleshapes:
+		turtle_name=name
+		turtle_data=turtleshapes[name]
+	else:
+		raise ValueError('available shapes: "classic" or "turtle"')
+	_refresh_turtle()
+
+def showturtle():
+	global turtle_visible
+	turtle_visible=True
+	_refresh_turtle()
+
+def speed(speed=None):
+	global turtle_speed
+	speedwords = {'fastest':0, 'fast':10, 'normal':6, 'slow':3, 'slowest':1 }
+	if speed==None:
+		return turtle_speed
+	elif isinstance(speed,(int,float)) and (speed<=0.5 or speed>=10.5):
+		turtle_speed=0
+	elif isinstance(speed,(int,float)) and (0.5<speed<10.5):
+		turtle_speed=int(round(speed))
+	elif isinstance(speed,str) and speed in speedwords:
+		turtle_speed=speedwords[speed]
+	else:
+		raise ValueError("Error using function speed: enter a real between 0 & 10")
+
+def st():
+	showturtle()
+
+def towards(x,y):
+	if round(x-turtle_pos[0],8)==0 and round(y-turtle_pos[1],8)==0:
+		return 0
+	else:
+		ang=atan2(y-turtle_pos[1],x-turtle_pos[0])*180/pi
+		if ang>=0:
+				return (ang)
+		else:
+				return (360+ang)
+
+def up():
+	penup()
+
+def width(n=None):
+	return pensize(n)
+
+def write(text):
+	_refresh_turtle()
+	xpixel=int(round(turtle_pos[0]+192))
+	ypixel=int(round(-turtle_pos[1]+96))
+	# c=(int(turtle_color[0]*255), int(turtle_color[1]*255),int(turtle_color[2]*255))
+	c = gint.C_RGB(int(turtle_color[0]*31), int(turtle_color[1]*31), int(turtle_color[2]*31))
+	gint.dtext(xpixel, ypixel, c, str(text))
+	# casioplot.draw_string(xpixel,ypixel,str(text),c,"small")
+	gint.dupdate()
+    # casioplot.show_screen()
+
+def xcor():
+	return round(turtle_pos[0],6)
+def ycor():
+	return round(turtle_pos[1],6)
+ # type: ignore