[stayscrisp]

Hey, this is the first in a series of challenges to help people learn some of the basics in game programming. We see a lot of beginners doing movement in this way:

float xspeed = 0;
float yspeed = 0;
float xpos = 0;
float ypos = 0;

player.xpos += xspeed;
player.ypos += yspeed;

// etc.

For a start it doesn't really look very nice. It also is not reusable, and you have to make it even more convoluted to do some of the more advanced math needed in games. The better alternative is to use vectors. Using vectors we can do movement something like this:

2DVector speed;
2DVector position;

player.position += player.speed;

You will probably have realised that this is going to require knowledge of overloaded operators among other things. This should be a great challenge and I look forward to seeing what people can come up with. Other functions that could be included are dot product, normalise etc.

Extra points for creating a template class so you can easily switch between ints, floats and doubles depending on how much precision you want. Use any language you want but C++ would be great Feel free to ask questions within this thread so we can all collaborate.

Happy coding!

[cfoley]

I'll enter this Java one I made for a game physics engine. I've done a few strange things. First, it is immutable which I guess sends alarm bells ringing for most game developers. I did it to see of Java can cope. Turns out it copes nicely. Second, I save the minimum state I have to. Every time you want an angle, it calculates it again. I did this to avoid the possibility of inconsistant states, and I'll only optimise if it ever becomes a bottleneck. Finally, there are no overloaded operators in Java but you will see things like add, subtract, multiply. Oh, and angles are in degrees. I like it that way.

Spoiler

package cfoley.bouncyBalls.physics;

import java.awt.geom.Point2D;

import cfoley.math.Trig;

/**
 * Represents a Vector in 2D coordinates.
 * */
public class Vect {
	private final static double DELTA = 0.000001;
	static final Vect zero = new Vect(0, 0);
	private final double x, y;

	public Vect(double x, double y) {
		this.x = x;
		this.y = y;
	}

	public Vect(Point2D point) {
		this.x = point.getX();
		this.y = point.getY();
	}

	final double  x()                     {return x;}
	final double  y()                     {return y;}
	final double  magnitude()             {return Math.sqrt(x*x + y*y);}
	final double  degrees()               {return Trig.getAngleFromOrigin(asPoint2D());}
	final Vect    add(Vect v)             {return new Vect(x+v.x, y+v.y);}
	
	public final Vect    subtract(Vect v)        {return new Vect(x-v.x, y-v.y);}
	public final Vect    multiply(double scalar) {return makePolar(scalar * magnitude(), degrees());}
	public final boolean isZero()                {return equals(zero);}
	public final Point2D asPoint2D()             {return new Point2D.Double(x, y);}

	final double  distance(Vect other)    {return Math.sqrt(distanceSquare(other));}

	final double distanceSquare(Vect other) {
		double dx = x - other.x;
		double dy = y - other.y;
		return dx*dx + dy*dy;
	}

	final Vect paralellComponent(Vect other) {
		if (other.isZero()) return zero;

		double otherDegrees = other.degrees();
		double degreesApart = otherDegrees - degrees();
		double newMagnitude = magnitude() * Trig.cos(degreesApart);
		return makePolar(newMagnitude, otherDegrees);
	}
	
	final Vect perpendicularComponent(Vect other) {
		return other.subtract(paralellComponent(other));
	}

	/**
	 * Returns the angle between this vector and other
	 * in the range 1-360 going clockwise from this angle.
	 */
	double angleTo(Vect other) {
		double angle = other.degrees() - degrees();
		if (angle < 0) angle += 360; 
		return angle;
	}

	@Override
	public final boolean equals(Object other) {
		if (other == null) return false;
		if (this == other) return true;
		if (!other.getClass().isInstance(other))
			return false;

		Vect v = (Vect) other;
		boolean isXSame = Math.abs(x - v.x) < DELTA;
		boolean isYSame = Math.abs(y - v.y) < DELTA;
		return isXSame && isYSame;
	}

	@Override
	public final int hashCode() {
		int hash = 1;
		final int prime = 31;
		hash *= (prime * x);
		hash *= (prime * y);
		return hash;
	}

