Upload a1

1 files changed, 0 insertions, 156 deletions

diff --git a/worksheets/a2_carsoccer.md b/worksheets/a2_carsoccer.md
deleted file mode 100644
index 95170c4..0000000
--- a/worksheets/a2_carsoccer.md
+++ /dev/null
@@ -1,156 +0,0 @@
-# Assignment 2 (Car Soccer) Worksheet
-
-## Definitions
-
-Use the following C++ style pseudocode definitions for Q1 and Q2:
-
-```
-/* Use this Point3 class to store x,y,z values that define a mathematical
- * point (i.e., a position) in 3-space.
- */
-class Point3 {
-    float x;
-    float y;
-    float z;
-};
-
-/* Use this Vector3 class to store x,y,z values that define a vector in
- * 3-space.  Remember, mathematically, a vector is quite different than
- * a point.  It has a direction and a magnitude but no position!
- * For vectors it is often useful to be able to compute the length,
- * also known as the magnitude, of the vector.
- */
-class Vector3  {
-    float x;
-    float y;
-    float z;
-    
-    // returns the length (i.e., magnitude) of the vector
-    float Length() {
-        return sqrt(x*x + y*y + z*z);
-    }
-};
-
-
-/* In C++ and other languages we can define operators so we can use
- * the +, -, =, *, / operations on custom classes.  Like many graphics
- * libraries, this is what MinGfx does to make it easy to work with
- * points and vectors in code.  For example, recall from class that
- * if we have a point A (Coffman Union) and we add a vector (direction
- * and magnitude) to this, we arrive at a new point B (e.g., Murphy Hall).
- * Conceptually, a point + a vector = a new point.  Mathematically, it
- * does not make sense to add two points, but it does make sense to 
- * subtract two points.  The "difference" between the Murphy and Coffman 
- * points is a vector that tells us the direction and magnitude we would
- * need to walk from Coffman to get to Murphy.  Here's how we can write
- * that in code using Point3, Vector3, and operators like + and -.
- *
- *   Point3 murphy = Point3(5, 8, 0);
- *   Point3 coffman = Point3(4, 6, 0);
- *   Vector3 toMurphy = murphy - coffman; 
- *
- *   // or, if we were given coffman and toMurphy we could find
- *   // the point "murphy" by starting at point "coffman" and adding
- *   // the vector "toMurphy".
- *   Point3 murphy2 = coffman + toMurhpy; 
- *
- * The code that defines these opertors looks something like this:
-*/
-
-// a point + a vector = a new point
-Point3 operator+(Point3 p, Vector3 v) { 
-   return Point3(p.x + v.x, p.y + v.y, p.z + v.z); 
-}
-
-// a point - a point = a vector 
-// the dir and magnitude needed to go from point point B to point A
-Vector3 operator-(Point3 A, Point3 B) {
-    return Vector3(A.x - B.x, A.y - B.y, A.z - B.z);
-}
-
-// a vector * a scalar = a new vector with scaled magnitude
-Vector3 operator*(Vector3 v, float s) {
-    return Vector3(v.x * s, v.y * s, v.z * s);
-}
-
-
-
-/* Given all these tools, we can define additional classes for geometries
- * that are useful in graphics.  For example, we can represent a sphere
- * using a Point3 for the position of the center point of the sphere and
- * a float for the sphere's radius.
- */
-class Sphere {
-    Point3 position;
-    float radius;
-};
-```
-
-## Q1: Eulerian Integration
-
-In computer graphics and animation, there are many forms of integration that
-are used. For simple physics models like we have in Car Soccer, Eulerian
-Integration is good enough. Eulerian Integration uses velocity and position
-information from the current frame, and the elapsed time to produce a position
-for the next frame. Write pseudocode for determining the position of the sphere in the
-next frame:
-
-*Hint: think back to the motion equations from introductory physics. Or, look
-around in the assignment handout.*
-
-```
-Vector3 velocity = Vector3(1.0, 1.0, 1.0);
-float dt = 20; // milliseconds
-
-Sphere s = Sphere {
-    position: Point3(0.0, 0.0, 0.0),
-    radius: 5.0,
-};
-
-s.position = /* --- Fill in the next frame position computation here --- */
-```
-
-
-
-## Q2: Sphere Intersection
-
-In this assignment, you will need to test intersections between spheres and
-other objects. Using the information contained within each sphere class,
-write pseudocode to determine whether or not two spheres are intersecting
-(which you can use for car/ball intersections):
-
-```
-bool sphereIntersection(Sphere s1, Sphere s2) {
-    /* --- Fill in your sphere intersection code here --- */
-    
-
-}
-```
-
-To check that your intersections work, try working through the math by hand for the
-following two cases.  You can write out the math on a scrap piece of paper.   You do
-not need to include that detail in this worksheet.  But, do change the lines below where
-it says "Fill in expected output" to indicate whether True or False would be returned:
-
-```
-Sphere s1 = Sphere {
-    position: Point3(0.0, 1.0, 0.0),
-    radius: 1.0,
-};
-
-Sphere s2 = Sphere {
-    position: Point3(3.0, 0.0, 0.0),
-    radius: 1.0,
-};
-
-Sphere s3 = Sphere {
-    position: Point3(1.0, 1.0, 0.0),
-    radius: 2.0,
-};
-
-print(sphereIntersection(s1, s2));
-/* --- Fill in expected output (True or False) --- */
-
-print(sphereIntersection(s1, s3));
-/* --- Fill in expected output (True or False) --- */
-```