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         Mf::Texture::TileIndex frame = animation.getFrame();
 130         Mf::Texture::Orientation orientation = Mf::Texture::NORMAL;
 131
 132         if (mState.velocity[0] < 0.0) orientation = Mf::Texture::REVERSE;
 133
 134         Mf::Scalar coords[8];
 135         tilemap.getTileCoords(frame, coords, orientation);
 136
 137         Mf::Scalar s = 0.5;
 138
 139         glBegin(GL_TRIANGLE_FAN);
 140                 glTexCoord(coords[0], coords[1]);
 141                 glVertex(position[0]-s, position[1]-s);
 142                 glTexCoord(coords[2], coords[3]);
 143                 glVertex(position[0]+s, position[1]-s);
 144                 glTexCoord(coords[4], coords[5]);
 145                 glVertex(position[0]+s, position[1]+s);
 146                 glTexCoord(coords[6], coords[7]);
 147                 glVertex(position[0]-s, position[1]+s);
 148         glEnd();
 149 }
 150
 151
 152 /*int Character::getOctant(const Mf::Aabb<3>& aabb) const
 153 {
 154         int octantNum = -1;
 155
 156         Mf::Plane::Halfspace halfspace;
 157
 158         Mf::Plane xy = aabb.getPlaneXY();
 159         halfspace = xy.intersects(mSphere);
 160         if (halfspace == Mf::Plane::INTERSECT)
 161         {
 162                 halfspace = xy.intersects(mAabb);
 163         }
 164
 165         if (halfspace == Mf::Plane::POSITIVE)
 166         {
 167                 Mf::Plane xz = aabb.getPlaneXZ();
 168                 halfspace = xz.intersects(mSphere);
 169                 if (halfspace == Mf::Plane::INTERSECT)
 170                 {
 171                         halfspace = xz.intersects(mAabb);
 172                 }
 173
 174                 if (halfspace == Mf::Plane::POSITIVE)
 175                 {
 176                         Mf::Plane yz = aabb.getPlaneYZ();
 177                         halfspace = yz.intersects(mSphere);
 178                         if (halfspace == Mf::Plane::INTERSECT)
 179                         {
 180                                 halfspace = yz.intersects(mAabb);
 181                         }
 182
 183                         if (halfspace == Mf::Plane::POSITIVE)
 184                         {
 185                                 octantNum = 2;
 186                         }
 187                         else if (halfspace == Mf::Plane::NEGATIVE)
 188                         {
 189                                 octantNum = 3;
 190                         }
 191                 }
 192                 else if (halfspace == Mf::Plane::NEGATIVE)
 193                 {
 194                         Mf::Plane yz = aabb.getPlaneYZ();
 195                         halfspace = yz.intersects(mSphere);
 196                         if (halfspace == Mf::Plane::INTERSECT)
 197                         {
 198                                 halfspace = yz.intersects(mAabb);
 199                         }
 200
 201                         if (halfspace == Mf::Plane::POSITIVE)
 202                         {
 203                                 octantNum = 1;
 204                         }
 205                         else if (halfspace == Mf::Plane::NEGATIVE)
 206                         {
 207                                 octantNum = 0;
 208                         }
 209                 }
 210         }
 211         else if (halfspace == Mf::Plane::NEGATIVE)
 212         {
 213                 Mf::Plane xz = aabb.getPlaneXZ();
 214                 halfspace = xz.intersects(mSphere);
 215                 if (halfspace == Mf::Plane::INTERSECT)
 216                 {
 217                         halfspace = xz.intersects(mAabb);
 218                 }
 219
 220                 if (halfspace == Mf::Plane::POSITIVE)
 221                 {
 222                         Mf::Plane yz = aabb.getPlaneYZ();
 223                         halfspace = yz.intersects(mSphere);
 224                         if (halfspace == Mf::Plane::INTERSECT)
 225                         {
 226                                 halfspace = yz.intersects(mAabb);
 227                         }
 228
 229                         if (halfspace == Mf::Plane::POSITIVE)
 230                         {
 231                                 octantNum = 6;
 232                         }
 233                         else if (halfspace == Mf::Plane::NEGATIVE)
 234                         {
 235                                 octantNum = 7;
 236                         }
 237                 }
 238                 else if (halfspace == Mf::Plane::NEGATIVE)
 239                 {
 240                         Mf::Plane yz = aabb.getPlaneYZ();
 241                         halfspace = yz.intersects(mSphere);
 242                         if (halfspace == Mf::Plane::INTERSECT)
 243                         {
 244                                 halfspace = yz.intersects(mAabb);
 245                         }
 246
 247                         if (halfspace == Mf::Plane::POSITIVE)
 248                         {
 249                                 octantNum = 5;
 250                         }
 251                         else if (halfspace == Mf::Plane::NEGATIVE)
 252                         {
 253                                 octantNum = 4;
 254                         }
 255                 }
 256         }
 257
 258         return octantNum;
 259 }
 260 */
 261
 262
 263 void Character::addImpulse(Mf::Vector2 impulse)
 264 {
 265         mState.momentum += impulse;
 266 }
 267
 268 void Character::addForce(Mf::Vector2 force)
 269 {
 270         mState.force += force;
 271 }
 272
 273 void Character::setPosition(Mf::Vector2 position)
 274 {
 275         mState.position = position;
 276 }
 277
 278
 279 /** vim: set ts=4 sw=4 tw=80: *************************************************/
 280