	@Override 
	public final String toString() {
		return String.format("(%f, %f)", x, y);
	}

	static Vect makePolar(double magnitude, double degrees) {
		double x =  magnitude * Trig.sin(degrees);
		double y = -magnitude * Trig.cos(degrees);
		return new Vect(x, y);
	}

	/** Intended for use in the equation of motion v = u + at */
	final Vect update(double milis, Vect rateOfChange) {
		return update(milis, rateOfChange, zero);
	}

	/** Intended for use in the equation of motion s = s0 + ut + 0.5at^2 */
	final Vect update(double milis, Vect rateOfChange, Vect secondOrderRateOfChange) {
		double tSq = milis * milis;
		double newX = x + (rateOfChange.x() * milis) + (0.5 * secondOrderRateOfChange.x() * tSq);
		double newY = y + (rateOfChange.y() * milis) + (0.5 * secondOrderRateOfChange.y() * tSq);
		return new Vect(newX, newY);
	}	
}

And here is my Trig utility class that it uses. It's probably the only class I wrote 11 years ago that I still use today.

Spoiler

package cfoley.math;

import java.awt.geom.*;

/**
* Provides methods for common trig problems. All angles are measured in a
* clockwise ditection. 0 degrees is taken to be on a vertical line pointing to
* the top of the screen.
*/
public class Trig
{
	
	public static Point2D origin() {
		return new Point2D.Double(0, 0);
	}

  /**
  * Converts an angle in degrees to an angle in radians
  */
  public static double toRad( double deg )
    { return ( deg / 180 ) * Math.PI ; }

  /**
  * Converts an angle in degrees to an angle in radians
  */
  public static double toDeg( double rad )
    { return ( rad * 180 ) / Math.PI ; }

  /**
  * Returns the sine of an angle in degrees
  */
  public static double sin( double deg )
    { return Math.sin( toRad( deg ) ); }

  /**
  * Returns the cosine of an angle in degrees
  */
  public static double cos( double deg )
    { return Math.cos( toRad( deg ) ); }

  /**
  * Returns the tangent of an angle in degrees
  */
  public static double tan( double deg )
    { return Math.tan( toRad( deg ) ); }

  /**
  * Returns the arc sine of an angle in degrees
  */
  public static double asin( double deg )
    { return toDeg( Math.asin( deg ) ); }

  /**
  * Returns the arc cosine of an angle in degrees
  */
  public static double acos( double deg )
    { return toDeg( Math.acos( deg ) ); }

  /**
  * Returns the arc tangent of an angle in degrees
  */
  public static double atan( double deg )
    { return toDeg( Math.atan( deg ) ); }

  /**
  * Returns the angle between 0 degrees and the point specified. The origin is
  * taken as specified.
  */
  public static double getAngle( Point2D origin, Point2D measureTo )
    {
    final double dx = measureTo.getX() - origin.getX();
    final double dy = - ( measureTo.getY() - origin.getY() ); // -ve because of coords
    final double length = Math.sqrt( Math.pow(dx,2) + Math.pow(dy,2) );
    
    if ( length == 0 ) return 0.0;
    
    final double angle = Math.abs( asin( dx/length ) );
    
    if      (dx>=0 && dy >=0) return angle;
    else if (dx>=0 && dy <=0) return 180 - angle;
    else if (dx<=0 && dy <=0) return 180 + angle;
    else if (dx<=0 && dy >=0) return 360 - angle;
    throw new Assertionerror();
    } 
  
  public static double getAngleFromOrigin(Point2D measureTo) {
	  return getAngle(origin(), measureTo);
  }

  /**
  * Returns the coordinates of the point at the specified distance and angle
  * from the origin.
  */
  public static Point2D getPoint( Point2D origin, double distance, double deg )
    {
    double x = origin.getX() + distance * sin( deg );
    double y = origin.getY() - distance * cos( deg );
    return new Point2D.Double( x, y );
    }

