#4D4D4D

$\text{Check}$

$\text{NEW PROBLEM}$

Fix position and allow selection for all text objects

Empty all input boxes

$b=$

Reset app

\text{This is the error specific hint}

#006758

#B00020

#252525

#757575

#949494

#E44461

#DA2570

#E66B9E

#3A6ED6

#5991FF

#008475

#0F8538

#00a83c

#5145A8

#6557D2

#8575FF

#903D14

#BD6C43

#C75000

#E07415

#eeeeee

#2E006758

#2EB00020

\text{Drag to start}

$SA=\vphantom{b}$

\text{Describe the applet here}

$\text{Some string input}$

$\bold\textsf{%v}$

$\bold\textsf{Unfold / Fold}$

$\bold\textsf{Fold / Unfold}$

\text{Sides}

\text{Calculate the surface area of the Cone\shown to the right.}

\text{Open net}

$\textsf{NEW CONE}$

RESET

\pi\textsf{ square units}

$\bold\textsf{Fold / Unfold}$

allRandomSeeds = RandomUniform(0, 0.99, 200)
inputSaved: {"", "", ""}
inputDefined: Sum[Zip[A ≠ "?" ∧ ReplaceAll[A, " ", ""] ≠ "", A, {stringA}]] ≟ 1
validA = true
validB = true
validC = true
inputCurrent: {stringA, stringB, stringC}
inputValid: Sum[{validA, validB, validC}] ≟ 3
inputA = NaN
inputB = NaN
numRandoms: 2
countQuestion = 0
randIndex: (Mod[countQuestion, floor(Length[allRandomSeeds] / numRandoms)] * numRandoms) + 1
currentRandomSeeds = Take(allRandomSeeds, randIndex, randIndex + numRandoms - 1)
randomNum1: 1 + floor((currentRandomSeeds(1) * 20))
onboarding = false
randomNum2: randomNum1 + 2 + floor((currentRandomSeeds(2) * 10))
correct1: inputA ≟ randomNum1
validate = false
showanswer = false
showsolution = false
tries = 0
countCorrect = 0
showhint = false
possibleRads_{1} = Shuffle(Sequence[5])
countQuestion_{1}: countQuestion
r1_{1} = If(countQuestion_{1} ≟ 0, 2, Element[possibleRads_{1}, Mod[countQuestion_{1}, Length[possibleRads_{1}]] + 1])
possibleHsl_{1} = Shuffle(KeepIf[1 ≤ sqrt(CLIPBOARDmagicSTRINGkk^(2) - r1_{1}^(2)) ≤ 5, CLIPBOARDmagicSTRINGkk, Sequence[7]])
Hsl_{1} = If(countQuestion_{1} ≟ 0, 5, possibleHsl_{1}(1))
SA_{1}: (r1_{1} * Hsl_{1}) + r1_{1}^(2)
textSolution: "\textsf{\bold{Possible Solution}}\\
\pi rl+\pi r^2\\
=(rl+r^2)\pi\\
=(" + (LaTeX[r1_{1}]) + "\times" + (LaTeX[Hsl_{1}]) + "+" + (LaTeX[r1_{1}]) + "^2)\pi\\
=" + (LaTeX[SA_{1}]) + "\pi\text{ square units}"
InputBoxB = Textfield(inputB)
correct2: inputB ≟ randomNum2
correct: SA_{1} ≟ inputA
isTypicalError: inputB ≟ inputA + 1
showbuttons = true
showhinttypicalerror = false
textCountCorrect: "\text{Number correct: " + (LaTeX[countCorrect]) + " }"
showGraphhint = false
helpTextHint: "\text{" + (LaTeX[If[showGraphhint, "A cone with the same surface area as your\\answer is displayed. See how it compares.", "Find the areas of each shape.\\Next find the sum of the areas."]]) + "}"
pixelsRight: 16
pixelsLeft: 16
pixelsBottom: 16
pixelsTop: 24
textHint: "\text{\color{" + (LaTeX[colorOrange]) + "}\bold{Hint}\\" + (LaTeX[If[showhinttypicalerror, helpTextHintTypicalError]]) + "" + (LaTeX[If[showhint ∧ showhinttypicalerror, "\\"]]) + "" + (LaTeX[If[showhint, helpTextHint]]) + "}"
layoutY: 160
layoutX: 16
enableBtnValidate: inputCurrent ≠ inputSaved ∧ inputDefined ∧ inputValid
pulsingSpeed: 8
pulsing = 0.6 (slider from 0 to 1, step 0.1)
onboardingCase: 1
onboardingX: 337
onboardingY: 150
OnboardingTextOffset = onboardingTextOffset(Corner[onboardingText, 1], Corner[onboardingText, 3], onboardingCase, Corner[1], Corner[3], Corner[5])
onboardingDisplayText: "" + (LaTeX[onboardingText]) + ""
solutionView: showanswer ∨ showsolution
InputBoxA = Textfield(inputA)
altFeedback: "\text{" + (LaTeX[If[correct, (("Your answer is correct. Total number correct: " * countCorrect) * ". "), ("Your answer is not correct. " * If[tries < 3, "Try again. ", "Maybe next time. "])]]) + "}" + (LaTeX[If[showsolution, ("\\" * textSolution), If[showhint ∨ showhinttypicalerror, textHint, ""]]]) + ""
InputBoxC = Textfield(inputC)
textFeedback: "\text{\vphantom{✕}" + (LaTeX[If[correct, (("\textcolor{" * colorTealSuccess) * "}{✓ Correct}"), (((("\textcolor{" * colorRedError) * "}{✕ ") * If[tries < 3, "Try again", "Maybe next time"]) * "}")]]) + "}"
maxTries: 3
labelBtnValidate: "\text{CHECK (" + (LaTeX[maxTries - tries]) + ")}"
enableInput: tries < maxTries ∧ (¬(validate ∧ correct))
ddMenu_{1}: {"$\textsf{Prism }$", "$\textsf{Pyramid }$", "$\textsf{Cylinder }$", "$\textsf{Cone }$"}
hCone_{1}: sqrt(Hsl_{1}^(2) - r1_{1}^(2)) / r1_{1}
CA_{1} = Point(yAxis)
CB_{1} = Point(yAxis)
n_{1} = 6 (slider from 3 to 8, step 1)
A_{1}: (0, 0)
h_{1} = Ray(A_{1}, (x(A_{1}), y(A_{1}), 40))
B_{1} = Point(yAxis)
CD_{1} = Point(Segment[(0, 0, 0.1), (0, 0, 4)])
open_{1} = 0 (slider from -1 to 0)
choice_{1}: SelectedIndex[ddMenu_{1}] + 1
nRand_{1} = Random(3, 8)
tCil2_{1} = 0 (slider from 0 to 1)
tCil_{1}: (-tCil2_{1})
d_{1} = Circle(CA_{1}, CB_{1})
θCil_{1}: (pi * (1 - abs(tCil_{1})))
ϕCil_{1}: (abs(tCil_{1}) * pi / 2)
CC_{1}: (0, 0, 3)
aCon_{1} = Segment((1, 0, 0), (1, 0, 5))
cCon_{1} = Circle(aCon_{1}, (0, 0, 0))
KA_{1}: (1, 0, hCone_{1})
KB_{1} = Intersect(xAxis, aCon_{1})
bCon_{1}, dCon_{1}, eCon_{1} = Cone(KB_{1}, KA_{1}, 1)
KC_{1} = Intersect(yAxis, xAxis)
lCon_{1} = Segment(KC_{1}, KA_{1})
rCon_{1} = Distance(KB_{1}, KC_{1})
α_{1} = Angle(KA_{1}, KC_{1}, KB_{1})
KAA_{1} = Rotate(KA_{1}, (abs(tCil_{1}) * α_{1}), yAxis)
fCon_{1} = OrthogonalLine(KAA_{1}, xOyPlane)
KBB_{1} = Intersect(fCon_{1}, xOyPlane)
bet_{1}: ((2 * pi) * rCon_{1} / Distance[KBB_{1}, KC_{1}])
KCC_{1} = Rotate(KC_{1}, bet_{1} / 2, fCon_{1})
KCR_{1} = Rotate(KC_{1}, ((-bet_{1})) / 2, fCon_{1})
gCon_{1} = CircumcircleArc(KCC_{1}, KC_{1}, KCR_{1})
hCon_{1} = Distance(KAA_{1}, KBB_{1})
rcCon_{1} = Distance(KBB_{1}, KCC_{1})
kCon_{1}: x(KAA_{1})
ϕCon_{1}: (abs(tCil_{1}) * pi)
jCon_{1} = Surface(((kCon_{1} - ((v * rcCon_{1}) * cos((u * bet_{1} / 2)))) * cos(ϕCon_{1})) - (((1 - v) * hCon_{1}) * sin(ϕCon_{1})), ((v * rcCon_{1}) * sin((u * bet_{1} / 2))), (((1 - v) * hCon_{1}) * cos(ϕCon_{1})) + ((kCon_{1} - ((v * rcCon_{1}) * cos((u * bet_{1} / 2)))) * sin(ϕCon_{1})), u, -1, 1, v, 0, 1)
mCon_{1} = CurveCartesian(((kCon_{1} - (rcCon_{1} * cos((u * bet_{1} / 2)))) * cos(ϕCon_{1})), (rcCon_{1} * sin((u * bet_{1} / 2))), ((kCon_{1} - (rcCon_{1} * cos((u * bet_{1} / 2)))) * sin(ϕCon_{1})), u, -1, 1)
KD_{1}: (((kCon_{1} - (rcCon_{1} * cos(bet_{1} / 2))) * cos(ϕCon_{1})), (rcCon_{1} * sin(bet_{1} / 2)), ((kCon_{1} - (rcCon_{1} * cos(bet_{1} / 2))) * sin(ϕCon_{1})))
KE_{1}: (((kCon_{1} - (rcCon_{1} * cos(((-bet_{1})) / 2))) * cos(ϕCon_{1})), (rcCon_{1} * sin(((-bet_{1})) / 2)), ((kCon_{1} - (rcCon_{1} * cos(((-bet_{1})) / 2))) * sin(ϕCon_{1})))
KF_{1}: ((kCon_{1} * cos(ϕCon_{1})) - (hCon_{1} * sin(ϕCon_{1})), 0, (hCon_{1} * cos(ϕCon_{1})) + (kCon_{1} * sin(ϕCon_{1})))
nCon_{1} = Segment(KE_{1}, KF_{1})
pCon_{1} = Segment(KD_{1}, KF_{1})
speed_{1}: 1
TV_{1}: (2, -2, 2)
SizeGV1_{1} = Corner(5)
SizeTotal_{1}: (x(Corner[1, 5]) + x(CornerThreeD[-1, 9]), y(Corner[5]))
view_{1} = Vector((1; (pi / 2 * tCil2_{1}) + (pi / 6 * (1 - tCil2_{1})); ((-pi)) / 2 + ((0.8 * pi / 2) * (1 - tCil2_{1}))))
stage_{1} = 1
text1_{1}: "\textsf{Formula for Cone Surface Area (SA):}\\
\textsf{SA = \textcolor{#DA2570}{Lateral Surface Area} + \textcolor{#3A6ED6}{Base Area}}\\" + (LaTeX[If[stage_{1} ≟ 1, "\textsf{SA = }\textcolor{#DA2570}{\pi r l} + \textcolor{#3A6ED6}{\pi r^2}}", "\textsf{SA = }\pi \textcolor{#3A6ED6}{r} \textcolor{#DA2570}{l} + \pi \textcolor{#3A6ED6}{r}^2"]]) + "\\" + (LaTeX[If[stage_{1} ≟ 2, (((((((("\textsf{SA = }\pi\times \textcolor{#3A6ED6}{" * r1_{1}) * "}\times \textcolor{#DA2570}{") * Hsl_{1}) * "} + \pi\times \textcolor{#3A6ED6}{") * r1_{1}) * "}^2\\\textsf{SA = }") * SA_{1}) * "\pi\text{ sq. units}"), ""]]) + ""
jCon'_{1} = Rotate(jCon_{1}, -90°)
KE'_{1} = Rotate(KE_{1}, -90°)
KF'_{1} = Rotate(KF_{1}, -90°)
nCon'_{1} = Segment(KE'_{1}, KF'_{1})
KD'_{1} = Rotate(KD_{1}, -90°)
KF'_{2} = Rotate(KF_{1}, -90°)
pCon'_{1} = Segment(KD'_{1}, KF'_{2})
cCon'_{1} = Rotate(cCon_{1}, -90°)
mCon'_{1} = Rotate(mCon_{1}, -90°)
dCon'_{1} = Rotate(dCon_{1}, -90°)
factor_{1} = If(r1_{1} / Hsl_{1} ≤ 1 / 2, 1, 2)
EP1_{1} = Translate(KE'_{1}, Vector[(0, -1 + (2 * tCil2_{1}), 0)])
EP2_{1} = Translate(KF'_{1}, Vector[(0, -1 + (2 * tCil2_{1}), 0)])
u_{1} = Vector(Midpoint[EP1_{1}, EP2_{1}], EP1_{1})
v_{1} = Vector(Midpoint[EP1_{1}, EP2_{1}], EP2_{1})
EPr1_{1}: (-2, 0, 0)
EPr2_{1}: (-2, -1, 0)
w_{1} = Vector(Midpoint[EPr1_{1}, EPr2_{1}], EPr2_{1})
a_{1} = Vector(Midpoint[EPr1_{1}, EPr2_{1}], EPr1_{1})
f_{1} = Segment((0, -1, 0), (0, 0))
g_{1} = Segment(EP1_{1}, KE'_{1})
i_{1} = Segment(EP2_{1}, KF'_{1})
j_{1} = Segment(EPr2_{1}, (0, -1, 0))
k_{1} = Segment(EPr1_{1}, (0, 0, 0))
labelRToMeasure_{1} = Text(r1_{1}, (0, 0), true, true)
labelLToMeasure_{1} = Text(Hsl_{1}, (0, 0), true, true)
measureLabelR_{1} = Vector(Corner[labelRToMeasure_{1}, 1], Corner[labelRToMeasure_{1}, 3])
measureLabelL_{1} = Vector(Corner[labelLToMeasure_{1}, 1], Corner[labelLToMeasure_{1}, 3])
labelL_{1} = Text(Hsl_{1}, Midpoint[EP1_{1}, EP2_{1}] + (((-tCil2_{1}) * x(measureLabelL_{1}) / 2), (((2 * tCil2_{1}) - 1) * y(measureLabelL_{1})), (y(measureLabelL_{1}) * (1 - tCil2_{1}))), true, true)
labelR_{1} = Text(r1_{1}, Midpoint[EPr1_{1}, EPr2_{1}] + ((-x(measureLabelR_{1})), y(measureLabelR_{1}) / 2), true, true)
c_{1}: (2 * abs(u_{1}))
CView_{1}: (0, -1 + tCil2_{1}, tCil2_{1} / 2)
showformula = false
lblBtnFormula: "\textsf{" + (LaTeX[If[showformula, "HIDE FORMULA", "SHOW FORMULA"]]) + "}"
max_{1} = 3.1816949906249126
hhint: sqrt(((inputA - r1_{1}^(2)) / r1_{1})^(2) - r1_{1}^(2)) / r1_{1}
choice_{2}: 5
hhint_{1} = 0.75
tCil_{2} = If(hhint_{1} ≤ hCon_{1}, tCil2_{1}^(2), sqrt(tCil2_{1}))
aCon_{2} = Segment((1, 0, 0), (1, 0, 5))
KB_{2} = Intersect(xAxis, aCon_{2})
KA_{2}: (1, 0, hhint_{1})
KC_{2} = Intersect(yAxis, xAxis)
lCon_{2} = Segment(KC_{2}, KA_{2})
rCon_{2} = Distance(KB_{2}, KC_{2})
α_{2} = Angle(KA_{2}, KC_{2}, KB_{2})
KAA_{2} = Rotate(KA_{2}, (abs(tCil_{2}) * α_{2}), yAxis)
fCon_{2} = OrthogonalLine(KAA_{2}, xOyPlane)
KBB_{2} = Intersect(fCon_{2}, xOyPlane)
bet_{2}: ((2 * pi) * rCon_{2} / Distance[KBB_{2}, KC_{2}])
KCC_{2} = Rotate(KC_{2}, bet_{2} / 2, fCon_{2})
KCR_{2} = Rotate(KC_{2}, ((-bet_{2})) / 2, fCon_{2})
hCon_{2} = Distance(KAA_{2}, KBB_{2})
rcCon_{2} = Distance(KBB_{2}, KCC_{2})
kCon_{2}: x(KAA_{2})
ϕCon_{2}: (abs(tCil_{2}) * pi)
KD_{2}: (((kCon_{2} - (rcCon_{2} * cos(bet_{2} / 2))) * cos(ϕCon_{2})), (rcCon_{2} * sin(bet_{2} / 2)), ((kCon_{2} - (rcCon_{2} * cos(bet_{2} / 2))) * sin(ϕCon_{2})))
KE_{2}: (((kCon_{2} - (rcCon_{2} * cos(((-bet_{2})) / 2))) * cos(ϕCon_{2})), (rcCon_{2} * sin(((-bet_{2})) / 2)), ((kCon_{2} - (rcCon_{2} * cos(((-bet_{2})) / 2))) * sin(ϕCon_{2})))
KF_{2}: ((kCon_{2} * cos(ϕCon_{2})) - (hCon_{2} * sin(ϕCon_{2})), 0, (hCon_{2} * cos(ϕCon_{2})) + (kCon_{2} * sin(ϕCon_{2})))
jCon_{2} = Rotate(Surface[((kCon_{2} - ((v * rcCon_{2}) * cos((u * bet_{2} / 2)))) * cos(ϕCon_{2})) - (((1 - v) * hCon_{2}) * sin(ϕCon_{2})), ((v * rcCon_{2}) * sin((u * bet_{2} / 2))), (((1 - v) * hCon_{2}) * cos(ϕCon_{2})) + ((kCon_{2} - ((v * rcCon_{2}) * cos((u * bet_{2} / 2)))) * sin(ϕCon_{2})), u, -1, 1, v, 0, 1], -90°)
nCon_{2} = Segment(Rotate[KE_{2}, -90°], Rotate[KF_{2}, -90°])
pCon_{2} = Segment(Rotate[KD_{2}, -90°], Rotate[KF_{2}, -90°])
basehint = Rotate(CurveCartesian[((kCon_{2} - (rcCon_{2} * cos((u * bet_{2} / 2)))) * cos(ϕCon_{2})), (rcCon_{2} * sin((u * bet_{2} / 2))), ((kCon_{2} - (rcCon_{2} * cos((u * bet_{2} / 2)))) * sin(ϕCon_{2})), u, -1, 1], -90°)
tabOrder: {textQuestion_{1}, InputBoxA, textUnits, btnValidate, textHint, textSolution, text1_{1}, tCil2_{1}, btnFormula, btnNew}
speed: 5

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: expandSegment
expandSegment(A,B,pixelGap,Corner1,Corner3,Corner5)
Input: A, B, pixelGap, Corner1, Corner3, Corner5
Output: newPoly

distanceX: (pixelGap / x(Corner5) * (x(Corner3) - x(Corner1)))
distanceY: (pixelGap / y(Corner5) * (y(Corner3) - y(Corner1)))
pointGap: distanceX
xyScale: distanceY / distanceX
A: (0, 0)
vecAB: B - A
pVec: (20 * UnitVector[(((-y(vecAB))) / xyScale, (x(vecAB) * xyScale))])
pVecAngle = Angle(xAxis, Line[(0, 0), pVec])
realAngle = If(pVecAngle ≟ pi / 2 ∨ pVecAngle ≟ (3 * pi / 2), pVecAngle, atand(tan(pVecAngle) / xyScale))
curveFunction = CurveCartesian((pointGap * cos(u)), ((pointGap * xyScale) * sin(u)), u, 0, (2 * pi))
K: curveFunction(realAngle)
vSpace = Vector(K)
allPoints: {A + vSpace, A - vSpace, B - vSpace, B + vSpace}
newPoly = Polygon(allPoints)

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)