src/common/target/TargetLife.cpp

   1 ////////////////////////////////////////////////////////////////////////////////
   2 //    Scorched3D (c) 2000-2009
   3 //
   4 //    This file is part of Scorched3D.
   5 //
   6 //    Scorched3D is free software; you can redistribute it and/or modify
   7 //    it under the terms of the GNU General Public License as published by
   8 //    the Free Software Foundation; either version 2 of the License, or
   9 //    (at your option) any later version.
  10 //
  11 //    Scorched3D is distributed in the hope that it will be useful,
  12 //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 //    GNU General Public License for more details.
  15 //
  16 //    You should have received a copy of the GNU General Public License
  17 //    along with Scorched3D; if not, write to the Free Software
  18 //    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 ////////////////////////////////////////////////////////////////////////////////
  20
  21 #include <target/TargetLife.h>
  22 #include <target/TargetRenderer.h>
  23 #include <target/TargetSpace.h>
  24 #include <target/TargetState.h>
  25 #include <target/Target.h>
  26 #include <tank/TankType.h>
  27 #include <engine/ScorchedContext.h>
  28 #include <engine/ActionController.h>
  29 #include <tankai/TankAIAdder.h>
  30 #include <common/Defines.h>
  31 #include <common/Logger.h>
  32
  33 TargetLife::TargetLife(ScorchedContext &context, unsigned int playerId) :
  34         context_(context), sphereGeom_(true),
  35         life_(0), maxLife_(1), target_(0),
  36         size_(2, 2, 2), floatBoundingSize_(0.0f)
  37 {
  38 }
  39
  40 TargetLife::~TargetLife()
  41 {
  42         life_ = 0;
  43         updateSpace();
  44 }
  45
  46 void TargetLife::newGame()
  47 {
  48         setLife(maxLife_);
  49 }
  50
  51 void TargetLife::setLife(fixed life)
  52 {
  53         life_ = life;
  54
  55         if (life_ >= maxLife_) life_ = maxLife_;
  56         if (life_ < 1)
  57         {
  58                 life_ = 0;
  59                 setRotation(0); // Updates space too
  60         }
  61         else
  62         {
  63                 updateAABB();
  64                 updateSpace();
  65         }
  66 }
  67
  68 void TargetLife::setSize(FixedVector &size)
  69 {
  70         size_ = size;
  71
  72         updateAABB();
  73         updateSpace();
  74 }
  75
  76 void TargetLife::setTargetPositionAndRotation(FixedVector &pos, fixed rotation)
  77 {
  78         targetPosition_ = pos;
  79         if (!context_.getServerMode()) targetPosition_.asVector(floatPosition_);
  80
  81         FixedVector zaxis(0, 0, 1);
  82         quaternion_.setQuatFromAxisAndAngle(zaxis, rotation / 180 * fixed::XPI);
  83         if (!context_.getServerMode()) quaternion_.getOpenGLRotationMatrix(floatRotMatrix_);
  84
  85         updateAABB();
  86         updateSpace();
  87 }
  88
  89 void TargetLife::setTargetPosition(FixedVector &pos)
  90 {
  91         targetPosition_ = pos;
  92         if (!context_.getServerMode()) targetPosition_.asVector(floatPosition_);
  93
  94         updateSpace();
  95 }
  96
  97 void TargetLife::setRotation(fixed rotation)
  98 {
  99         FixedVector zaxis(0, 0, 1);
 100         quaternion_.setQuatFromAxisAndAngle(zaxis, rotation / 180 * fixed::XPI);
 101         if (!context_.getServerMode()) quaternion_.getOpenGLRotationMatrix(floatRotMatrix_);
 102
 103         updateAABB();
 104         updateSpace();
 105 }
 106
 107 FixedVector &TargetLife::getCenterPosition()
 108 {
 109         static FixedVector result;
 110         result = getTargetPosition();
 111         result[2] += getSize()[2] / 2;
 112         return result;
 113 }
 114
 115 Vector &TargetLife::getFloatCenterPosition()
 116 {
 117         static Vector result;
 118         result = getFloatPosition();
 119         result[2] += getFloatAabbSize()[2] / 2.0f;
 120         return result;
 121 }
 122
 123 fixed TargetLife::collisionDistance(FixedVector &position)
 124 {
 125         FixedVector &currentPosition = getCenterPosition();
 126         FixedVector direction = position - currentPosition;
 127         fixed dist = 0;
 128
 129         // Get how close the explosion was
 130         if (getBoundingSphere())
 131         {
 132                 // Find how close the explosion was to the
 133                 // outside of the sphere
 134                 fixed sphereRadius = MAX(MAX(size_[0], size_[1]), size_[2]) / 2;
 135                 dist = direction.Magnitude() - sphereRadius;
 136                 if (dist < 0) dist = 0;
 137         }
 138         else
 139         {
 140                 // Make the direction relative to the geom
 141                 // incase the geom has been rotated
 142                 FixedVector relativeDirection;
 143                 quaternion_.getRelativeVector(relativeDirection, direction);
 144
 145                 // Find how close the explosion was to the
 146                 // outside edge of the cube
 147                 FixedVector touchPosition = relativeDirection;
 148
 149                 // Check each size of the cube to see if the point is outside.
 150                 // If it is, then scale it back until the point sits on the
 151                 // outside edge of the cube.
 152                 int inner = 0;
 153                 for (int i=0; i<3; i++)
 154                 {
 155                         fixed halfSize = size_[i] / 2;
 156                         if (touchPosition[i] < -halfSize)
 157                         {
 158                                 // Scale the point so it sits on this edge
 159                                 fixed diff = -halfSize / touchPosition[i];
 160                                 touchPosition *= diff;
 161                         }
 162                         else if (touchPosition[i] > halfSize)
 163                         {
 164                                 // Scale the point so it sits on this edge
 165                                 fixed diff = halfSize / touchPosition[i];
 166                                 touchPosition *= diff;
 167                         }
 168                         else inner++; // The point is inside this edge
 169                 }
 170
 171                 if (inner == 3)
 172                 {
 173                         // We are inside the cube
 174                         dist = 0;
 175                 }
 176                 else
 177                 {
 178                         // We are outside the cube
 179                         relativeDirection -= touchPosition;
 180                         dist = relativeDirection.Magnitude();
 181                 }
 182         }
 183
 184         return dist;
 185 }
 186
 187 bool TargetLife::collision(FixedVector &position)
 188 {
 189         FixedVector &currentPosition = getCenterPosition();
 190         FixedVector direction = position - currentPosition;
 191
 192         // Check against bounding box
 193         if (direction[0] < -aabbSize_[0] ||
 194                 direction[0] > aabbSize_[0] ||
 195                 direction[1] < -aabbSize_[1] ||
 196                 direction[1] > aabbSize_[1] ||
 197                 direction[2] < -aabbSize_[2] ||
 198                 direction[2] > aabbSize_[2])
 199         {
 200                 return false;
 201         }
 202
 203         // Check against actual bounds
 204         if (sphereGeom_)
 205         {
 206                 fixed radius = MAX(MAX(size_[0], size_[1]), size_[2]) / 2;
 207                 if (direction.Magnitude() > radius) return false;
 208         }
 209         else
 210         {
 211                 // Make the direction relative to the geom
 212                 // incase the geom has been rotated
 213                 FixedVector relativeDirection;
 214                 quaternion_.getRelativeVector(relativeDirection, direction);
 215
 216                 // Check each side of the cube to see if the point is inside it
 217                 int inner = 0;
 218                 for (int i=0; i<3; i++)
 219                 {
 220                         fixed halfSize = size_[i] / 2;
 221                         if (-halfSize < relativeDirection[i] &&
 222                                 relativeDirection[i] < halfSize)
 223                         {
 224                                 inner++; // The point is inside this edge
 225                         }
 226                 }
 227
 228                 // We need the point to be inside each of the 6 edges
 229                 if (inner < 3) return false;
 230         }
 231
 232         return true;
 233 }
 234
 235 void TargetLife::setBoundingSphere(bool sphereGeom)
 236 {
 237         sphereGeom_ = sphereGeom;
 238
 239         updateAABB();
 240         updateSpace();
 241 }
 242
 243 void TargetLife::updateSpace()
 244 {
 245         if (target_->getRenderer()) target_->getRenderer()->moved();
 246         context_.getTargetSpace().updateTarget(target_);
 247 }
 248
 249 bool TargetLife::writeMessage(NetBuffer &buffer)
 250 {
 251         buffer.addToBuffer(maxLife_);
 252         buffer.addToBuffer(life_);
 253         buffer.addToBuffer(size_);
 254         buffer.addToBuffer(velocity_);
 255         buffer.addToBuffer(targetPosition_);
 256         buffer.addToBuffer(quaternion_);
 257         return true;
 258 }
 259
 260 bool TargetLife::readMessage(NetBufferReader &reader)
 261 {
 262         life_ = 0; // Suppress target space updates
 263
 264         fixed newLife;
 265         if (!reader.getFromBuffer(maxLife_))
 266         {
 267                 Logger::log("TargetLife::maxLife_ read failed");
 268                 return false;
 269         }
 270         if (!reader.getFromBuffer(newLife))
 271         {
 272                 Logger::log("TargetLife::life_ read failed");
 273                 return false;
 274         }
 275
 276         FixedVector newSize;
 277         if (!reader.getFromBuffer(newSize))
 278         {
 279                 Logger::log("TargetLife::size_ read failed");
 280                 return false;
 281         }
 282         setSize(newSize);
 283
 284         if (!reader.getFromBuffer(velocity_))
 285         {
 286                 Logger::log("TargetLife::velocity_ read failed");
 287                 return false;
 288         }
 289
 290         FixedVector newPosition;
 291         if (!reader.getFromBuffer(newPosition))
 292         {
 293                 Logger::log("TargetLife::targetPosition_ read failed");
 294                 return false;
 295         }
 296         setTargetPosition(newPosition);
 297
 298         if (!reader.getFromBuffer(quaternion_))
 299         {
 300                 Logger::log("TargetLife::quaternion_ read failed");
 301                 return false;
 302         }
 303
 304         // Update target space
 305         setLife(newLife);
 306
 307         return true;
 308 }
 309
 310 void TargetLife::updateAABB()
 311 {
 312         if (sphereGeom_)
 313         {
 314                 fixed radius = MAX(MAX(size_[0], size_[1]), size_[2]) / 2;
 315                 aabbSize_ = FixedVector(radius * 2, radius * 2, radius * 2);
 316         }
 317         else
 318         {
 319                 for (int i=0; i<8; i++)
 320                 {
 321                         FixedVector position;
 322                         switch (i)
 323                         {
 324                         case 0:
 325                                 position = FixedVector(size_[0], size_[1], size_[2]);
 326                                 break;
 327                         case 1:
 328                                 position = FixedVector(-size_[0], size_[1], size_[2]);
 329                                 break;
 330                         case 2:
 331                                 position = FixedVector(size_[0], -size_[1], size_[2]);
 332                                 break;
 333                         case 3:
 334                                 position = FixedVector(-size_[0], -size_[1], size_[2]);
 335                                 break;
 336                         case 4:
 337                                 position = FixedVector(size_[0], size_[1], -size_[2]);
 338                                 break;
 339                         case 5:
 340                                 position = FixedVector(-size_[0], size_[1], -size_[2]);
 341                                 break;
 342                         case 6:
 343                                 position = FixedVector(size_[0], -size_[1], -size_[2]);
 344                                 break;
 345                         case 7:
 346                                 position = FixedVector(-size_[0], -size_[1], -size_[2]);
 347                                 break;
 348                         }
 349
 350                         FixedVector result;
 351                         quaternion_.getRelativeVector(result, position);
 352
 353                         if (i == 0) aabbSize_ = result;
 354                         else
 355                         {
 356                                 aabbSize_[0] = MAX(aabbSize_[0], result[0]);
 357                                 aabbSize_[1] = MAX(aabbSize_[1], result[1]);
 358                                 aabbSize_[2] = MAX(aabbSize_[2], result[2]);
 359                         }
 360                 }
 361         }
 362         if (!context_.getServerMode())
 363         {
 364                 aabbSize_.asVector(floatAabbSize_);
 365                 floatBoundingSize_ = floatAabbSize_.Max();
 366         }
 367 }