  /**
  * Returns the destination of a point which is rotated around the origin by a
  * specified angle.
  */
  public static Point2D rotateAboutCenter(
                                      Point2D origin, Point2D from, double deg )
    {
    // distance
    double dxSquared = Math.pow((from.getX()-origin.getX()),2);
    double dySquared = Math.pow((from.getY()-origin.getY()),2);
    double dist = Math.sqrt( dxSquared + dySquared );

    // the rest
    double ang = getAngle( origin, from );
    double rotAng = ang + deg;
    return getPoint( origin, dist, rotAng );
    } 





}

[baavgai]

A lot of the fun of C++ is all the uber overloading...

Technically, a Vector would be both the position and the direction. Which got me to thinking that a ++ operator would be fun.

Here's the code:

Spoiler

#include <iostream>

struct VecDelta {
	int dx, dy;
	VecDelta();
	VecDelta(int dx, int dy);
	VecDelta operator-() const;
};

struct VecPos {
	int x, y;
	VecPos();
	VecPos(int x, int y);
	VecPos operator+(const VecDelta &);
	VecPos & operator+=(const VecDelta &);
	VecPos operator-(const VecDelta &);
	VecPos & operator-=(const VecDelta &);
};

struct Vec2D {
	VecPos pos;
	VecDelta delta;
	Vec2D();
	Vec2D(const VecPos &pos, const VecDelta &delta);
	Vec2D(int x, int y, int dx, int dy);
	Vec2D& operator++();
	void operator++ (int);
	Vec2D& operator--();
	void operator--(int);
};

std::ostream &operator<<(std::ostream &, const VecDelta &);
std::ostream &operator<<(std::ostream &, const VecPos &);
std::ostream &operator<<(std::ostream &, const Vec2D &);

using namespace std;

#define SHOW(v) cout << #v << " = " << v << endl

#define OP(o) cout << endl << #o << endl; o; SHOW(v); 

int main () {
	VecPos pos;
	VecDelta delta(1,1);
	SHOW(pos); 
	SHOW(delta);
	
	Vec2D v(pos, delta);
	SHOW(v); 
	OP(v++);
	OP(v--);
	OP(v=Vec2D(5,6,7,8));
	OP(v++);
	OP(v++);
	
	return 0;
}

VecDelta::VecDelta() : dx(0), dy(0) { }
VecDelta::VecDelta(int x, int y) : dx(x), dy(y) { }
VecDelta VecDelta::operator-() const { return VecDelta(-dx, -dy); } 

VecPos::VecPos() : x(0), y(0) { }
VecPos::VecPos(int _x, int _y) : x(_x), y(_y) { }
VecPos VecPos::operator+(const VecDelta &d) { return VecPos(x + d.dx, y + d.dy); }
VecPos & VecPos::operator+=(const VecDelta &d) { x += d.dx; y += d.dy; return *this; }
VecPos VecPos::operator-(const VecDelta &d) { return VecPos(x - d.dx, y - d.dy); }
VecPos & VecPos::operator-=(const VecDelta &d) { x -= d.dx; y -= d.dy; return *this; }

Vec2D::Vec2D() { }
Vec2D::Vec2D(const VecPos &p, const VecDelta &d) : pos(p), delta(d) { }
Vec2D::Vec2D(int x, int y, int dx, int dy) : pos(VecPos(x,y)), delta(VecDelta(dx,dy)) { }
Vec2D& Vec2D::operator++() { pos += delta; }
void Vec2D::operator++ (int) { operator++(); }
Vec2D& Vec2D::operator--() { pos -= delta; }
void Vec2D::operator--(int) { operator--(); }

std::ostream &operator<<(std::ostream &out, const VecDelta &item) { 
	out << '[' << item.dx << ',' << item.dy << ']'; 
	return out;
}

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

std::ostream &operator<<(std::ostream &out, const Vec2D &item) {
	out << '<' << item.pos << '-' << item.delta << '>'; 
	return out;
}

And the sample output, to show how much fun that ++ operator can be:

pos = (0,0)
delta = [1,1]
v = <(0,0)-[1,1]>

v++
v = <(1,1)-[1,1]>

v--
v = <(0,0)-[1,1]>

