[baavgai]

Final C++ version. With the idea of reusable code, broken up a little with namespace.

Spoiler

#ifndef PLANE_H
#define PLANE_H

#include <iostream>

namespace Plane {
	const double PI = 3.14159265;

	struct Point {
		double x, y;
		Point();
		Point(double x, double y);
	
		bool operator==(const Point &) const;
		bool operator!=(const Point &) const;
		Point operator+(const Point &) const;
		Point operator-(const Point &) const;
		Point operator/(const Point &) const; // midpoint
		Point operator/(double) const;
	
		Point & operator+=(const Point &);
		Point & operator-=(const Point &);
		Point & operator/=(const Point &);
		Point & operator/=(double);
		Point operator-() const;
	};


	struct Vector : public Point {
		Vector();
		Vector(const Point &);
		Vector(double magnitude, double angle, bool useRadians = false);
		double magnitude() const;
		double radians() const;
		double degrees() const;
		Vector normalise() const;
		Point apply(const Point &);
		// increase magnitude
		Vector operator*(double) const;
		Vector &operator*=(double);
	};



	struct BoundVector : public Vector {
		Point origin;
		BoundVector();
		BoundVector(const Vector &, const Point &);
		BoundVector& operator++();
		void operator++ (int);
		Point getIntersect(const Vector &) const;
	};

}

std::ostream &operator<<(std::ostream &, const Plane::Point &);
std::ostream &operator<<(std::ostream &, const Plane::Vector &);
std::ostream &operator<<(std::ostream &, const Plane::BoundVector &);

#endif

#include <iostream>
#include <cmath>
#include "plane.h"

using namespace std;
using namespace Plane;

Point::Point() : x(0), y(0) { }
Point::Point(double _x, double _y) : x(_x), y(_y) { }
bool Point::operator==(const Point &p) const { return x==p.x && y==p.y; }
bool Point::operator!=(const Point &p) const { return !(*this==p); }

Point Point::operator+(const Point &pt) const { return Point(x+pt.x, y+pt.y); }
Point Point::operator-(const Point &pt) const { return Point(x-pt.x, y-pt.y); }
Point Point::operator/(const Point &pt) const { return (operator+(pt)/2.0); }
Point Point::operator/(double n) const { return Point(x/n, y/n); }

Point &Point::operator+=(const Point &pt) { return (*this = operator+(pt)); }
Point &Point::operator-=(const Point &pt) { return (*this = operator-(pt)); } 
Point &Point::operator/=(const Point &pt) { return (*this = operator/(pt)); }  
Point &Point::operator/=(double n) { return (*this = operator/(n)); }  
Point Point::operator-() const { return Point(-x, -y); } 

std::ostream &operator<<(std::ostream &out, const Point &item) {
	out << '(' << item.x << ',' << item.y << ')'; 
	return out;
}


Vector::Vector() : Point() { }
Vector::Vector(const Point &pt) : Point(pt) { }
Vector::Vector(double magnitude, double angle, bool useRadians) {
	double rad = useRadians ? angle : angle * PI / 180.0;
	x = magnitude * cos(rad);
	y = magnitude * sin(rad);
}

double Vector::magnitude() const { return sqrt(x*x + y*y); }
double Vector::radians() const { 
	double rad = atan2(y,x);
	// negative angles suck
	return rad<0 ? 2*PI + rad : rad;
}
double Vector::degrees() const { return radians() * 180.0 / PI; }
Point Vector::apply(const Point &pt) { return pt + *this; }

Vector Vector::operator*(double n) const { return Vector(magnitude()*n, radians(), true); }
Vector &Vector::operator*=(double n) { return (*this = operator*(n)); }  


Vector Vector::normalise() const {
	double mag = magnitude();
	if (mag==1) { return *this; }
	return Vector(Point(x/mag,y/mag));
}

std::ostream &operator<<(std::ostream &out, const Vector &item) {
	out << '[' << item.x << ' ' << item.y << " : m=" << item.magnitude() << " deg=" << item.degrees() << "]"; 
	return out;
}


BoundVector::BoundVector() { }
BoundVector::BoundVector(const Vector &v, const Point &p) : Vector(v), origin(p) { }
BoundVector& BoundVector::operator++() { origin += *this; return *this; }
void BoundVector::operator++ (int) { operator++(); }


