kg: comparison src/PhysicsObject.hh

equal deleted inserted replaced

-:01e77fe8c040
+:712b943195a6
 /**
 * PhysicsObject class. Represents an object in the physics simulation.
 */
 class PhysicsObject {
-public:
+protected:
 /** Reference to PhysicsWorld. */
 PhysicsWorld &world;
+private:
+/** Position */
+Vector position;
+/** Position at previous tick */
+Vector previousPosition;
+/** Velocity */
+Vector velocity;
+/** Mass */
+float mass;
+/** Object's shape, polygon vertices */
+std::vector<Vector> shape;
+/** Force queue, emptied on every physics tick */
+std::queue<std::pair<Force, TimeMS> > forceq;
 protected:
-/** Object position. */
-Vector position;
-/** Object position on previous physics tick. */
-Vector previousPosition;
-/** Object velocity */
-Vector velocity;
-/** Object mass. */
-float mass;
 /** Tells if the object is "on the ground" */
 bool inAir;
-/** Object elasticity. */
+/** Object elasticity */
 float collision_elasticity;
-/** Aim angle in radians. */
+/** Aim angle in radians */
 float aim;
-/** Player facing. */
+/** Player facing */
 FacingDirection facing;
 /** Specifies if the object should be simulated */
 bool alive;
 /**
 * Set player facing.
 *
 * @param facingRight True if player is facing right.
 */
-void setFacing (FacingDirection facing);
+void setFacing (FacingDirection facing) {
+this->facing = facing;
+}
 /**
 * Makes the player jump in the air.
 *
 * @param direction -1: jump left, 0: jump up, 1: jump right
 * its movements will not be calculated.
 */
 void disable (void);
 private:
-/** Objects shape. Edgepoints of the polygon */
-std::vector<Vector> shape;
-/** Object force queue. The queue is emptied on every physics
-tick.*/
-std::queue<std::pair<Force, TimeMS> > forceq;
 /**
 * Handle player movement and apply forces.
 *
 * @param dt Time intervall
 */
 * @param force Force
 * @param dt Time
 * @param d Previous derivative
 * @return Derivative
 */
-Derivative evaluate (Force force, TimeMS dt, Derivative &d, const Vector &posAfterTick, const Vector &velAfterTick);
+Derivative evaluate (Force force, TimeMS dt, const Derivative &d, const Vector &posAfterTick, const Vector &velAfterTick);
 /**
 * Return object acceleration with given force.
 *
 * @param force Force
 /**
 * Get object type.
 *
 * @return Object type
 */
-ObjectType getType (void) const;
+ObjectType getType (void) const {
+return type;
+}
 /**
 * Checks if it is possible for the object to be in the given
 * location.
 *
 /**
 * Get current object position.
 *
 * @return position vector
 */
-Vector getPosition (void) const;
+Vector getPosition (void) const {
+return position;
+}
 /**
 * Get previous object position.
 *
 * @return position vector
 */
-Vector getPreviousPosition (void) const;
+Vector getPreviousPosition (void) const {
+return previousPosition;
+}
 /**
 * Get current object screen coordinates
 *
 * @return PixelCoordinate position
 /**
 * Get current object velocity.
 *
 * @return Velocity vector
 */
-Vector getVelocity (void) const;
+Vector getVelocity (void) const {
+return velocity;
+}
-/**
-* Return object shape.
-*
-* @return Polygon points
-*/
-const std::vector<Vector>& getShape (void) const;
-/**
-* Set object shape.
-*
-* @param shape Vector containing polygon points
-*/
-void setShape(std::vector<Vector> shape);
 /**
 * Return object facing.
 *
 * @return Object facing (true if facing right)
 */
-FacingDirection getFacing (void) const;
+FacingDirection getFacing (void) const {
+return facing;
+}
 /**
 * Return object aim angle.
 *
 * @return Object aim angle
 */
-float getAim (void) const;
+float getAim (void) const {
+return aim;
+}
 /**
 * Get object direction.
 *
 * @return Unit vector to facing+aim
 /**
 * Check if the object is alive.
 *
 * @return Is the object alive?
 */
-bool isAlive (void);
+bool isAlive (void) const {
+return alive;
+}
 /**
 * Tells the state of the object.
 *
 * @return True if object has been destroyed.
 /**
 * Set object pivot.
 *
 * @param pivot Pivot object
 */
-void setPivot (PhysicsObject *pivot);
+void setPivot (PhysicsObject *pivot) {
+this->pivot = pivot;
+}
 /**
 * Return the pivot object pointer.
 */
-PhysicsObject *getPivot (void);
+PhysicsObject *getPivot (void) {
+return pivot;
+}
+/**
+* Compute the force that this object (as a pivot) exerts on the given object
+*
+* @param bob Othe object
+* @return Force
+*/
+virtual Vector getPivotForce (void);
 /**
 * Checks if object collides with other objects
 *
 * @param obj Other PhysicsObject
 * @return Did we collide?
 */
 bool collides (const PhysicsObject &obj);
 /**
-* Compute the force that this object (as a pivot) exerts on the given object
-*
-* @param bob Othe object
-* @return Force
-*/
-virtual Vector getPivotForce (void);
-/**
 * Update object in physics simulation.
 *
 * @param tick_length Length of the physics tick
 */
 virtual void tick (TimeMS tick_length);
 protected:
 /**
+* Set object shape.
+*
+* XXX: constructor
+*
+* @param shape Vector containing polygon points
+*/
+void setShape(std::vector<Vector> shape) {
+this->shape = shape;
+}
+/**
 * Update object position, also updating our previous position
 *
 * @param pos new position
 */
 void setPosition (Vector pos);
 /**
 * Update current object velocity.
 *
 * @param velocity new velocity
 */
-void setVelocity (Vector velocity);
+void setVelocity (Vector velocity) {
+this->velocity = velocity;
+}
+/**
+* Reset state and disable, ready to be resume()'d again in a different place
+*/
+void reset (void);
+/**
+* Resume after a reset() at the given position with a zero velocity
+*/
+void resume (Vector position);
 };
 /** Helper struct for the integration */
 struct Derivative {
-Vector dx; // Velocity
+/**
-Vector dv; // Acceleration
+* Velocity
+*/
+Vector dx;
+/**
+* Acceleration
+*/
+Vector dv;
+Derivative () : dx(), dv() { }
+Derivative (Vector dx, Vector dv) : dx(dx), dv(dv) { }
 };
 /**
 * Returns the "sign" of the cross product between given points. In
 * practice the sign of the return value tels on which side of the

changeset 428	712b943195a6
parent 427	01e77fe8c040