v=Vec2D(5,6,7,8)
v = <(5,6)-[7,8]>

v++
v = <(12,14)-[7,8]>

v++
v = <(19,22)-[7,8]>

I'll get you a templated one, maybe. This was just amusing.

[Shane Hudson]

I am not sure if I will have time to give this a go, but will be interesting to see what people come up with. I have always done:

var velocity = 10;
var direction = 'x';

if (direction == 'x')
{
   player.x += velocity;
}
else
{
   player.y += velocity;
}

Which quite frankly is dreadful!

[ishkabible]

ill defiantly do this when i got home, im gonna make a normal method to i think

[AdamSpeight2008]

I think there already is Vector class in the Framework, but I've created my own.

Spoiler

Option Strict On

<ComponentModel.ImmutableObject(True)>
Public Class Vector2D_Dbl
  Protected m_X As Double
  Protected m_Y As Double

  Public ReadOnly Property X As Double
    Get
      Return m_X
    End Get
  End Property
  Public ReadOnly Property Y As Double
    Get
      Return m_Y
    End Get
  End Property

  Public Sub New(ByVal x As Double, ByVal y As Double)
    Me.m_X = x
    Me.m_Y = y
  End Sub

  Shared Operator -(ByVal v1 As Vector2D_Dbl, ByVal v2 As Vector2D_Dbl) As Vector2D_Dbl
    Return New Vector2D_Dbl(v1.X - v2.X, v1.Y - v2.Y)
  End Operator

  Shared Operator +(ByVal v1 As Vector2D_Dbl, ByVal v2 As Vector2D_Dbl) As Vector2D_Dbl
    Return New Vector2D_Dbl(v1.X + v2.X, v1.Y + v2.Y)
  End Operator

  Public Overrides Function ToString() As String
    Return String.Format("({0}, {1})", X, Y)
  End Function
End Class

Option Strict On

<ComponentModel.ImmutableObject(True)>
Public Class Vector2D_Int
  Protected m_X As Integer
  Protected m_Y As Integer

  Public ReadOnly Property X As Integer
    Get
      Return m_X
    End Get
  End Property
  Public ReadOnly Property Y As Integer
    Get
      Return m_Y
    End Get
  End Property

  Public Sub New(ByVal x As Integer, ByVal y As Integer)
    Me.m_X = x
    Me.m_Y = y
  End Sub

  Shared Operator -(ByVal position As Vector2D_Int, ByVal delta As Vector2D_Int) As Vector2D_Int
    Return New Vector2D_Int(position.X - delta.X, position.Y - delta.Y)
  End Operator

  Shared Operator +(ByVal position As Vector2D_Int, ByVal delta As Vector2D_Int) As Vector2D_Int
    Return New Vector2D_Int(position.X + delta.X, position.Y + delta.Y)
  End Operator

  Public Overrides Function ToString() As String
    Return String.Format("({0}, {1})", X, Y)
  End Function
End Class

Left for the other to implement DotProduct (as Extension Methods)

Install with NuGet: Vector2D

[stayscrisp]

Shane Hudson, on 22 September 2011 - 04:53 PM, said:

I am not sure if I will have time to give this a go, but will be interesting to see what people come up with. I have always done:

var velocity = 10;
var direction = 'x';

if (direction == 'x')
{
   player.x += velocity;
}
else
{
   player.y += velocity;
}

Which quite frankly is dreadful!

Ouch! My eyes!

[ButchDean]

Look out for speed-critical sections as well in your code. If using C++ a very common method for finding the appropriate function calls for applying your implementations to various types and other situations where you can have naming conflicts would be to make use of namespaces:

namespace Vector
{
    class Vector2D
    {
       // ...
    }
}

This could also be manipulated in such a way to get around using templates which are generally a big no-no in any speed-critical section of code.

I'm also seeing a fear of callback functionality that will drastically improve the flexibility of your implementations. And last but not least, let's not forget the use of design patterns like singleton (as always suggested) to keep track of your various instances.

Enjoy!

[Viske]

Well, here's my (admittedly, horrible) attempt at a generic Vector class using Java. Was good to brush up on my maths, I'd forgotten a lot of it.