static void getABC(const Vector &v, double &a, double &b, double &c) {
	a = v.y;
	b = -v.x;
	c = 0;
}

static void getABC(const BoundVector &bv, double &a, double &b, double &c) {
	a = bv.y;
	b = -bv.x;
	c = a*bv.origin.x + b*bv.origin.y;
}


Point BoundVector::getIntersect(const Vector &v) const {
	double a1, b1 , c1;
	getABC(*this, a1, b1, c1);

	if (v.x==0) {
		return Point((c1 - (b1*v.y))/a1, v.y);
	} else if (v.y==0) {
		return Point(v.x, (c1 - (a1*v.x))/b1);
	} else {
		double a2, b2 , c2;
		getABC(v, a2, b2, c2);
		double det = a1*b2 - a2*b1;
		if(det == 0) { return Point(); }
		double x = (b2*c1 - b1*c2)/det;
		double y = (a1*c2 - a2*c1)/det;
		return Point(x,y);
	}

}

std::ostream &operator<<(std::ostream &out, const BoundVector &item) {
	out << '<'
		<< '[' << item.x << ' ' << item.y << ']'
		// << '(' << item.origin.x << ',' << item.origin.y << ')'
		<< item.origin
		<< '>'; 
	return out;
}

Test code can be fun. You can program in the abstract all day long, but actually using the code for something points out what you really need.

I needed a getIntersect. I'm not thrilled with it and it could be buggered, but it worked for the demo. The demo is common; bounce ball. Because, even showing all the methods doesn't really tell a student what they're good for.

This isn't the usual ricochet called bounce, we have gravity here. I think it's a pretty good test of any basic 2D physics framework.

#include <iostream>
#include "plane.h"

using namespace std;
using namespace Plane;

struct Ball : public BoundVector {
	double bounceConserve;
	Ball(double x, double y, const Vector &speed, double B)/> : BoundVector(speed, Point(x,y)), bounceConserve(B)/> { }
	void bounce() {
		Vector v(magnitude()*bounceConserve, -degrees());
		x = v.x;
		y = v.y;
	}
};




int main() {
	Point maxCorner(77, 21);
	const Vector gravity(Point(0, 1));
	const Vector ground(Point(0, maxCorner.y));

	Ball ball(0, maxCorner.y, Point(2, -7), 0.8);
	while(ball.origin.x<=maxCorner.x && ball.magnitude() > 1) {
		cout << ball.origin << endl;
		ball += gravity; 
		ball++; 
		if(ball.origin.y>maxCorner.y) { 
			ball.origin = ball.getIntersect(ground);
			ball.bounce();
		}
	}

	return 0;
}

Results:

(0,21)
(2,15)
(4,10)
(6,6)
(8,3)
(10,1)
(12,0)
(14,0)
(16,1)
(18,3)
(20,6)
(22,10)
(24,15)
(26,21)
(26,21)
(27.6,16.4)
(29.2,12.8)
(30.8,10.2)
(32.4,8.6)
(34,8)
(35.6,8.4)
(37.2,9.8)
(38.8,12.2)
(40.4,15.6)
(42,20)
(42.2963,21)
(43.5763,17.68)
(44.8563,15.36)
(46.1363,14.04)
(47.4163,13.72)
(48.6963,14.4)
(49.9763,16.08)
(51.2563,18.76)
(52.0354,21)
(53.0594,19.056)
(54.0834,18.112)
(55.1074,18.168)
(56.1314,19.224)
(57.016,21)
(57.8352,20.3552)

I know, hard to follow. But if you were to plot those pixels, you'd get something like:

            * *                                           
          *     *                                         
                                                          
        *         *                                       
                                                          
                                                          
      *             *                                     
                                  *                       
                                *  *                      
                                     *                    
    *                 *       *                           
                                                          
                             *        *                   
                                               *          
                                              * *         
  *                     *               *   *             
                           *                     *        
                                           *              
                                                   *  **  
                                          *          *  *
                                                         *
*                         *               *         *    *

If the screen wraps that too much, it will probably look like ass, but hopefully you get the idea.

[CasiOo]

I tried and implement it in C#.

