Example #1
0
        public bool IsCollideableWith(Mesh2D target)
        {
            float d1 = centerOfGravity.SquaredDistanceTo(target.centerOfGravity);
            float d2 = (boundingRadiusSquared + target.boundingRadiusSquared);

            return(d1 < d2 * 4F);
        }
Example #2
0
        public void CreatePaddle(Mesh2D mesh)
        {
            Attributes a = mesh.Attributes;

            a["name"]  = "paddle";
            mesh.Color = Color.White;
        }
Example #3
0
        public void CreateWall(Mesh2D mesh)
        {
            Attributes a = mesh.Attributes;

            a["name"]  = "wall";
            mesh.Color = wc;
        }
Example #4
0
        public static Mesh2D Ball(float radius, P3 position, V3 velocity)
        {
            Mesh2D c = Mesh2D.Circle(radius, 16, position);

            c.Velocity = velocity;
            return(c);
        }
Example #5
0
        public bool IsCollideableWith(Mesh2D target)
        {
            float d1  = MidPoint().SquaredDistanceTo(target.CenterOfGravity);
            float rad = Length() / 2F;
            float d2  = (rad * rad + target.BoundingRadiusSquared);

            return(d1 < d2);
        }
Example #6
0
        public void CreateBall(Mesh2D mesh)
        {
            Attributes a = mesh.Attributes;

            a["projectile"] = true;
            a["name"]       = "ball";
            mesh.Color      = Color.Red;
        }
Example #7
0
        public void AddVec(Edge e, Color c)
        {
            Mesh2D sideV = Mesh2D.Vector(e, 0.002F);

            sideV.Color = c;
            //System.Threading.Thread.Sleep(10);
            AddMesh("vectors", sideV);
        }
Example #8
0
        public Level(Game parent, string[][] data)
        {
            Game  = parent;
            World = new World(this);
            buildHpColors();
            this.data = data;
            float pwid, ph; int nrows, ncols;

            Width        = 1.0F;
            Height       = 0.625F;
            nrows        = data.Length;
            ncols        = data[0].Length;
            BrickWidth   = Width / (float)ncols;           //100%
            BrickHeight  = Height / (float)nrows;          //100%
            pwid         = Width * 0.1F; ph = Height * 0.15F;
            Paddle       = Mesh2D.Paddle(new P3(-pwid / 2F, -ph / 2.0F, 0), pwid, ph, new P3(Width / 2.0F, Height - ph / 2F, 0), 0.98f);
            Paddle.Color = Color.Blue;
            CreatePaddle(Paddle);
            World.AddMesh("paddles", Paddle);
            PaddleStop = BrickWidth + pwid / 2F;
            World.Meshes.Add("vectors", new List <Mesh2D>());
            P3 ballStart = new P3(Width / 2F, Height - BrickHeight, 0);
            V3 vel       = new V3(new P3((float)r.NextDouble() * Width, Height / 2F, 0), ballStart);       //set random init direction

            vel.Magnitude = 1.0F;
            Ball          = Mesh2D.Ball(Width / 200.0F, ballStart, vel);
            CreateBall(Ball);
            World.AddMesh("balls", Ball);
            string type;
            Mesh2D m;

            for (int i = 0; i < data.Length; i++)
            {
                for (int j = 0; j < data[i].Length; j++)
                {
                    m    = Mesh2D.Rectangle(P3.Zero, BrickWidth, BrickHeight, P3.New(BrickWidth * j, BrickHeight * i));
                    type = data[i][j];
                    if (type == "W")
                    {
                        CreateWall(m);
                        World.AddMesh("walls", m);
                        continue;
                    }
                    int hp = int.Parse(type);
                    if (hp == 0)
                    {
                        continue;
                    }
                    CreateBrick(m, hp);
                    BricksLeft++;
                    World.AddMesh("bricks", m);
                }
            }
        }
Example #9
0
 public void AddMesh(string key, Mesh2D mesh)
 {
     if (Meshes.ContainsKey(key))
     {
         Meshes[key].Add(mesh);
     }
     else
     {
         Meshes.Add(key, new List <Mesh2D>(new Mesh2D[] { mesh }));
     }
 }