public class Vector<T extends Number> {
	private T x;
	private T y;
	
	public Vector(T x, T y) {
		this.x = x;
		this.y = y;
	}
	
	public T getX() {
		return x;
	}
	
	public T getY() {
		return y;
	}
	
	public double getMagnitude() {
		return Math.sqrt(x.doubleValue() * x.doubleValue() + y.doubleValue() * y.doubleValue());
	}
	
	public double getDistance(Vector vect) {
		double dx = (x.doubleValue() - vect.getX().doubleValue());
		double dy = (y.doubleValue() - vect.getY().doubleValue());
		return Math.sqrt(dx*dx + dy*dy);
	}
	
	public Vector<T> normalise() {
		if (getMagnitude() != 1) {
			return new Vector(x.doubleValue() / getMagnitude(),
					          y.doubleValue() / getMagnitude());
		}
		else
			return this);
	}
	
	public boolean equals(Object vect) {
		if (vect == null)
			return false;
		if (this == vect)
			return true;
			
		Vector temp = (Vector) vect;
		return (x.doubleValue() == temp.getX().doubleValue()) && (y.doubleValue() == temp.getY().doubleValue());
	}
	
	public double dotProduct(Vector vect) {
		return (x.doubleValue() * vect.getX().doubleValue() +
				y.doubleValue() * vect.getY().doubleValue());
	}
	public double dotProduct(Vector vect, Vector other) {
		return (vect.getX().doubleValue() * other.getX().doubleValue() +
				vect.getY().doubleValue() * other.getY().doubleValue());
	}
	
	public double getAngle(Vector vect) {
		return Math.acos(dotProduct(this.normalise(), vect.normalise()));
	}
	
	public Vector<T> subtract(Vector<T> vect) {
		if (vect.getX() instanceof Double) {
			return new Vector(x.doubleValue() - vect.getX().doubleValue(),
					y.doubleValue() - vect.getY().doubleValue());
		}
		else if (vect.getY() instanceof Float) {
			return new Vector(x.floatValue() - vect.getX().floatValue(),
					y.floatValue() - vect.getY().floatValue());
		}
		else {
			return new Vector(x.intValue() - vect.getX().intValue(),
					y.intValue() - vect.getY().intValue());
		}
	}
	
	public Vector<T> add(Vector<T> vect) {
		if (vect.getX() instanceof Double) {
			return new Vector(x.doubleValue() + vect.getX().doubleValue()
					, y.doubleValue() + vect.getY().doubleValue());
		}
		else if (vect.getY() instanceof Float) {
			return new Vector(x.floatValue() + vect.getX().floatValue(),
					y.floatValue() + vect.getY().floatValue());
		}
		else {
			return new Vector(x.intValue() + vect.getX().intValue(),
					y.intValue() + vect.getY().intValue());
		}
	}
}

[baavgai]

Version 2.0. Uber template version...

As much as it makes sense to have delta separate from position, it is a bit of a pita. I threw a bunch of overloads at this. I can think of a few more, but it would get silly.

Spoiler

#include <iostream>

template<typename T>
struct Pos {
	T x, y;
	Pos();
	Pos(T x, T y);
	
	bool operator==(const Pos &) const;
	bool operator!=(const Pos &) const;
	Pos operator+(const Pos &) const;
	Pos operator-(const Pos &) const;
	Pos operator/(const Pos &) const; // midpoint
	Pos operator/(double) const;
	
	Pos & operator+=(const Pos &);
	Pos & operator-=(const Pos &);
	Pos & operator/=(const Pos &);
	Pos & operator/=(double);
	Pos operator-() const;
};

template<typename T>
std::ostream &operator<<(std::ostream &, const Pos<T> &);


template<typename T>
struct Vec {
	Pos<T> pos, delta;
	Vec();
	Vec(const Pos<T> &pos, const Pos<T> &delta);
	Vec(T x, T y, T dx, T dy);
	Vec& operator++();
	void operator++ (int);
	Vec& operator--();
	void operator-- (int);
};

