#4D4D4D

$\text{NEW LINES}$

Fix position and allow selection for all text objects

Reset app

#006758

#B00020

#252525

#757575

#949494

#E44461

#DA2570

#E66B9E

#3A6ED6

#5991FF

#008475

#0F8538

#00a83c

#5145A8

#6557D2

#8575FF

#903D14

#BD6C43

#C75000

#E07415

#eeeeee

\text{The horizontal roads are parallel. Choose an angle to explore.} 

#2E006758

#2EB00020

$\text{RESET}$

\text{\begin{array}{c}Keep exploring to find\alternate angles\end{array}}

+

=180°

\text{Supplementary Angles}

numRandoms: 12
allRandoms = RandomUniform(0, 0.99, 200)
PointTreeMiddle: (Corner[treePicBase, 1] + Corner[treePicBase, 3]) / 2
intersectP1: {(-2.5, 1), (2.5, 1)}
segP1Range = Segment(intersectP1(1) + (0.9, 0), intersectP1(2) - (0.9, 0))
InputPoint1 = Point(segP1Range)
intersectP2: {(-2.5, -1), (2.5, -1)}
segP2Range = Segment(intersectP2(1) + (0.9, 0), intersectP2(2) - (0.9, 0))
InputPoint2 = Point(segP2Range)
countQuestion = 0
randIndex: (Mod[countQuestion, floor(Length[allRandoms] / numRandoms)] * numRandoms) + 1
currentRandomSeeds = Take(allRandoms, randIndex, randIndex + numRandoms - 1)
y3b: -1.1 - 44 / 90 + (currentRandomSeeds(6) * (-2.5 + 4 / 90 + 4 / 9 + 1.1))
y3a: -1.1 - 44 / 90 + (currentRandomSeeds(5) * (-2.5 + 44 / 90 + 4 / 9 + 1.1))
y1b: 1.1 + 44 / 90 + (currentRandomSeeds(2) * (2.2 - 88 / 90 - 1.1))
y1a: 1.1 + 44 / 90 + (currentRandomSeeds(1) * (2.2 - 88 / 90 - 1.1))
graphArea = Polygon({(-2.5, -2.5), (-2.5, 2.2), (2.5, 2.2), (2.5, -2.5)})
randomList1 = Flatten(Sequence[{-1, 0, 1}, n, 1, 33])
randomNum1 = Element(randomList1, Mod[countQuestion, 100] + 1)
x1: randomNum1
x3min = If(y3b < -1.8 - 44 / 90, (x1 * y3b) + 0.1 + 44 / 90, x(InputPoint2) + 0.8 + 44 / 90)
x3b = If(x3min < 2.5 - 44 / 90, x3min + (currentRandomSeeds(12) * (2.5 - 44 / 90 - x3min)), 3)
x3max = If(y3a < -1.8 - 44 / 90, (x1 * y3a) - 0.1 - 44 / 90, x(InputPoint2) - 1.8 - 44 / 90)
x3a = If(x3max > -2.5 + 44 / 90, -2.5 + 44 / 90 + (currentRandomSeeds(11) * (x3max + 2.5 - 44 / 90)), -3)
x1min = If(y1b > 1.8 + 44 / 90, (x1 * y1b) + 0.1 + 44 / 90, x(InputPoint1) + 0.8 + 44 / 90)
x1b = If(x1min < 2.5 - 44 / 90, x1min + (currentRandomSeeds(8) * (2.5 - 44 / 90 - x1min)), 3)
x1max = If(y1a > 1.8 + 44 / 90, (x1 * y1a) - 0.1 - 44 / 90, x(InputPoint1) - 0.8 - 44 / 90)
x1a = If(x1max > -2.5 + 44 / 90, -2.5 + 44 / 90 + (currentRandomSeeds(7) * (x1max + 2.5 - 44 / 90)), -3)
y2bmax = If(x1 ≟ 1, 1 - 0.8 - 44 / 90, 0.9 - 44 / 90)
y2bmin = If(x1 ≟ -1, -1 + 0.8 + 44 / 90, -0.9 + 44 / 90)
y2b: y2bmin + (currentRandomSeeds(4) * (y2bmax - y2bmin))
x2min = If(y2b > -0.2 + 44 / 90 ∨ x1 ≟ 1, (x1 * y2b) + 0.1 + 44 / 90, x1 ≟ 0, 0.8 + 44 / 90, 1.8 + 44 / 90)
x2b = If(x2min < 2.5 - 44 / 90, x2min + (currentRandomSeeds(10) * (2.5 - 44 / 90 - x2min)), 3)
y2amax = If(x1 ≟ -1, 1 - 0.8 - 44 / 90, 0.9 - 44 / 90)
y2amin = If(x1 ≟ 1, -1 + 0.8 + 44 / 90, -0.9 + 44 / 90)
y2a: y2amin + (currentRandomSeeds(3) * (y2amax - y2amin))
x2max = If(y2a < 0.2 - 44 / 90 ∨ x1 ≟ 1, (x1 * y2a) - 0.1 - 44 / 90, x1 ≟ 0, -0.8 - 44 / 90, -1.8 - 44 / 90)
x2a = If(x2max > -2.5 + 44 / 90, -2.5 + 44 / 90 + (currentRandomSeeds(9) * (x2max - 44 / 90 + 2.5)), -3)
treePoints = KeepIf(IsInRegion[n, graphArea], n, {(x1a, y1a), (x2a, y2a), (x2b, y2b), (x3a, y3a), (x1b, y1b), (x3b, y3b)})
case = If(x1 ≟ -1, 2, x1 ≟ 1, 3, 4)
lineP2: y = -1
lineP1: y = 1
lineT = Line(InputPoint1, InputPoint2)
arcCircle1 = Circle(InputPoint1, 0.8)
ints2 = Element({{(-1.56569, 1.56569), (-0.43431, 0.43431)}, {(1.56569, 1.56569), (0.43431, 0.43431)}, {(0, 1.8), (0, 0.2)}}, case - 1)
ints1 = Element({{(-1.8, 1), (-0.2, 1)}, {(0.2, 1), (1.8, 1)}, {(-0.8, 1), (0.8, 1)}}, case - 1)
arc1 = CircleSector(InputPoint1, ints1(1), ints2(2))
arc2 = CircleSector(InputPoint1, ints2(2), ints1(2))
clickNum = 9
polyCircle1 = Circle(InputPoint1, 0.7)
segmentP1 = Segment(intersectP1(1), intersectP1(2))
lineTopB = Segment(intersectP1(1) - (0, 0.1), intersectP1(2) - (0, 0.1))
lineTopT = Segment(intersectP1(1) + (0, 0.1), intersectP1(2) + (0, 0.1))
polyCircle2 = Circle(InputPoint2, 0.7)
chosenCircle = If(clickNum ≤ 4, polyCircle1, polyCircle2)
arcInputs: {InputPoint1, InputPoint1, InputPoint1, InputPoint1, InputPoint2, InputPoint2, InputPoint2, InputPoint2, (0, 0)}
centerP1: arcInputs(clickNum)
segmentT = Segment(InputPoint1, InputPoint2)
tpAngle = Angle(segmentT, segmentP1)
distT: 0.1 / sin(tpAngle)
distT2: 0.1 / cos(tpAngle)
intersectT = Element({{(-2.2, 2.2), (2.5, -2.5)}, {(2.2, 2.2), (-2.5, -2.5)}, {(0, 2.2), (0, -2.5)}}, case - 1)
PointDistTop = If(y(Element[intersectT, 1]) < 2.2, (0, distT2), (distT, 0))
PointDistBottom = If(y(Element[intersectT, 2]) > -2.5, (0, distT2), (distT, 0))
lineTransB = Segment(intersectT(1) + PointDistTop, intersectT(2) + PointDistBottom)
lineTransT = Segment(intersectT(1) - PointDistTop, intersectT(2) - PointDistBottom)
arcCircle2 = Circle(InputPoint2, 0.8)
ints4 = Element({{(0.43431, -0.43431), (1.56569, -1.56569)}, {(-0.43431, -0.43431), (-1.56569, -1.56569)}, {(0, -0.2), (0, -1.8)}}, case - 1)
ints3 = Element({{(0.2, -1), (1.8, -1)}, {(-1.8, -1), (-0.2, -1)}, {(-0.8, -1), (0.8, -1)}}, case - 1)
arc2Ints: {ints2(2), ints1(2), ints2(1), ints1(1), ints4(2), ints3(2), ints4(1), ints3(1), (1, 0)}
dist1PS' = Vector(centerP1, arc2Ints(clickNum))
lineBottomB = Segment(intersectP2(1) - (0, 0.1), intersectP2(2) - (0, 0.1))
lineBottomT = Segment(intersectP2(1) + (0, 0.1), intersectP2(2) + (0, 0.1))
innerCenterInts = Element({{(-1.04142, 0.9), (-0.75858, 0.9), (-0.95858, 1.1), (-1.24142, 1.1), (0.95858, -1.1), (1.24142, -1.1), (1.04142, -0.9), (0.75858, -0.9)}, {(0.75858, 0.9), (1.04142, 0.9), (1.24142, 1.1), (0.95858, 1.1), (-1.24142, -1.1), (-0.95858, -1.1), (-0.75858, -0.9), (-1.04142, -0.9)}, {(-0.1, 0.9), (0.1, 0.9), (0.1, 1.1), (-0.1, 1.1), (-0.1, -1.1), (0.1, -1.1), (0.1, -0.9), (-0.1, -0.9)}}, case - 1)
dilatedCenters = Element({{(-1.05325, 0.87143), (-0.6896, 0.87143), (-0.94675, 1.12857), (-1.3104, 1.12857), (0.94675, -1.12857), (1.3104, -1.12857), (1.05325, -0.87143), (0.6896, -0.87143)}, {(0.6896, 0.87143), (1.05325, 0.87143), (1.3104, 1.12857), (0.94675, 1.12857), (-1.3104, -1.12857), (-0.94675, -1.12857), (-0.6896, -0.87143), (-1.05325, -0.87143)}, {(-0.12857, 0.87143), (0.12857, 0.87143), (0.12857, 1.12857), (-0.12857, 1.12857), (-0.12857, -1.12857), (0.12857, -1.12857), (0.12857, -0.87143), (-0.12857, -0.87143)}}, case - 1)
arc1Ints: {ints1(1), ints2(2), ints1(2), ints2(1), ints3(1), ints4(2), ints3(2), ints4(1), (0, 1)}
dist1PS = Vector(centerP1, arc1Ints(clickNum))
PP1 = Intersect(chosenCircle, Ray[dilatedCenters(clickNum), dist1PS])
PP2 = Intersect(chosenCircle, Ray[dilatedCenters(clickNum), dist1PS'])
dist1P: dilatedCenters(clickNum) - PP2
distCPI = Vector(centerP1, dilatedCenters(clickNum))
ints1p = Element({{(-1.7, 1), (-0.3, 1)}, {(0.3, 1), (1.7, 1)}, {(-0.7, 1), (0.7, 1)}}, case - 1)
streetP1 = Polygon({intersectP1(1) + (0, 0.1), intersectP1(1) - (0, 0.1), intersectP1(2) - (0, 0.1), intersectP1(2) + (0, 0.1)})
streetTransversal = Polygon({intersectT(1) + PointDistTop, intersectT(1) - PointDistTop, intersectT(2) - PointDistBottom, intersectT(2) + PointDistBottom})
ints2p = Element({{(-1.49497, 1.49497), (-0.50503, 0.50503)}, {(1.49497, 1.49497), (0.50503, 0.50503)}, {(0, 1.7), (0, 0.3)}}, case - 1)
ints4p = Element({{(0.50503, -0.50503), (1.49497, -1.49497)}, {(-0.50503, -0.50503), (-1.49497, -1.49497)}, {(0, -0.3), (0, -1.7)}}, case - 1)
ints3p = Element({{(0.3, -1), (1.7, -1)}, {(-1.7, -1), (-0.3, -1)}, {(-0.7, -1), (0.7, -1)}}, case - 1)
arc2IntsP: {ints2p(2), ints1p(2), ints2p(1), ints1p(1), ints4p(2), ints3p(2), ints4p(1), ints3p(1), (1, 0)}
PolyB: arc2IntsP(clickNum)
arc1IntsP: {ints1p(1), ints2p(2), ints1p(2), ints2p(1), ints3p(1), ints4p(2), ints3p(2), ints4p(1), (0, 1)}
PolyA: arc1IntsP(clickNum)
α = Angle(PolyA, centerP1, PolyB)
streetP2 = Polygon({intersectP2(1) + (0, 0.1), intersectP2(1) - (0, 0.1), intersectP2(2) - (0, 0.1), intersectP2(2) + (0, 0.1)})
signDirectionY = If(clickNum ≟ 3 ∨ clickNum ≟ 4 ∨ clickNum ≟ 7 ∨ clickNum ≟ 8, 1, -1)
signDirectionX = If(clickNum ≟ 1 ∨ clickNum ≟ 4 ∨ clickNum ≟ 5 ∨ clickNum ≟ 8, -1, 1)
DragPoint = Point(segmentT)
innerArc1 = Element({{(-1.79373, 0.9), (-0.36804, 0.50946), (-0.20627, 1.1), (-1.63196, 1.49054), (0.20627, -1.1), (1.63196, -1.49054), (1.79373, -0.9), (0.36804, -0.50946)}, {(0.20627, 0.9), (0.50946, 0.36804), (1.79373, 1.1), (1.49054, 1.63196), (-1.79373, -1.1), (-1.49054, -1.63196), (-0.20627, -0.9), (-0.50946, -0.36804)}, {(-0.79373, 0.9), (0.1, 0.20627), (0.79373, 1.1), (-0.1, 1.79373), (-0.79373, -1.1), (0.1, -1.79373), (0.79373, -0.9), (-0.1, -0.20627)}}, case - 1)
innerArc2 = Element({{(-0.50946, 0.36804), (-0.20627, 0.9), (-1.49054, 1.63196), (-1.79373, 1.1), (1.49054, -1.63196), (1.79373, -1.1), (0.50946, -0.36804), (0.20627, -0.9)}, {(0.36804, 0.50946), (1.79373, 0.9), (1.63196, 1.49054), (0.20627, 1.1), (-1.63196, -1.49054), (-0.20627, -1.1), (-0.36804, -0.50946), (-1.79373, -0.9)}, {(-0.1, 0.20627), (0.79373, 0.9), (0.1, 1.79373), (-0.79373, 1.1), (-0.1, -1.79373), (0.79373, -1.1), (0.1, -0.20627), (-0.79373, -0.9)}}, case - 1)
arcCovers: {{InputPoint1, innerArc1(2), innerArc2(1)}, {InputPoint1, innerArc1(3), innerArc2(2)}, {InputPoint1, innerArc1(4), innerArc2(3)}, {InputPoint1, innerArc1(1), innerArc2(4)}, {InputPoint2, innerArc1(6), innerArc2(5)}, {InputPoint2, innerArc1(7), innerArc2(6)}, {InputPoint2, innerArc1(8), innerArc2(7)}, {InputPoint2, innerArc1(5), innerArc2(8)}}
arcCover1a: arcCovers(clickNum)
coverInda: Mod[clickNum - 1 + 3, 4] + 1 + If[clickNum ≤ 4, 0, 4]
arcCover2a: arcCovers(coverInda)
distCP = Vector(centerP1, innerCenterInts(clickNum))
dist4P: dilatedCenters(clickNum) - PP1
dist3P = Rotate(dist1P, (-2 * α / 3))
dist2P = Rotate(dist1P, ((-α)) / 3)
fourthPoints: {{innerCenterInts(2), innerCenterInts(4)}, {innerCenterInts(3), innerCenterInts(1)}, {innerCenterInts(4), innerCenterInts(2)}, {innerCenterInts(1), innerCenterInts(3)}, {innerCenterInts(6), innerCenterInts(8)}, {innerCenterInts(7), innerCenterInts(5)}, {innerCenterInts(8), innerCenterInts(6)}, {innerCenterInts(5), innerCenterInts(7)}}
fourthPoint: fourthPoints(clickNum)
transClick: Mod[clickNum + 4 - 1, 8] + 1
square1 = Polygon({InputPoint1, ints1(1), (x(ints1(1)), y(ints2(2))), ints2(2)})
square2 = Polygon({InputPoint1, ints2(2), (x(ints1(2)), y(ints2(2))), ints1(2)})
square3 = Polygon({InputPoint1, ints1(2), (x(ints1(2)), y(ints2(1))), ints2(1)})
square4 = Polygon({InputPoint1, ints2(1), (x(ints1(1)), y(ints2(1))), ints1(1)})
square1a = Polygon({InputPoint2, ints3(1), (x(ints3(1)), y(ints4(2))), ints4(2)})
square2a = Polygon({InputPoint2, ints4(2), (x(ints3(2)), y(ints4(2))), ints3(2)})
square3a = Polygon({InputPoint2, ints3(2), (x(ints3(2)), y(ints4(1))), ints4(1)})
square4a = Polygon({InputPoint2, ints4(1), (x(ints3(1)), y(ints4(1))), ints3(1)})
polyPointsP = Zip({m, n, p}, n, arc1IntsP, m, arcInputs, p, arc2IntsP)
squareChoice = Element({square1, square2, square3, square4, square1a, square2a, square3a, square4a}, transClick)
circleDrag = If(clickNum ≤ 4, polyCircle2, polyCircle1)
DragPointNew = Point(circleDrag)
polyPointP: polyPointsP(transClick)
DragStartNew: polyPointP(2)
centerP2: arcInputs(transClick)
angleMoved = Angle(DragPointNew, centerP2, DragStartNew)
sectorChoices: {{InputPoint1, ints1(1), ints2(2)}, {InputPoint1, ints2(2), ints1(2)}, {InputPoint1, ints1(2), ints2(1)}, {InputPoint1, ints2(1), ints1(1)}, {InputPoint2, ints3(1), ints4(2)}, {InputPoint2, ints4(2), ints3(2)}, {InputPoint2, ints3(2), ints4(1)}, {InputPoint2, ints4(1), ints3(1)}}
caseEnd = If(clickNum ≟ 1 ∨ clickNum ≟ 4 ∨ clickNum ≟ 5 ∨ clickNum ≟ 8, 3, 4)
caseChoice = If(case ≟ 1, 3, case ≟ 2, 7, case ≟ 3, 2, 6)
endPoint = If(centerP1 ≟ InputPoint1, InputPoint2, InputPoint1)
showArc2: DragPoint ≟ endPoint
EndPoint = Rotate(DragStartNew, 180°, centerP2)
dragEnd: DragPointNew ≟ EndPoint
dist1PN = Vector(centerP2, DragPointNew)
dist6PN = Rotate(dist1PN, α / 3)
dist7PN: dist1PN - dist6PN
dist4PN = Rotate(dist1PN, α)
dist5PN: dist1PN - dist4PN
dist2PN = Rotate(dist1PN, (2 * α / 3))
dist3PN: dist1PN - dist2PN
segmentP2 = Segment(intersectP2(1), intersectP2(2))
yPixelPoint1 = If(clickNum ≟ 9 ∧ case ≟ 1 ∨ showArc2 ∧ (transClick ≟ 3 ∨ transClick ≟ 4) ∨ (¬showArc2) ∧ (clickNum ≟ 3 ∨ clickNum ≟ 4), -1 - 0.5, clickNum ≟ 9 ∧ case ≟ 2 ∨ showArc2 ∧ (transClick ≟ 7 ∨ transClick ≟ 8) ∨ (¬showArc2) ∧ (clickNum ≟ 7 ∨ clickNum ≟ 8), 1 - 0.5, clickNum ≟ 9 ∧ case ≟ 3 ∨ showArc2 ∧ (transClick ≟ 1 ∨ transClick ≟ 2) ∨ (¬showArc2) ∧ (clickNum ≟ 1 ∨ clickNum ≟ 2), -1 + 0.5, 1 + 0.5)
xPixelPoint: If[showArc2, If[4 < transClick < 9, x(InputPoint2), x(InputPoint1)], case ≟ 2 ∨ case ≟ 4 ∨ 4 < clickNum < 9, x(InputPoint2), x(InputPoint1)] + 0.8
PixelPoint: (xPixelPoint, yPixelPoint1)
countCorrect = 0
showbuttons = true
pixelsRight: 16
pixelsLeft: 16
pixelsBottom: 16 + 36 + 24 + 16 + 8
pixelsTop: 24 + 16 + 8
borderBox = Polygon(Zip[PixelsToPoint[Corner[1], Corner[3], Corner[5], A], A, {(pixelsLeft, pixelsTop), (pixelsLeft, y(Corner[5]) - pixelsBottom), Corner[5] - (pixelsRight, pixelsBottom), (x(Corner[5]) - pixelsRight, pixelsTop)}])
layoutY: 448
layoutX: 170 + 24
layoutAppSize = Corner(5)
inputPointLastPos: (0, 1)
inputCurrent: {InputPoint1}
inputSaved: {(0, 1)}
arc3 = CircleSector(InputPoint1, ints1(2), ints2(1))
arc4 = CircleSector(InputPoint1, ints2(1), ints1(1))
arc1a = CircleSector(InputPoint2, ints3(1), ints4(2))
arc2a = CircleSector(InputPoint2, ints4(2), ints3(2))
arc3a = CircleSector(InputPoint2, ints3(2), ints4(1))
arc4a = CircleSector(InputPoint2, ints4(1), ints3(1))
active = Sequence(clickNum ≟ n, n, 1, 9)
DragPoint2 = (1.710849321202622, 1)
DragPoint3 = (1.6294881619055355, 0.698315143047686)
DragPoint4 = (1.710849321202622, 1)
DragPoint1 = (0.9201187972326204, 0.4311222739233599)
polyPoints = Zip({m, n, p}, n, arc1Ints, m, arcInputs, p, arc2Ints)
polyPoint: polyPoints(clickNum)
ArcA: arc1Ints(clickNum)
ArcB: arc2Ints(clickNum)
dist1: centerP1 - arcCover2a(2)
dist2: centerP1 - arcCover1a(3)
randomNum2: (-randomNum1)
dimensions: {-2.85201, -2.90395, 6.358, 2.84722}
staticDragSquare = Rotate(squareChoice, (-angleMoved), centerP2)
direction = If(Mod[clickNum, 4] > 1, 0.25, -0.25)
AnPoint1: Midpoint[InputPoint1, InputPoint2] + (direction, 0)
AnPoint0: centerP1 + (direction, 0)
speed: 4
step = 1
slideStarted: DragPoint ≠ centerP1
speed1: 2
PointTreeA = (0.8230900874999996, -1.9463135599999992)
PointTreeB: (1.52274, -1.94631)
onboarding = true
pulsingSpeed: 8
pulsing = 0.2 (slider from 0 to 1, step 0.1)
haloPixels: (pulsing * 7)
RightPixelCoords = PointToPixels(Corner[1], Corner[3], Corner[5], PixelPoint)
onboardingX: x(RightPixelCoords) + 8
onboardingY: y(RightPixelCoords) + 8
basePixels: 70
sectorChoice: sectorChoices(clickNum)
dragPoly2, dragPoly2a, dragPoly2b, dragPoly2c, dragPoly2d, dragPoly2e = Polygon(DragPointNew - dist1PN, DragPointNew, DragPointNew - dist7PN, DragPointNew - dist3PN, DragPointNew - dist5PN)
vectorTreePics = Zip(Vector[PointTreeMiddle, n], n, treePoints)
trees = Zip(Translate[treePicBase, Vector[n]], Vector[n], vectorTreePics)
sectorCase: sectorChoices(caseChoice)
sectorUse: sectorChoices(If[clickNum ≟ 9, caseChoice, ¬showArc2, clickNum, caseEnd])
pulsingObject1 = sectorPixels(sectorUse(1), sectorUse(2), sectorUse(3), basePixels + haloPixels, Corner[1], Corner[3], Corner[5])
numClicks = 0
changePulseColor: ¬(clickNum ≟ 9 ∨ (¬dragEnd))
DragCenterNew: DragStartNew + dist4P
xpA: x(PolyA)
ypA: y(PolyA)
DragPointNew' = Dilate(DragPointNew, 8 / 7, centerP2)
dragPoly1, dragPoly1b, dragPoly1c, dragPoly1d, dragPoly1e, dragPoly1f, dragPoly1g, dragPoly1a = Polygon(DragPoint, DragPoint + distCPI, DragPoint - dist1P + distCPI, DragPoint - dist2P + distCPI, DragPoint - dist3P + distCPI, DragPoint - dist4P + distCPI, DragPoint + distCPI)
staticDragArc2 = CircleSector(centerP2, DragPointNew', Rotate[DragPointNew', α, centerP2])
onboardingText: "\bgcolor{white}{\text{" + (LaTeX[If[step ≟ 1, "Click to Start", "Drag to Continue"]]) + "}}"
onboardingCase: 1
OnboardingTextOffset = onboardingTextOffset(Corner[onboardingText, 1], Corner[onboardingText, 3], onboardingCase, Corner[1], Corner[3], Corner[5])
onboardingTextX: onboardingX + x(OnboardingTextOffset)
onboardingTextY: onboardingY + y(OnboardingTextOffset)
onboardingDisplayText: "" + (LaTeX[onboardingText]) + ""
coverInd: Mod[transClick - 1 + 3, 4] + 1 + If[transClick ≤ 4, 0, 4]
arcCover2: arcCovers(coverInd)
arcCover1: arcCovers(transClick)
arcCoverA = CircleSector(arcCover1(1), arcCover1(3), arcCover1(2))
arcCoverB = CircleSector(arcCover2(1), arcCover2(3), arcCover2(2))
arcCoverA' = Rotate(arcCoverA, (-angleMoved), centerP2)
arcCoverB' = Rotate(arcCoverB, (-angleMoved), centerP2)
dist1PN' = Rotate(dist1PN, pi / 2)
polyCover1 = Polygon({centerP2, innerCenterInts(transClick), arcCover1(3), arcCover1(2)})
polyCover2 = Polygon({innerCenterInts(transClick), centerP2, arcCover2(3), arcCover2(2)})
polyCover1' = Rotate(polyCover1, (-angleMoved), centerP2)
polyCover2' = Rotate(polyCover2, (-angleMoved), centerP2)
dragSquare2, dragpointnew, dragSquare2a, dragSquare2b, dragSquare2c = Polygon(DragPointNew, DragPointNew - dist1PN, DragPointNew - (dist1PN - dist1PN'), DragPointNew + dist1PN')
PtDropped = Point(circleDrag)
activeMove: PtDropped ≠ DragPointNew
innerCircle = Circle(centerP2, innerCenterInts(transClick))
CenterCircle: innerCenterInts(transClick)
circleArrow = Circle(centerP2, If[α ≟ 90°, 1.3, 0.95])
arrowCenter = Intersect(circleArrow, Ray[centerP2, CenterCircle])
arrowPoint1 = Rotate(arrowCenter, -10°, centerP2)
arrowPoint2 = Rotate(arrowCenter, 10°, centerP2)
arrowArc = CircleArc(centerP2, arrowPoint1, arrowPoint2)
transVect = Vector(polyPoint(1), DragPoint)
selectedArc = Element({arc1, arc2, arc3, arc4, arc1a, arc2a, arc3a, arc4a}, clickNum)
thirdArcInd = If(clickNum ≟ 1, 8, clickNum ≟ 2, 7, clickNum ≟ 3, 7, clickNum ≟ 4, 8, clickNum ≟ 5, 1, clickNum ≟ 6, 2, clickNum ≟ 7, 2, clickNum ≟ 8, 1, 9)
secondArcInd = If(clickNum ≟ 1, 8, clickNum ≟ 2, 7, clickNum ≟ 3, 2, clickNum ≟ 4, 1, clickNum ≟ 5, 8, clickNum ≟ 6, 7, clickNum ≟ 7, 2, clickNum ≟ 8, 1, 9)
arrowSeg = Segment(arrowCenter, arrowPoint1)
staticDragArc1 = CircleSector(DragPoint + distCP, DragPoint - dist1, DragPoint - dist2)
β = Angle(PolyA, centerP1, PolyB)
x2: randomNum2
dragSquareS, dragSquareS1, dragSquareS2, dragSquareS3, dragSquareS4, dragSquareS5, dragSquareS6 = Polygon(DragPoint, DragPoint + ((signDirectionX * 0.1), (signDirectionY * 0.1)), DragPoint + ((signDirectionX * 0.1), (signDirectionY * 0.8)), DragPoint + ((signDirectionX * 0.8), (signDirectionY * 0.8)), DragPoint + ((signDirectionX * 0.8), (signDirectionY * 0.1)), DragPoint + ((signDirectionX * 0.1), (signDirectionY * 0.1)))
tabOrder: {arc1, arc2, arc3, arc4, arc1a, arc2a, arc3a, arc4a, dragPoly1, dragPoly2, square1, square2, square3, square4, square1a, square2a, square3a, square4a, dragSquareS, dragSquare2, btnReset, btnNew}
clickSupp = If(clickNum ≤ 4, 5 - clickNum, 8 - Mod[clickNum, 5])
arcSupp = Element({arc1, arc2, arc3, arc4, arc1a, arc2a, arc3a, arc4a}, clickSupp)
PtArc1B: (2.95, -0.5)
PtArc2C: PtArc1B + (1.5, 0)
PtArc1C: PtArc1B + (0.5, 0)
PtArc2A: PtArc2C + (0.5, 0)
PtArc1A = Rotate(PtArc1B, (-α), PtArc1C)
PtArc2B = Rotate(PtArc2A, pi - α, PtArc2C)
arc2Sector = CircleSector(PtArc2C, PtArc2A, PtArc2B)
arc1Sector = CircleSector(PtArc1C, PtArc1A, PtArc1B)
xPlus: (Min[{x(PtArc2A), x(PtArc2B), x(PtArc2C)}] + Max[{x(PtArc1A), x(PtArc1B), x(PtArc1C)}]) / 2
PtPlus: (xPlus, -0.25)
squareSupp = Element({square1, square2, square3, square4, square1a, square2a, square3a, square4a}, clickSupp)
square1Sector, f, g, h, i, polyA, polyB = Polygon(PtArc1C, PtArc1A, 4)
square2Sector, j, k, l, m, poly2A, poly2B = Polygon(PtArc2C, PtArc2A, 4)
a = If(clickNum < 4, 5 - clickNum, 9 - clickNum)
innerPoly1 = Element({{(-0.58081, 0.43939), (-0.30718, 0.9), (-1.41919, 1.56061), (-1.69282, 1.1), (1.41919, -1.56061), (1.69282, -1.1), (0.58081, -0.43939), (0.30718, -0.9)}, {(0.43939, 0.58081), (1.69282, 0.9), (1.56061, 1.41919), (0.30718, 1.1), (-1.56061, -1.41919), (-0.30718, -1.1), (-0.43939, -0.58081), (-1.69282, -0.9)}, {(-0.1, 0.30718), (0.69282, 0.9), (0.1, 1.69282), (-0.69282, 1.1), (-0.1, -1.69282), (0.69282, -1.1), (0.1, -0.30718), (-0.69282, -0.9)}}, case - 1)
innerPoly2 = Element({{(-1.69282, 0.9), (-0.43939, 0.58081), (-0.30718, 1.1), (-1.56061, 1.41919), (0.30718, -1.1), (1.56061, -1.41919), (1.69282, -0.9), (0.43939, -0.58081)}, {(0.30718, 0.9), (0.58081, 0.43939), (1.69282, 1.1), (1.41919, 1.56061), (-1.69282, -1.1), (-1.41919, -1.56061), (-0.30718, -0.9), (-0.58081, -0.43939)}, {(-0.69282, 0.9), (0.1, 0.30718), (0.69282, 1.1), (-0.1, 1.69282), (-0.69282, -1.1), (0.1, -1.69282), (0.69282, -0.9), (-0.1, -0.30718)}}, case - 1)
caseN = If(x1 ≟ -1, 2, x1 ≟ 1, 3, 4)

Tool: PixelsToPoint
PixelsToPoint(Corner1,Corner3,Corner5,PixelCoords)
Input: Corner1, Corner3, Corner5, InputPixels
Output: OutputPoint

InputPixels: (100, 200)
xRight: x(Corner3)
xLeft: x(Corner1)
yTop: y(Corner3)
yBottom: y(Corner1)
yCoord: yTop - (y(InputPixels) / y(Corner5) * (yTop - yBottom))
xCoord: (x(InputPixels) / x(Corner5) * (xRight - xLeft)) + xLeft
OutputPoint: (xCoord, yCoord)

Tool: PixelsToPoint (command PixelsToPoint1)
PixelsToPoint(Corner1,Corner3,Corner5,PixelCoords)
Input: Corner1, Corner3, Corner5, InputPixels
Output: OutputPoint

InputPixels: (100, 200)
xRight: x(Corner3)
xLeft: x(Corner1)
yTop: y(Corner3)
yBottom: y(Corner1)
yCoord: yTop - (y(InputPixels) / y(Corner5) * (yTop - yBottom))
xCoord: (x(InputPixels) / x(Corner5) * (xRight - xLeft)) + xLeft
OutputPoint: (xCoord, yCoord)

Tool: PointToPixels
PointToPixels(Corner1,Corner3,Corner5,InputPoint)
Input: Corner1, Corner3, Corner5, InputPoint
Output: OutputPixels

Corner1: (-5, -5)
Corner3: (16, 6)
Corner5: (300, 200)
xLeft: x(Corner1)
xRight: x(Corner3)
yTop: y(Corner3)
yBottom: y(Corner1)
yPixels: (y(Corner5) * (y(InputPoint) - yBottom) / (yTop - yBottom))
xPixels: (x(Corner5) * (x(InputPoint) - xLeft) / (xRight - xLeft))
OutputPixels: (xPixels, yPixels)

Tool: PartitionPoint
PartitionPoint(P1,P2,Num,Den)
Input: SimMove, solutionPoint, animation1Slider, animation1Range
Output: Animation1Point

$\textbf{\mathsf{F}}$

Animation1Point: SimMove + (animation1Slider * (solutionPoint - SimMove) / animation1Range)

Tool: treeSeries
Input: A, d
Output: c, e, f

d: 1
B: A + (d, 0)
B' = Rotate(B, (-atand(1.5)), A)
B'_{1} = Rotate(B, atand(1.5), A)
B'_{2} = Rotate(B, (4 * pi / 3) - atand(1.5), A)
c = Circle(B', (4 * d / 9))
e = Circle(B'_{1}, (2 * d / 3))
f = Circle(B'_{2}, (7 * d / 9))

Tool: pixelsToDistanceY
pixelsToDistanceY(inputPixels,corner1,corner3,corner5)
Input: inputPixels, Corner1, Corner3, Corner5
Output: outputDistance

Corner1: (-4, -2)
Corner3: (6, 6)
Corner5: (800, 500)
yLeft: y(Corner1)
yRight: y(Corner3)
outputDistance: (inputPixels / y(Corner5) * (yRight - yLeft))

Tool: pixelsToDistanceX
pixelsToDistanceX(inputPixels,corner1,corner3,corner5)
Input: inputPixels, Corner1, Corner3, Corner5
Output: outputDistance

inputPixels: 5
Corner1: (-4, -2)
Corner3: (6, 6)
Corner5: (800, 500)
xLeft: x(Corner1)
xRight: x(Corner3)
outputDistance: (inputPixels / x(Corner5) * (xRight - xLeft))

Tool: expandSector
expandedSector(Midpoint,B,C,pixelRadius,Corner1,Corner3,Corner5)
Input: A, B, C, pixelRadius, Corner1, Corner3, Corner5
Output: newSector

xyScale: pixelsToDistanceY[10, Corner1, Corner3, Corner5] / pixelsToDistanceX[10, Corner1, Corner3, Corner5]
CPrime: A + (x(C) - x(A), (y(C) - y(A)) / xyScale)
anglePart2 = Angle(A + (1, 0), A, CPrime)
Bprime: A + (x(B) - x(A), (y(B) - y(A)) / xyScale)
anglePart1 = Angle(A + (1, 0), A, Bprime)
startAngle: anglePart1
endAngle = If(anglePart2 > startAngle, anglePart2, anglePart2 + (2 * pi))
pointGap = pixelsToDistanceX(pixelRadius, Corner1, Corner3, Corner5)
arc = Sequence((x(A) + (pointGap * cos(K)), y(A) + ((pointGap * xyScale) * sin(K))), K, startAngle, endAngle, (endAngle - startAngle) / 48)
cornerPoints = Append(A, arc)
newSector = Polygon(cornerPoints)

Tool: pixelsToDistanceX (command pixelsToDistanceX1)
pixelsToDistanceX(inputPixels,corner1,corner3,corner5)
Input: inputPixels, Corner1, Corner3, Corner5
Output: outputDistance

inputPixels: 5
Corner1: (-4, -2)
Corner3: (6, 6)
Corner5: (800, 500)
xLeft: x(Corner1)
xRight: x(Corner3)
outputDistance: (inputPixels / x(Corner5) * (xRight - xLeft))

Tool: circlePixels
circlePixels(A,pixelRadius,Corner1,Corner3,Corner5
Input: A, pixelRadius, Corner1, Corner3, Corner5
Output: newCircle

pointRadius = pixelsToDistanceX(pixelRadius, Corner1, Corner3, Corner5)
newCircle = Circle(A, pointRadius)

Tool: pixelsToDistanceX (command pixelsToDistanceX2)
pixelsToDistanceX(inputPixels,corner1,corner3,corner5)
Input: inputPixels, Corner1, Corner3, Corner5
Output: outputDistance

inputPixels: 5
Corner1: (-4, -2)
Corner3: (6, 6)
Corner5: (800, 500)
xLeft: x(Corner1)
xRight: x(Corner3)
outputDistance: (inputPixels / x(Corner5) * (xRight - xLeft))

Tool: sectorPixels
sectorPixels(Midpoint,B,C,pixelRadius,Corner1,Corner3,Corner5
Input: A, B, C, pixelRadius, Corner1, Corner3, Corner5
Output: newSector

pixelRadius: 30
pointRadius = pixelsToDistanceX(pixelRadius, Corner1, Corner3, Corner5)
BPrime: A + (pointRadius * UnitVector[B - A])
newSector = CircleSector(A, BPrime, C)

Tool: onboardingTextOffset
onboardingTextOffset(textCorner1,textCorner3,case,corner1,corner3,corner5)
Input: CornerText1, CornerText3, case, Corner1, Corner3, Corner5
Output: TextOffset

xPixels: ((x(CornerText3) - x(CornerText1)) * x(Corner5) / (x(Corner3) - x(Corner1)))
yPixels: ((y(CornerText3) - y(CornerText1)) * y(Corner5) / (y(Corner3) - y(Corner1)))
xOffset = Element({27, (-xPixels) + 2, 16 - xPixels / 2, 16 - xPixels / 2}, case)
yOffset = Element({-23, -23, yPixels - 27, -49}, case)
TextOffset: (xOffset, yOffset)