minor refactoring and state progress

[chaz/yoink] / src / Character.cc

diff --git a/src/Character.cc b/src/Character.cc
index e0ce1c05c016afa66b9ff4612f125808bc2cade4..f12ed5f2d88f66935f5b3923fd0d1f7b57632f9e 100644 (file)
--- a/src/Character.cc
+++ b/src/Character.cc
@@ -44,8 +44,8 @@ struct SpringForce
                Mf::Scalar d = 50.0;
 
                // spring:
-               //current.force += -15.0 * x - 1.5 * current.velocity;
-               force = -20.0 * (mag - d) * (x / mag) - 2.0 * state.velocity;
+               //mState.force += -15.0 * x - 1.5 * mState.velocity;
+               force = SCALAR(-10.0) * (mag - d) * (x / mag) - 2.0 * state.velocity;
 
                return force;
        }
@@ -78,61 +78,46 @@ Character::Character(const std::string& name) :
        tilemap(name),
        animation(name)
 {
-       current.init();
+       mState.init();
 
-       current.mass = 1.0;
-       current.inverseMass = 1.0 / current.mass;
+       mState.mass = 1.0;
+       mState.inverseMass = 1.0 / mState.mass;
 
        // forces
-       current.force = Mf::Vector2(0.0, 0.0);
-       current.forces.push_back(SpringForce(Mf::Vector2(500.0, 200.0)));
-       current.forces.push_back(ResistanceForce(2.0));
-       current.forces.push_back(Mf::LinearState<2>::GravityForce(-1000.0));
+       mState.force = Mf::Vector2(0.0, 0.0);
+       //mState.forces.push_back(SpringForce(Mf::Vector2(500.0, 200.0)));
+       mState.forces.push_back(ResistanceForce(2.0));
+       //mState.forces.push_back(Mf::LinearState<2>::GravityForce(-100.0));
 
        // starting position
-       current.position = Mf::Vector2(64.0, 64.0);
-       current.momentum = Mf::Vector2(0.0, 0.0);
-       current.recalculate();
+       mState.position = Mf::Vector2(64.0, 64.0);
+       mState.momentum = Mf::Vector2(0.0, 0.0);
+       mState.recalculate();
 
-       previous = current;
+       mPrevState = mState;
 }
 
 
 void Character::update(Mf::Scalar t, Mf::Scalar dt)
 {
-       previous = current;
+       Mf::RigidBody2::update(t, dt); // update physics
 
-       //Mf::Vector2 x = current.position - Mf::Vector2(500.0, 200.0);
-       //Mf::Scalar mag = x.length();
-       //Mf::Scalar d = 50.0;
-
-       //// gravity:
-       //current.force = Mf::Vector2(0.0, -2000.0);
-       //// spring:
-       ////current.force += -15.0 * x - 1.5 * current.velocity;
-       //current.force += -20.0 * (mag - d) * (x / mag) - 2.0 * current.velocity;
-       //// internal:
-       //current.force += userForce;
-       //current.recalculate();
-       //std::cout << "force: " << current.momentum << std::endl;
-
-       //Mf::euler<State,Derivative>(current, t, dt);
-
-       current.integrate(t, dt);
        animation.update(t, dt);
 
-       Mf::Vector3 center(current.position[0], current.position[1], z);
-       Mf::Vector3 a(current.position[0] - 16.0, current.position[1] - 16.0, z);
-       Mf::Vector3 b(current.position[0] + 16.0, current.position[1] + 16.0, z);
+       Mf::Vector3 center(mState.position[0], mState.position[1], z);
+       Mf::Vector3 a(mState.position[0] - 16.0, mState.position[1] - 16.0, z);
+       Mf::Vector3 b(mState.position[0] + 16.0, mState.position[1] + 16.0, z);
 
-       aabb_.init(a, b);
-       sphere_.init(center, a);
+       mAabb.init(a, b);
+       mSphere.init(center, a);
 }
 
 
 void Character::draw(Mf::Scalar alpha) const
 {
-       Mf::Vector2 position = cml::lerp(previous.position, current.position, alpha);
+       //Mf::Vector2 position = cml::lerp(mPrevState.position, mState.position, alpha);
+       Mf::State2 state = getState(alpha);
+       Mf::Vector2 position = state.position;
 
        //glColor3f(1.0f, 1.0f, 1.0f);
        tilemap.bind();
@@ -141,7 +126,7 @@ void Character::draw(Mf::Scalar alpha) const
 
        Tilemap::Orientation orientation = Tilemap::NORMAL;
 
-       if (current.velocity[0] < 0.0) orientation = Tilemap::REVERSE;
+       if (mState.velocity[0] < 0.0) orientation = Tilemap::REVERSE;
 
        Mf::Scalar coords[8];
        tilemap.getTileCoords(frame, coords, orientation);
@@ -172,22 +157,6 @@ void Character::draw(Mf::Scalar alpha) const
 }
 
 