template<typename T> 
std::ostream &operator<<(std::ostream &, const Vec<T> &);



using namespace std;

#define SHOW(v) cout << #v << " = " << v << endl
#define OP2(op,oname,v1,v2) cout << v1 << ' ' << oname << ' ' << v2; op; cout << " -> " << result << endl
#define OP1(op,oname,v) OP2(op,oname,result,v) 
#define OP0(opre,opost,v,op) cout << opre << v << opost; op; cout << " -> " << v << endl

template<typename T>
void tests(const Pos<T> &p1, const Pos<T> &p2) {
	Pos<T> result;
	SHOW(p1); SHOW(p2); SHOW(result);
	SHOW((p1==p2)); SHOW((p1!=p2));
	SHOW((p1==p1)); SHOW((p1!=p1));
	OP2(result = p1 + p2, "+", p1, p2);
	OP2(result = p1 - p2, "-", p1, p2);
	OP2(result = p1 / p2, "/", p1, p2);
	OP2(result = p1 / 3.0, "/", p1, 3.0);
	
	OP1(result += p2, "+=", p2);
	OP1(result -= p2, "-=", p2);
	OP1(result /= p2, "/=", p2);
	OP1(result /= 3, "/=", 3);
	OP0('-',' ',result,result = -result);
	
	Vec<T> vec(p1, p2);
	SHOW(vec);
	OP0("++",' ',vec,++vec);
	OP0(' ',"++",vec,vec++);
	OP0("--",' ',vec,--vec);
	OP0(' ',"--",vec,vec--);

	Vec<T> vec2(p2.x, p1.y, p1.x, p2.y);
	cout << vec2;
	for(int i=0; i<6; i++, vec2++) { cout << ' ' << vec2.pos; }
	cout << endl;

	cout << endl;
}


int main() {
	tests(Pos<int>(5,5), Pos<int>(2,2));
	tests(Pos<float>(12.5, 2.9), Pos<float>(2,2));

	return 0;
}



template<typename T>
Pos<T>::Pos() : x(0), y(0) { }

template<typename T>
Pos<T>::Pos(T x, T y) : x(x), y(y) { }

template<typename T>
bool Pos<T>::operator==(const Pos<T> &p) const { return x==p.x && y==p.y; }

template<typename T>
bool Pos<T>::operator!=(const Pos<T> &p) const { return !(*this==p); }

template<typename T>
Pos<T> Pos<T>::operator+(const Pos<T> &d) const { return Pos<T>(x, y) += d; }

template<typename T>
Pos<T> Pos<T>::operator-(const Pos<T> &d) const { return Pos<T>(x, y) -= d; }

template<typename T>
Pos<T> Pos<T>::operator/(const Pos<T> &d) const { return Pos<T>(x, y) /= d; }

template<typename T>
Pos<T> Pos<T>::operator/(double n) const { return Pos<T>(x/n, y/n); }

template<typename T>
Pos<T> &Pos<T>::operator+=(const Pos<T> &d) { 
	x += d.x, 
	y += d.y; 
	return *this;
}

template<typename T>
Pos<T> &Pos<T>::operator-=(const Pos<T> &d) { 
	x -= d.x, 
	y -= d.y; 
	return *this;
}

template<typename T>
Pos<T> &Pos<T>::operator/=(const Pos<T> &d) { 
	*this += d;
	*this /= 2.0;
	return *this;
}

template<typename T>
Pos<T> &Pos<T>::operator/=(double n) { 
	x /= n;
	y /= n;
	return *this;
}

template<typename T>
Pos<T> Pos<T>::operator-() const { return Pos<T>(-x, -y); } 

template<typename T>
std::ostream &operator<<(std::ostream &out, const Pos<T> &item) {
	out << '(' << item.x << ',' << item.y << ')'; 
	return out;
}

