Dogcows Code - chaz/yoink/blob - src/Character.cc

   1
   2 /*******************************************************************************
   3
   4  Copyright (c) 2009, Charles McGarvey
   5  All rights reserved.
   6
   7  Redistribution   and   use  in  source  and  binary  forms,  with  or  without
   8  modification, are permitted provided that the following conditions are met:
   9
  10    * Redistributions  of  source  code  must retain the above copyright notice,
  11      this list of conditions and the following disclaimer.
  12    * Redistributions  in binary form must reproduce the above copyright notice,
  13      this  list of conditions and the following disclaimer in the documentation
  14      and/or other materials provided with the distribution.
  15
  16  THIS  SOFTWARE  IS  PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  AND  ANY  EXPRESS  OR  IMPLIED  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19  DISCLAIMED.  IN  NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  20  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  DAMAGES  (INCLUDING,  BUT  NOT  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22  SERVICES;  LOSS  OF  USE,  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23  CAUSED  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24  OR  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26
  27 *******************************************************************************/
  28
  29 #include <iostream>
  30
  31 #include "Character.hh"
  32 #include "Log.hh"
  33
  34
  35 class SpringForce
  36 {
  37 public:
  38
  39         explicit SpringForce(Mf::Vector2 x) :
  40                 location(x) {}
  41
  42         const Mf::Vector2& operator () (const Mf::LinearState<2>& state)
  43         {
  44                 Mf::Vector2 x = state.position - location;
  45                 Mf::Scalar mag = x.length();
  46                 Mf::Scalar d = 0.0;
  47
  48                 // spring:
  49                 //mState.force += -15.0 * x - 1.5 * mState.velocity;
  50                 force = SCALAR(-10.0) * (mag - d) * (x / mag) - 2.0 * state.velocity;
  51
  52                 return force;
  53         }
  54
  55 private:
  56
  57         Mf::Vector2 force;
  58         Mf::Vector2 location;
  59 };
  60
  61 class ResistanceForce
  62 {
  63 public:
  64
  65         explicit ResistanceForce(Mf::Scalar scale = 1.0) :
  66                 k(scale) {}
  67
  68         const Mf::Vector2& operator () (const Mf::LinearState<2>& state)
  69         {
  70                 force = -k * state.velocity;
  71                 return force;
  72         }
  73
  74 private:
  75
  76         Mf::Vector2     force;
  77         Mf::Scalar      k;
  78 };
  79
  80
  81 Character::Character(const std::string& name) :
  82         tilemap(name),
  83         animation(name)
  84 {
  85         mState.init();
  86
  87         mState.mass = 1.0;
  88         mState.inverseMass = 1.0 / mState.mass;
  89
  90         // forces
  91         mState.force = Mf::Vector2(0.0, 0.0);
  92         //mState.forces.push_back(SpringForce(Mf::Vector2(20.0, 4.0)));
  93         mState.forces.push_back(ResistanceForce(2.0));
  94         //mState.forces.push_back(Mf::LinearState<2>::GravityForce(-9.8));
  95
  96         // starting position
  97         mState.position = Mf::Vector2(5.0, 5.0);
  98         mState.momentum = Mf::Vector2(0.0, 0.0);
  99         mState.recalculate();
 100
 101         mPrevState = mState;
 102 }
 103
 104
 105 void Character::update(Mf::Scalar t, Mf::Scalar dt)
 106 {
 107         Mf::RigidBody2::update(t, dt); // update physics
 108
 109         animation.update(t, dt);
 110
 111         Mf::Vector3 center(mState.position[0], mState.position[1], 0.0);
 112         Mf::Vector3 a(mState.position[0] - 0.5, mState.position[1] - 0.5, 0.0);
 113         Mf::Vector3 b(mState.position[0] + 0.5, mState.position[1] + 0.5, 0.0);
 114
 115         mAabb.init(a, b);
 116         mSphere.init(center, a);
 117 }
 118
 119
 120 void Character::draw(Mf::Scalar alpha) const
 121 {
 122         //Mf::Vector2 position = cml::lerp(mPrevState.position, mState.position, alpha);
 123         Mf::State2 state = getState(alpha);
 124         Mf::Vector2 position = state.position;
 125
 126         //glColor3f(1.0f, 1.0f, 1.0f);
 127         tilemap.bind();
 128
 129         Tilemap::Index frame = animation.getFrame();
 130
 131         Tilemap::Orientation orientation = Tilemap::NORMAL;
 132
 133         if (mState.velocity[0] < 0.0) orientation = Tilemap::REVERSE;
 134
 135         Mf::Scalar coords[8];
 136         tilemap.getTileCoords(frame, coords, orientation);
 137
 138         Mf::Scalar s = 0.5;
 139
 140         glBegin(GL_TRIANGLE_FAN);
 141                 glTexCoord(coords[0], coords[1]);
 142                 glVertex(position[0]-s, position[1]-s);
 143                 glTexCoord(coords[2], coords[3]);
 144                 glVertex(position[0]+s, position[1]-s);
 145                 glTexCoord(coords[4], coords[5]);
 146                 glVertex(position[0]+s, position[1]+s);
 147                 glTexCoord(coords[6], coords[7]);
 148                 glVertex(position[0]-s, position[1]+s);
 149         glEnd();
 150 }
 151
 152
 153 /*int Character::getOctant(const Mf::Aabb<3>& aabb) const
 154 {
 155         int octantNum = -1;
 156
 157         Mf::Plane::Halfspace halfspace;
 158
 159         Mf::Plane xy = aabb.getPlaneXY();
 160         halfspace = xy.intersects(mSphere);
 161         if (halfspace == Mf::Plane::INTERSECT)
 162         {
 163                 halfspace = xy.intersects(mAabb);
 164         }
 165
 166         if (halfspace == Mf::Plane::POSITIVE)
 167         {
 168                 Mf::Plane xz = aabb.getPlaneXZ();
 169                 halfspace = xz.intersects(mSphere);
 170                 if (halfspace == Mf::Plane::INTERSECT)
 171                 {
 172                         halfspace = xz.intersects(mAabb);
 173                 }
 174
 175                 if (halfspace == Mf::Plane::POSITIVE)
 176                 {
 177                         Mf::Plane yz = aabb.getPlaneYZ();
 178                         halfspace = yz.intersects(mSphere);
 179                         if (halfspace == Mf::Plane::INTERSECT)
 180                         {
 181                                 halfspace = yz.intersects(mAabb);
 182                         }
 183
 184                         if (halfspace == Mf::Plane::POSITIVE)
 185                         {
 186                                 octantNum = 2;
 187                         }
 188                         else if (halfspace == Mf::Plane::NEGATIVE)
 189                         {
 190                                 octantNum = 3;
 191                         }
 192                 }
 193                 else if (halfspace == Mf::Plane::NEGATIVE)
 194                 {
 195                         Mf::Plane yz = aabb.getPlaneYZ();
 196                         halfspace = yz.intersects(mSphere);
 197                         if (halfspace == Mf::Plane::INTERSECT)
 198                         {
 199                                 halfspace = yz.intersects(mAabb);
 200                         }
 201
 202                         if (halfspace == Mf::Plane::POSITIVE)
 203                         {
 204                                 octantNum = 1;
 205                         }
 206                         else if (halfspace == Mf::Plane::NEGATIVE)
 207                         {
 208                                 octantNum = 0;
 209                         }
 210                 }
 211         }
 212         else if (halfspace == Mf::Plane::NEGATIVE)
 213         {
 214                 Mf::Plane xz = aabb.getPlaneXZ();
 215                 halfspace = xz.intersects(mSphere);
 216                 if (halfspace == Mf::Plane::INTERSECT)
 217                 {
 218                         halfspace = xz.intersects(mAabb);
 219                 }
 220
 221                 if (halfspace == Mf::Plane::POSITIVE)
 222                 {
 223                         Mf::Plane yz = aabb.getPlaneYZ();
 224                         halfspace = yz.intersects(mSphere);
 225                         if (halfspace == Mf::Plane::INTERSECT)
 226                         {
 227                                 halfspace = yz.intersects(mAabb);
 228                         }
 229
 230                         if (halfspace == Mf::Plane::POSITIVE)
 231                         {
 232                                 octantNum = 6;
 233                         }
 234                         else if (halfspace == Mf::Plane::NEGATIVE)
 235                         {
 236                                 octantNum = 7;
 237                         }
 238                 }
 239                 else if (halfspace == Mf::Plane::NEGATIVE)
 240                 {
 241                         Mf::Plane yz = aabb.getPlaneYZ();
 242                         halfspace = yz.intersects(mSphere);
 243                         if (halfspace == Mf::Plane::INTERSECT)
 244                         {
 245                                 halfspace = yz.intersects(mAabb);
 246                         }
 247
 248                         if (halfspace == Mf::Plane::POSITIVE)
 249                         {
 250                                 octantNum = 5;
 251                         }
 252                         else if (halfspace == Mf::Plane::NEGATIVE)
 253                         {
 254                                 octantNum = 4;
 255                         }
 256                 }
 257         }
 258
 259         return octantNum;
 260 }
 261 */
 262
 263
 264 void Character::addImpulse(Mf::Vector2 impulse)
 265 {
 266         mState.momentum += impulse;
 267 }
 268
 269 void Character::addForce(Mf::Vector2 force)
 270 {
 271         mState.force += force;
 272 }
 273
 274 void Character::setPosition(Mf::Vector2 position)
 275 {
 276         mState.position = position;
 277 }
 278
 279
 280 /** vim: set ts=4 sw=4 tw=80: *************************************************/
 281