Example #10
0
        List <Mesh2D> GetCollideable(Mesh2D target, List <Mesh2D> candidates)
        {
            List <Mesh2D> found = new List <Mesh2D>();

            for (int i = 0; i < candidates.Count; i++)
            {
                if (target.IsCollideableWith(candidates[i]))
                {
                    found.Add(candidates[i]);
                }
            }
            return(found);
        }
Example #11
0
        List <Edge> GetCollideable(Mesh2D projectile, List <Edge> candidates)
        {
            List <Edge> found = new List <Edge>();

            for (int i = 0; i < candidates.Count; i++)
            {
                if (candidates[i].IsCollideableWith(projectile))
                {
                    found.Add(candidates[i]);
                }
            }
            return(found);
        }
Example #12
0
        List <Mesh2D> GetCollidedMeshes(Mesh2D projectile, List <Mesh2D> collideable)
        {
            List <Mesh2D> results = new List <Mesh2D>();

            for (int i = 0; i < collideable.Count; i++)
            {
                if (projectile.Intersects(collideable[i]))
                {
                    results.Add(collideable[i]);
                }
            }
            return(results);
        }
Example #13
0
        public bool Intersects(Mesh2D other)
        {
            int tec = other.edges.Count; P3 var;

            for (int i = 0; i < edges.Count; i++)
            {
                for (int j = 0; j < tec; j++)
                {
                    if (edges[i].IntersectsWith(other.edges[j], out var) == Edge.Result.Intersecting)
                    {
                        return(true);
                    }
                }
            }
            return(false);
        }
Example #14
0
        public static Mesh2D Vector(V3 direction, P3 position, float width)
        {
            P3[] vertices = new P3[3];
            V3   perp     = direction.Perpendicular2DLeftHanded();

            perp.Magnitude = width;
            V3 perp2 = perp.Clone().Flip();

            vertices[0] = direction.ToPoint();
            vertices[2] = perp.ToPoint();
            vertices[1] = perp2.ToPoint();
            Mesh2D c = new Mesh2D(vertices, position);

            c.Color = System.Drawing.Color.Magenta;
            return(c);
        }
Example #15
0
        public List <Edge> CollidesWith(Mesh2D other)
        {
            int         tec = other.edges.Count; P3 var;
            List <Edge> collided = new List <Edge>();

            for (int i = 0; i < edges.Count; i++)
            {
                for (int j = 0; j < tec; j++)
                {
                    if (edges[i].IntersectsWith(other.edges[j], out var) == Edge.Result.Intersecting)
                    {
                        edges[i].Tag = var;
                        collided.Add(edges[i]);
                    }
                }
            }
            return(collided);
        }
Example #16
0
        public void CreateBrick(Mesh2D mesh, int hitpoints)
        {
            Attributes a = mesh.Attributes;

            a["hitpoints"]   = hitpoints;
            a["destroyable"] = true;
            a["name"]        = "brick";
            if (hitpoints == 1)
            {
                mesh.Color = RandomBlue();
            }
            else if (hitpoints == 2)
            {
                mesh.Color = RandomGreen();
            }
            else
            {
                mesh.Color = RandomRed();
            }
        }