template<typename T> Vec<T>::Vec() { }
template<typename T> Vec<T>::Vec(const Pos<T> &p, const Pos<T> &d) : pos(p), delta(d) { }
template<typename T> Vec<T>::Vec(T x, T y, T dx, T dy) : pos(Pos<T>(x,y)), delta(Pos<T>(dx,dy)) { }
template<typename T> Vec<T>& Vec<T>::operator++() { pos += delta; return *this; }
template<typename T> void Vec<T>::operator++(int) { operator++(); }
template<typename T> Vec<T>& Vec<T>::operator--() { pos -= delta; return *this; }
template<typename T> void Vec<T>::operator--(int) { operator--(); }

template<typename T>
std::ostream &operator<<(std::ostream &out, const Vec<T> &item) {
	out << '<' << item.pos << '-' << item.delta << '>'; 
	return out;
}

[cfoley]

So vectors have an origin, a magnitude and a direction... which is what I think you were getting at before. But if you work with zero-based vectors (I forget their proper name) you can do away with the origin. and just store (x,y) or (magnitude,angle) as you choose.

You can then compose an object that uses a vector as its position and a vector as its delta. In my physics engine, moving objects have a position vector, a speed vector and an acceleration vector. I think the speed vector is similar to your delta (acceleration being a second order delta). This would make my update() methods similar to your ++ operator, albeit more verbose. The moving object class has an update method that takes no parameters (since it already has the acceleration and speed), so I guess that would be the direct equivalent.

[baavgai]

I believe an orgin (0,0) vector is called a "free vector." Or perhaps bound at zero. I'm not real sure how useful this is to the game mechanics of position. I want to know where I am as well as where I'm going, so the orgin does matter.

You're right that only ++ would makes sense in context, as a vector only travels one direction. Other vector properties are obviously valuable, like changing magnatude directly, rather than mucking about with a second point.

I'm not sure why you need both a position and speed, as that kind of sounds like one vector. Acceleration makes sense, though for a physics engine I guess that could be a few vectors. Gravity and the object's momentum.

I've honestly just looked at your code. I was writing in a happy C++ vacuum, having fun with frameworks. I'd thought to stick to basics. I guess the real test of a given framework would be how easy it is to do a given task. Ball bouncing is good. Hmm...

[RevTorA]

Vectors have no origin. They have only a direction and magnitude. I'll definitely have to give this a go though

Only a line segment would have an actual origin btw.

Edit: I think a matrix class challenge would be a good one too btw, since OpenGL is getting rid of its own matrix operations.

This post has been edited by RevTorA: 23 September 2011 - 12:16 PM

[baavgai]

I supposed you're right. I just think of the arrows with the little dot at the beginning...

So, technically, I guess want my vector class to just be an extension of a point class, with direction and mag worried out? But for a travelling point, I'd want to pair them. I like the ++ or cfoley's update. Need a name for that.

I agree with the matrix class. There are a number of ways to skin that cat. I believe that was my first graphic project, in Pascal. Pity I lost those floppies. Damn, I feel old sometimes.

[macosxnerd101]

I'll give this a shot! I took the polar approach, and added in dot and cross products. Which for 2D Vectors, cross-product is just the matrix determinant.

Spoiler

public class Vector2D{
  
    private double magnitude, theta;

    public Vector2D(double magnitude, double theta){
        this.magnitude = magnitude;
        this.theta = theta;
    }

    public double getX(){ return magnitude * Math.cos(theta); }
    public double getY(){ return magnitude * Math.sin(theta); }
    public double getTheta(){ return theta; }
    
    public Vector2D add(Vector2D other){
        double newX = getX() + other.getX();
        double newY = getY() + other.getY();
        double newTheta = getTheta(newX, newY);
        return new Vector2D(Math.sqrt((newX * newX) + (newY * newY)), newTheta);
    }

    private double getTheta(double newX, double newY){
        double newTheta = Math.atan(newY/newX);

        if(newY > 0 && newX > 0) 
             return newTheta;
        else if(newX < 0)
             return newTheta + (Math.PI);
        return newTheta + (2 * Math.PI);
    }

    public double dotProduct(Vector2D other){ 
       return magnitude * other.getX() * Math.cos(Math.abs(theta - other.theta));
    }

    public double crossProduct(Vector2D other){ 
       return getX() * other.getY() - other.getX() * getY();
    }
    
}