I had a little fun with operator overloading funny what you can do with these!
== and != compares x and y
It is possible to write Vector2D v = new Point(x, y); (I don't think this will ever be useful )

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2 {
    public class Vector2D {
        private double x, y;

        private Vector2D(double x, double y) {
            this.x = x;
            this.y = y;
        }

        public static Vector2D Create(double x, double y) {
            return new Vector2D(x, y);
        }

        public static Vector2D CreateFromLengthAndAngel(double length, double angel) {
            double cosv = RadianToDegree(Math.Cos(DegreeToRadian(angel)));
            double sinv = RadianToDegree(Math.Sin(DegreeToRadian(angel)));
            return new Vector2D(length * cosv, length * sinv);
        }

        public static Vector2D CreateFromLine(double x1, double y1, double x2, double y2) {
            return new Vector2D(x2 - x1, y2 - y1);
        }

        private void Add(Vector2D other) {
            x += other.x;
            y += other.y;
        }

        private void Substract(Vector2D other) {
            x -= other.x;
            y -= other.y;
        }

        public double GetAngelBetweenVector(Vector2D other) {
            double cosv = GetDotProduct(other) / (GetLength() * other.GetLength());
            return RadianToDegree(Math.Acos(cosv));
        }

        public double GetDotProduct(Vector2D other) {
            return x * other.x + y * other.y;
        }

        public double GetLength() {
            return Math.Sqrt(Math.Pow(x, 2) + Math.Pow(y, 2));
        }

        public static implicit operator Vector2D(Point p) {
            return new Vector2D(p.X, p.Y);
        }

        public static Vector2D operator +(Vector2D v1, Vector2D v2) {
            v1.Add(v2);
            return v1;
        }

        public static Vector2D operator -(Vector2D v1, Vector2D v2) {
            v1.Substract(v2);
            return v1;
        }

        public static bool operator ==(Vector2D v1, Vector2D v2) {
            return v1.x == v2.x && v1.y == v2.y;
        }

        public static bool operator !=(Vector2D v1, Vector2D v2) {
            return !(v1.x == v2.x && v1.y == v2.y);
        }

        public override int GetHashCode() {
            return base.GetHashCode();
        }

        public override bool Equals(object obj) {
            if (obj is Vector2D) {
                Vector2D other = (Vector2D) obj;
                return x == other.x && y == other.y;
            }
            return base.Equals(obj);
        }

        public static double DegreeToRadian(double angel) {
            return Math.PI * (angel / 180);
        }

        public static double RadianToDegree(double angel) {
            return angel * (180 / Math.PI);
        }

        public double X {
            get { return x; }
        }

        public double Y {
            get { return y; }
        }
    }
}

Edit: forgot to add the + and - operators

This post has been edited by CasiOo: 25 September 2011 - 02:05 PM

[cfoley]

Quote

It is possible to write Vector2D v = new Point(x, y); (I don't think this will ever be useful )

Actually, that looks pretty cool to me. Overloading the assignment operator to make type conversion easier is something you cannot do in Java that I would fine useful sometimes.

[baavgai]

Why let the class based OO languages have all the fun? Time for some prototypes...

Spoiler

// to put this bluntly, Javascript inheritance really isn't
// pretending it exists only causes pain and suffering
// embrace the prototype
// this helps
function AddMethods(objDef, methods) {
	for(var k in methods) { 
		objDef.prototype[k] = methods[k];
	}
}

var Plane = (function() {
	var inst = {
		DegToRad : function(n) { return n * ( Math.PI / 180.0 ); },
		RadToDeg : function(n) { return n * ( 180.0 / Math.PI ); },
		VectorFromMagRad : function(magnitude, rad) {
			return new this.Vector(magnitude * Math.cos(rad), magnitude * Math.sin(rad) );
		},
		VectorFromMagDeg : function(magnitude, deg) {
			return this.VectorFromMagRad(magnitude, Plane.DegToRad(deg));
		},
		GetIntersect : function(v1, p1, v2, p2) {
			function getABC(v, p) {
				var abc = { a : v.y, b: -v.x };
				abc.c = abc.a*p.x + abc.b*p.y;
				return abc;
			}
			
			var abc1 = getABC(v1, p1);

			if (v2.x==0) {
				return new this.Point((abc1.c - (abc1.b*v2.y))/abc1.a, v2.y);
			} else if (v2.y==0) {
				return new this.Point(v2.x, (abc1.c - (abc1.a*v2.x))/abc1.B)/>;
			} else {
				var abc2 = getABC(v2, p2);
				var det = abc1.a*abc2.b - abc2.a*abc1.b;
				if(det == 0) { return new this.Point(0,0); }
				var x = (abc2.b*abc1.c - abc1.b*abc2.c)/det;
				var y = (abc1.a*abc3.c - abc2.a*abc1.c)/det;
				return new this.Point(x,y);
			}
		},
		Point : function(x,y) { this.x = x; this.y = y; },
		Vector : function(x, y) { this.x = x; this.y = y; },
		BoundVector : function(vector,origin) {
			this.x = vector.x;
			this.y = vector.y;
			this.origin = origin;
		},
	};
	
	AddMethods(inst.Point, {
		equals : function(pt) { return this.x==pt.x && this.y==pt.y; },
		add : function(pt) { this.x+=pt.x; this.y+=pt.y; },
		sub : function(pt) { this.x-=pt.x; this.y-=pt.y; },
		divPoint : function(pt) { this.add(pt); this.divNum(2.0); },
		divNum : function(n) { this.x/=n, this.y/=n; },
		neg : function() { this.x*=-1; this.y*=-1; },
		toString : function() { return "(" + this.x + "," + this.y + ")"; },
	});
	
	AddMethods(inst.Vector, inst.Point.prototype);
	
	AddMethods(inst.Vector, {
		magnitude : function() { return Math.sqrt(this.x*this.x + this.y*this.y); },
		radians : function() { 
			var rad = Math.atan2(this.y, this.x);
			return rad<0 ? 2*Math.PI + rad : rad;
		},
		degrees : function() {  return inst.RadToDeg(this.radians()); },
		toString : function() { return '[' + this.x + ' ' + this.y + " : m=" + this.magnitude() + " deg=" + this.degrees() + "]"; },
	});
	
	AddMethods(inst.BoundVector, inst.Vector.prototype);
	AddMethods(inst.BoundVector, {
		move : function() { this.origin = this.origin.add(this); },
		getIntersectVect : function(v) { return inst.GetIntersect(this, this.origin, v, {x:0,y:0}); },
		toString : function() { return '<[' + this.x + ' ' + this.y + ']' + this.origin + '>'; },
	});
	
	inst.Gravity = new inst.Vector(0, 1);

	return inst;
})();

Yes, it's Javascript. Why? Because HTML5 is gonna take over the world!

Ok, maybe not, but it does offer the importunity to share a demo with everyone. If your browser doesn't support HTML5... WTF is wrong with you, it's going to take over the world.

Anyway, enjoy the bouncy balls.

[ButchDean]

You're insane, baavgai!

[SixOfEleven]

He's right though. Development with in Microsoft's Metro for Windows 8 is will be done mostly with HTML 5 with Javascript from what I've seen. Thankfully my browser already supports HTML 5 so I'm good there.

[AdamSpeight2008]

Javascript and HTML5 isn't the only support language for Metro Style apps. They can be programmed with most of the .net languages, even C++ is supports. Thanks to the Windows RunTime.

This post has been edited by AdamSpeight2008: 28 September 2011 - 01:43 PM

[SixOfEleven]

Yes, though .NET and C++ are severely limited compared to pre-Metro. The whole Metro thing is more "web" style than "desktop" style in security features. It is much harder to access the local file system for instance. It was designed with tablets and other portable devices in mind. From what I've been seeing around the web Microsoft seems to be pushing HTML 5 over older technologies lately and they seem to be of the belief that it will replace older technologies.

[AdamSpeight2008]

MSDN: Building your first Windows Metro style app using C#, C++, or Visual Basic

Microsoft Visual Studio 11 Express for Windows Developer Preview (Needs to run on the Windows8 Developer Preview

Build 2011: Metro Style Application Video

This post has been edited by AdamSpeight2008: 28 September 2011 - 02:04 PM

[SixOfEleven]

Yes, I know about all of this. I'm just saying that Metro is a paradigm shift from old school programming methodology. First look at Visual Studio 11.

[Fib]

I'm already one step ahead of you! Here is my snippet I wrote just for DIC.

http://www.dreaminco...snippet5958.htm

[RSouthee]

I know this is an old topic but I was wondering if it would be better to have the 'x' and 'y' values as private members and use Get/Set accessors or let them be public.

[samirashafir]

A good approach to this would be to have a look at the SDL library. I'm not saying it's necessarily the best library for 2D games, but it's easy to get started with and the web is flooded with tutorials and open source code samples for simple homebrew 2D games written using SDL.