Example #17
0
        public Edge GetCollisionEdge(Mesh2D next, Mesh2D projectile, List <Mesh2D> collided, out float distance)
        {
            //create rays leaving each vertex of the projectile in the direction of vel
            //intersect each edge with the target polygon edges and return the closest future bounce pos & deflection edge
            float rayLength = projectile.BoundingRadius * 5F + projectile.Position.DistanceTo(next.Position);
            V3    rayVel    = projectile.Velocity.UnitVector * rayLength;
            Dictionary <Edge, float> raysOut = new Dictionary <Edge, float>();          //we'll keep the min dist so far per ray in a dictionary
            Dictionary <Edge, float> raysIn  = new Dictionary <Edge, float>();
            Edge ray;

            for (int j = 0; j < projectile.Vertices.Length; j++)
            {
                ray = new Edge(projectile.Vertices[j] + rayVel, projectile.Vertices[j]);                //AddVec(ray, Color.Blue);
                if (!raysOut.ContainsKey(ray))
                {
                    raysOut.Add(ray, float.MaxValue);
                }
            }
            //for (int k = 0; k < collided.Count; k++) {
            //    for (int j = 0; j < collided[k].Vertices.Length; j++) {
            //        ray = new Edge(collided[k].Vertices[j] + rayVel.Clone().Flip(), collided[k].Vertices[j], collided[k]);
            //        if (!raysIn.ContainsKey(ray)) raysIn.Add(ray, float.MaxValue);//AddVec(ray, Color.Blue);
            //    }
            //}
            P3 isect;

            #region Projectile to Polygon
            float       d;       // iterate over each collided mesh edge and pick the closest intersection point (bounce pt)
            List <Edge> keys = new List <Edge>(raysOut.Keys);
            foreach (Edge edge in keys)
            {
                for (int k = 0; k < collided.Count; k++)
                {
                    for (int j = 0; j < collided[k].Edges.Length; j++)
                    {
                        if (edge.IntersectsWith(collided[k].Edges[j], out isect) == Edge.Result.Intersecting)
                        {
                            d = edge.Tail.DistanceTo(isect);
                            if (d < raysOut[edge])
                            {
                                edge.Tag      = collided[k].Edges[j];
                                raysOut[edge] = d;
                            }
                        }
                    }
                }
            }
            d = float.MaxValue; Edge closest = null;
            foreach (Edge edge in keys)
            {
                if (raysOut[edge] < d)
                {
                    d       = raysOut[edge];
                    closest = edge;
                }
            }
            #endregion
            //float d2;
            //keys = new List<Edge>(raysIn.Keys);
            //foreach (Edge edge in keys) {
            //    for (int j = 0; j < projectile.Edges.Length; j++) {
            //        if (edge.IntersectsWith(projectile.Edges[j], out isect) == Edge.Result.Intersecting) {
            //            d2 = edge.Tail.DistanceTo(isect);
            //            if (d2 < raysIn[edge]) {
            //                raysIn[edge] = d2; //this is useless for now since we don't know what edges the vertex is attached to
            //            }
            //        }
            //    }
            //}
            //d2 = d;
            //foreach (Edge edge in keys) {
            //    if (raysIn[edge] < d2) {
            //        d2 = raysIn[edge];
            //    }
            //}
            distance = d;
            return((Edge)closest.Tag);
        }
Example #18
0
 public Edge(P3 head, P3 tail, Mesh2D parent)
 {
     Head = head; Tail = tail; this.Parent = parent;
 }
