From e67f4ad19cfe8428bd3c64b006c55aeb18a0569f Mon Sep 17 00:00:00 2001
From: tgaeta <nobody@makingwithcode.org>
Date: Wed, 17 Sep 2025 14:22:50 -0400
Subject: [PATCH] Used Bezier curves to make fancy typeset.

This assignment was fun to do. The implementation was way easier than I
thought it would be. I know I'm supposed to make multiple commits, but I
really only have 1 implementation. I got the constants by messing around
in Desmos.
---
 .DS_Store   | Bin 0 -> 6148 bytes
 typeface.py |  64 ++++++++++++++++++++++++++++++++++++++++++++++------
 2 files changed, 57 insertions(+), 7 deletions(-)
 create mode 100644 .DS_Store

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..ab18bdb1b05edde16b34dc2dce93bb42b10b2c6c
GIT binary patch
literal 6148
zcmeHKJ5Iwu5S=wHjMAi_pg_VWKtwb&AQPDrq(uS}qXa3&E})?EHBxXD3MjY)m!P2M
z&CV!zWlV`sG!xCf^?cU5&z2`cL~i_0jEIIrlt3AyZ45sM`&l~@sfC@6*I3R+lUY^P
zok%nMR|fdm#dJV(x~2Q@`8~b1ePxyB(`7Y<E!p2WI$fQ-orV75SAV@|y&F-6R2tAF
zel<PPjIN;zx?xMWi@neO$o8H-o?q^CPd)3F)%Olp?-#|foS-K<*e@OOeoc%4W55{L
z6b4YUS(1UEjmCg6U<|Ao;O|2UWy};CLI3H%;9CG-46_%^xtHLaR54R*1mS@=Nd-!(
z(-y-?I_#;&Wr~fUq?6O;!|9!!b|}u@9qXq)oLnYoqcLC%gbZxS<&f+Dd4K;OCfSuS
zU<_;&11`=d`4~si+S)lB*V+_%1!dv5MsS^ii7&;7<x;#0^#Xg!6JVy;2*LufKLVZx
K8;pTJW#9`MuT8Z8

literal 0
HcmV?d00001

diff --git a/typeface.py b/typeface.py
index b966bef..e1f6d92 100644
--- a/typeface.py
+++ b/typeface.py
@@ -1,5 +1,5 @@
 # typeface.py
-# By Chris Proctor and _________
+# By Chris Proctor and Tristan Gaeta
 
 # Contains one function for each letter in the English alphabet. 
 # Each function should draw its letter at a scale of `unit`, and then 
@@ -9,8 +9,42 @@
 # move the turtle along the diagonal of a square with side length x, 
 # the turtle should move a distance of sqrt(x)
 
-from turtle import *
-from math import sqrt
+from turtle import (pos, teleport, goto)
+
+class Point(tuple):
+    "Class for doing element-wise arithmetic on tuples"
+    def __add__(self, other):
+        return Point((x + y for x, y in zip(self, other)))
+    
+    def __sub__(self, other):
+        return Point((x - y for x, y in zip(self, other)))
+    
+    def __rmul__(self, other):
+        return Point((other * x for x in self))
+    
+    def __truediv__(self, other):
+        return Point((x / other for x in self))
+    
+def bezier(t, *points: tuple[float, ...]) -> Point:
+    "Recursive definition of a Bezier curve"
+    assert(len(points) > 0)
+    if len(points) == 1:
+        return Point(points[0])
+    return (1-t) * bezier(t, *points[0:-1]) + t * bezier(t, *points[1:])
+
+def draw_bezier(unit, segments, *points: tuple[float, ...]):
+    "Draws bezier and returns turtle to initial position"
+    segments = int(unit * (segments / 40)) 
+    origin = pos()
+    points = tuple(origin + unit * Point(x) for x in points)
+    
+    teleport(*points[0])
+    for i in range(0, segments + 1):
+        bz = bezier(i / segments, *points)
+        goto(bz)
+        
+    teleport(*origin)
+    
 
 def draw_letter_a(unit):
     pass
@@ -19,7 +53,11 @@ def draw_letter_b(unit):
     pass
 
 def draw_letter_c(unit):
-    pass
+    draw_bezier(unit, 160,
+                (7, 7),
+                (0.5, 11.88),
+                (0.5, -3.88),
+                (7, 1))
 
 def draw_letter_d(unit):
     pass
@@ -46,7 +84,11 @@ def draw_letter_k(unit):
     pass
 
 def draw_letter_l(unit):
-    pass
+    draw_bezier(unit, 100, 
+                (1.46, 8), 
+                (5.27, -6.66), 
+                (-5.94, 4.27), 
+                (7, 0))
 
 def draw_letter_m(unit):
     pass
@@ -73,10 +115,18 @@ def draw_letter_t(unit):
     pass
 
 def draw_letter_u(unit):
-    pass
+    draw_bezier(unit, 100,
+                (0.5, 8),
+                (0, -2.5),
+                (8, -2.5),
+                (7, 8))
 
 def draw_letter_v(unit):
-    pass
+    draw_bezier(unit, 80,
+                (1, 8),
+                (4, -0.33),
+                (3.44, -4.33),
+                (7, 8))
 
 def draw_letter_w(unit):
     pass