-bool Character::isInsideAabb(const Mf::Aabb& aabb) const
-{
-       // make sure the entity is fully inside the volume
-       if (!(aabb_.max[0] < aabb.max[0] &&
-                 aabb_.min[0] > aabb.min[0] &&
-                 aabb_.max[1] < aabb.max[1] &&
-                 aabb_.min[1] > aabb.min[1] &&
-                 aabb_.max[2] < aabb.max[2] &&
-                 aabb_.min[2] > aabb.min[2]))
-       {
-               return false;
-       }
-
-       return true;
-}
-
 int Character::getOctant(const Mf::Aabb& aabb) const
 {
        int octantNum = -1;
@@ -195,28 +164,28 @@ int Character::getOctant(const Mf::Aabb& aabb) const
        Mf::Plane::Halfspace halfspace;
 
        Mf::Plane xy = aabb.getPlaneXY();
-       halfspace = xy.intersects(sphere_);
+       halfspace = xy.intersects(mSphere);
        if (halfspace == Mf::Plane::INTERSECT)
        {
-               halfspace = xy.intersects(aabb_);
+               halfspace = xy.intersects(mAabb);
        }
 
        if (halfspace == Mf::Plane::POSITIVE)
        {
                Mf::Plane xz = aabb.getPlaneXZ();
-               halfspace = xz.intersects(sphere_);
+               halfspace = xz.intersects(mSphere);
                if (halfspace == Mf::Plane::INTERSECT)
                {
-                       halfspace = xz.intersects(aabb_);
+                       halfspace = xz.intersects(mAabb);
                }
 
                if (halfspace == Mf::Plane::POSITIVE)
                {
                        Mf::Plane yz = aabb.getPlaneYZ();
-                       halfspace = yz.intersects(sphere_);
+                       halfspace = yz.intersects(mSphere);
                        if (halfspace == Mf::Plane::INTERSECT)
                        {
-                               halfspace = yz.intersects(aabb_);
+                               halfspace = yz.intersects(mAabb);
                        }
 
                        if (halfspace == Mf::Plane::POSITIVE)
@@ -231,10 +200,10 @@ int Character::getOctant(const Mf::Aabb& aabb) const
                else if (halfspace == Mf::Plane::NEGATIVE)
                {
                        Mf::Plane yz = aabb.getPlaneYZ();
-                       halfspace = yz.intersects(sphere_);
+                       halfspace = yz.intersects(mSphere);
                        if (halfspace == Mf::Plane::INTERSECT)
                        {
-                               halfspace = yz.intersects(aabb_);
+                               halfspace = yz.intersects(mAabb);
                        }
 
                        if (halfspace == Mf::Plane::POSITIVE)
@@ -250,19 +219,19 @@ int Character::getOctant(const Mf::Aabb& aabb) const
        else if (halfspace == Mf::Plane::NEGATIVE)
        {
                Mf::Plane xz = aabb.getPlaneXZ();
-               halfspace = xz.intersects(sphere_);
+               halfspace = xz.intersects(mSphere);
                if (halfspace == Mf::Plane::INTERSECT)
                {
-                       halfspace = xz.intersects(aabb_);
+                       halfspace = xz.intersects(mAabb);
                }
 
                if (halfspace == Mf::Plane::POSITIVE)
                {
                        Mf::Plane yz = aabb.getPlaneYZ();
-                       halfspace = yz.intersects(sphere_);
+                       halfspace = yz.intersects(mSphere);
                        if (halfspace == Mf::Plane::INTERSECT)
                        {
-                               halfspace = yz.intersects(aabb_);
+                               halfspace = yz.intersects(mAabb);
                        }
 
                        if (halfspace == Mf::Plane::POSITIVE)
@@ -277,10 +246,10 @@ int Character::getOctant(const Mf::Aabb& aabb) const
                else if (halfspace == Mf::Plane::NEGATIVE)
                {
                        Mf::Plane yz = aabb.getPlaneYZ();
-                       halfspace = yz.intersects(sphere_);
+                       halfspace = yz.intersects(mSphere);
                        if (halfspace == Mf::Plane::INTERSECT)
                        {
-                               halfspace = yz.intersects(aabb_);
+                               halfspace = yz.intersects(mAabb);
                        }
 
                        if (halfspace == Mf::Plane::POSITIVE)