Example #19
0
        //http://www.gamedev.net/reference/articles/article1026.asp
        void collideWithWorld(Mesh2D projectile, float deltaTimeInSec)
        {
            P3 sourcePoint    = projectile.Position;
            V3 velocityVector = projectile.Velocity.Clone() * deltaTimeInSec;
            // How far do we need to go?
            float distanceToTravel = velocityVector.Magnitude;             //length of velocityVector;

            // Do we need to bother?
            if (distanceToTravel < float.Epsilon)
            {
                return;
            }
            // What's our destination?
            P3 destinationPoint = sourcePoint + velocityVector;
            // Whom might we collide with?
            List <Mesh2D> potentialColliders = null;          //= GetObstacles(projectile);

            // If there are none, we can safely move to the destination and bail
            if (potentialColliders.Count == 0)
            {
                projectile.MoveNext(deltaTimeInSec);
                return;
            }
            // Determine the nearest collider from the list potentialColliders
            bool   firstTimeThrough                = true;
            float  nearestDistance                 = -1.0F;
            Mesh2D nearestCollider                 = null;
            P3     nearestIntersectionPoint        = null;
            P3     nearestPolygonIntersectionPoint = null;

            for (int i = 0; i < potentialColliders.Count; i++)
            {
                // Plane origin/normal
                P3 pOrigin = potentialColliders[i].Vertices[0];                                  //any vertex from the current polygon;
                V3 pNormal = potentialColliders[i].Edges[0].GetNormal2DRightHanded().UnitVector; //surface normal from the current polygon;
                // Determine the distance from the plane to the source
                float pDist = intersect(sourcePoint, -pNormal, pOrigin, pNormal);
                //P3 sphereIntersectionPoint;
                P3 planeIntersectionPoint;
                // The radius of the ellipsoid (in the direction of pNormal)
                //V3 directionalRadius = -pNormal * new V3(projectile.BoundingRadius, projectile.BoundingRadius, 0);
                float radius = projectile.BoundingRadius;                 //directionalRadius.Magnitude;
                // Is the plane embedded?
                if (Math.Abs(pDist) <= radius)
                {
                    // Calculate the plane intersection point
                    V3 pN = -pNormal;
                    pN.Magnitude           = pDist;           //-pNormal with length set to pDist
                    planeIntersectionPoint = sourcePoint + pN;
                }
                else
                {
                    // Calculate the ellipsoid intersection point
                    V3 pN = -pNormal;
                    pN.Magnitude = radius;                     //-pNormal with length set to radius
                    P3 ellipsoidIntersectionPoint = sourcePoint + pN;
                    // Calculate the plane intersection point
                    //Ray    ray(sphereIntersectionPoint, Velocity);
                    float tt = intersect(ellipsoidIntersectionPoint, velocityVector, pOrigin, pNormal);
                    // Calculate the plane intersection point
                    V3 VV = velocityVector.Clone();
                    VV.Magnitude           = tt;           // velocityVector with length set to t;
                    planeIntersectionPoint = ellipsoidIntersectionPoint + VV;
                }
                // Unless otherwise stated, our polygonIntersectionPoint is the
                // same point as planeIntersectionPoint

                P3 polygonIntersectionPoint = planeIntersectionPoint.Clone();
                // So… are they the same?
                if (!potentialColliders[i].Contains(planeIntersectionPoint))                                       //planeIntersectionPoint is not within the current polygon)
                {
                    polygonIntersectionPoint = P3.Closest(potentialColliders[i].Vertices, planeIntersectionPoint); //nearest point on polygon's perimeter to planeIntersectionPoint;
                }
                // Invert the velocity vector
                V3 negativeVelocityVector = -velocityVector;
                // Using the polygonIntersectionPoint, we need to reverse-intersect
                // with the ellipsoid
                float t = intersectSphere(polygonIntersectionPoint, negativeVelocityVector, sourcePoint, projectile.BoundingRadius);
                // Was there an intersection with the ellipsoid?
                if (t >= 0.0F && t <= distanceToTravel)
                {
                    V3 VV = negativeVelocityVector.Clone();                     //negativeVelocityVector with length set to t;
                    VV.Magnitude = t;
                    // Where did we intersect the ellipsoid?
                    V3 intersectionPoint = (polygonIntersectionPoint + VV).ToV3();
                    // Closest intersection thus far?
                    if (firstTimeThrough || t < nearestDistance)
                    {
                        nearestDistance                 = t;
                        nearestCollider                 = potentialColliders[i];
                        nearestIntersectionPoint        = intersectionPoint;
                        nearestPolygonIntersectionPoint = polygonIntersectionPoint;
                        firstTimeThrough                = false;
                    }
                }
            }
            // If we never found a collision, we can safely move to the destination
            // and bail
            if (firstTimeThrough)
            {
                projectile.MoveNext(deltaTimeInSec);
                return;
            }
            // Move to the nearest collision
            V3 V = velocityVector.Clone();             //velocityVector with length set to (nearestDistance - EPSILON);

            V.Magnitude = nearestDistance;
            sourcePoint = sourcePoint + V;

            // Determine the sliding plane (we do this now, because we're about to
            // change sourcePoint)
            P3 slidePlaneOrigin = nearestPolygonIntersectionPoint;
            V3 slidePlaneNormal = new V3(nearestPolygonIntersectionPoint, sourcePoint);
            // We now project the destination point onto the sliding plane
            float time = intersect(destinationPoint, slidePlaneNormal, slidePlaneOrigin, slidePlaneNormal);
            //Set length of slidePlaneNormal to time;
            V3 destinationProjectionNormal = slidePlaneNormal;
            P3 newDestinationPoint         = destinationPoint + destinationProjectionNormal;
            // Generate the slide vector, which will become our new velocity vector
            // for the next iteration
            V3 newVelocityVector = new V3(newDestinationPoint, nearestPolygonIntersectionPoint);

            // Recursively slide (without adding gravity)
            projectile.Position = sourcePoint;
            projectile.Velocity = newVelocityVector;
            collideWithWorld(projectile, deltaTimeInSec);
        }
Example #20
0
 public void RemoveMesh(string key, Mesh2D mesh)
 {
     Meshes[key].Remove(mesh);
 }
Example #21
0
 public Mesh2D Clone()
 {
     trash          = new Mesh2D(P3.Clone(relativeVertices), position.Clone());
     trash.velocity = this.velocity.Clone();
     return(trash);
 }