Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Dec 28, 2007, 10:30:29 PM (16 years ago)
Author:
rgrieder
Message:
  • added Vector2, Vector3, Matrix3, ColourValue, Quaternion and String to the misc folder as header files (each of them contains #include <string> … typedef std::string String , etc.)
  • please use String from now on by including <misc/String.h"
  • removed #include <OgreVector3.h", etc. from "CoreIncludes.h" (adjusted all source files)
  • adjusted all the source files (except network, that keeps <string> for the moment) (what a mess..)
  • moved usleep hack to misc/Sleep.h
  • relative include paths for files from other root directories (like misc, network, etc.) (but it stills writes "../Orxonox.h" when in folder orxonox/objects)
  • "OgreSceneManager.h" —> <OgreSceneManager.h>
  • included OrxonoxPrereqs in every file in folder orxonox
  • moved HUD and ParticleInterface to namespace orxonox
  • removed some using namespace Ogre/std when appropriate
  • I hope I haven't forgotten important points..
File:
1 edited

Legend:

Unmodified
Added
Removed

  • code/branches/FICN/src/orxonox/SpaceshipSteering.cc

    r612 r708  
    11/*
    2  *   ORXONOX - the hottest 3D action shooter ever to exist
    3  *
    4  *
    5  *   License notice:
    6  *
    7  *   This program is free software; you can redistribute it and/or
    8  *   modify it under the terms of the GNU General Public License
    9  *   as published by the Free Software Foundation; either version 2
    10  *   of the License, or (at your option) any later version.
    11  *
    12  *   This program is distributed in the hope that it will be useful,
    13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
    14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    15  *   GNU General Public License for more details.
    16  *
    17  *   You should have received a copy of the GNU General Public License
    18  *   along with this program; if not, write to the Free Software
    19  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
    20  *
    21  *   Author:
    22  *      ...
    23  *   Co-authors:
    24  *      ...
    25  *
    26  */
    27 
    28 #include "Ogre.h"
     2*   ORXONOX - the hottest 3D action shooter ever to exist
     3*
     4*
     5*   License notice:
     6*
     7*   This program is free software; you can redistribute it and/or
     8*   modify it under the terms of the GNU General Public License
     9*   as published by the Free Software Foundation; either version 2
     10*   of the License, or (at your option) any later version.
     11*
     12*   This program is distributed in the hope that it will be useful,
     13*   but WITHOUT ANY WARRANTY; without even the implied warranty of
     14*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     15*   GNU General Public License for more details.
     16*
     17*   You should have received a copy of the GNU General Public License
     18*   along with this program; if not, write to the Free Software
     19*   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
     20*
     21*   Author:
     22*      ...
     23*   Co-authors:
     24*      ...
     25*
     26*/
     27
     28#include <OgreNode.h>
     29#include <OgreSceneNode.h>
     30
     31#include "core/Debug.h"
     32#include "misc/Vector3.h"
    2933#include "SpaceshipSteering.h"
    30 #include <iostream>
    31 #include "core/Debug.h"
    32 
    33 using namespace Ogre;
    34 
    35 SpaceshipSteering::SpaceshipSteering(float maxSpeedForward, float
    36 maxSpeedRotateUpDown, float maxSpeedRotateRightLeft, float
    37 maxSpeedLoopRightLeft) {
    38 
    39   COUT(3) << "Info: Steering was loaded" << std::endl;
    40   moveForward_ = 0;
    41   rotateUp_ = 0;
    42   rotateDown_ = 0;
    43   rotateRight_ = 0;
    44   rotateLeft_ = 0;
    45   loopRight_ = 0;
    46   loopLeft_ = 0;
    47   brakeForward_ = 0;
    48   brakeRotate_ = 0;
    49   brakeLoop_ = 0;
    50   speedForward_ = 0;
    51   speedRotateUpDown_ = 0;
    52   speedRotateRightLeft_ = 0;
    53   speedLoopRightLeft_ = 0;
    54   maxSpeedForward_ = maxSpeedForward;
    55   maxSpeedRotateUpDown_ = maxSpeedRotateUpDown;
    56   maxSpeedRotateRightLeft_ = maxSpeedRotateRightLeft;
    57   maxSpeedLoopRightLeft_ = maxSpeedLoopRightLeft;
    58   accelerationForward_ = 0;
    59   accelerationRotateUpDown_ = 0;
    60   accelerationRotateRightLeft_ = 0;
    61   accelerationLoopRightLeft_ = 0;
     34
     35namespace orxonox
     36{
     37
     38  SpaceshipSteering::SpaceshipSteering(float maxSpeedForward, float
     39    maxSpeedRotateUpDown, float maxSpeedRotateRightLeft, float
     40    maxSpeedLoopRightLeft)
     41  {
     42
     43      COUT(3) << "Info: Steering was loaded" << std::endl;
     44      moveForward_ = 0;
     45      rotateUp_ = 0;
     46      rotateDown_ = 0;
     47      rotateRight_ = 0;
     48      rotateLeft_ = 0;
     49      loopRight_ = 0;
     50      loopLeft_ = 0;
     51      brakeForward_ = 0;
     52      brakeRotate_ = 0;
     53      brakeLoop_ = 0;
     54      speedForward_ = 0;
     55      speedRotateUpDown_ = 0;
     56      speedRotateRightLeft_ = 0;
     57      speedLoopRightLeft_ = 0;
     58      maxSpeedForward_ = maxSpeedForward;
     59      maxSpeedRotateUpDown_ = maxSpeedRotateUpDown;
     60      maxSpeedRotateRightLeft_ = maxSpeedRotateRightLeft;
     61      maxSpeedLoopRightLeft_ = maxSpeedLoopRightLeft;
     62      accelerationForward_ = 0;
     63      accelerationRotateUpDown_ = 0;
     64      accelerationRotateRightLeft_ = 0;
     65      accelerationLoopRightLeft_ = 0;
     66  }
     67
     68  void SpaceshipSteering::tick(float time)
     69  {
     70
     71    if(moveForward_ > 0) {
     72      accelerationForward_ = moveForward_;
     73      if(speedForward_ < maxSpeedForward_)
     74        speedForward_ += accelerationForward_*time;
     75      if(speedForward_ > maxSpeedForward_)
     76        speedForward_ = maxSpeedForward_;
     77    }
     78    if(moveForward_ <= 0) {
     79      accelerationForward_ = brakeForward_;
     80      if(speedForward_ > 0)
     81        speedForward_ -= accelerationForward_*time;
     82      if(speedForward_ < 0)
     83        speedForward_ = 0;
     84    }
     85
     86    if(rotateUp_ > 0) {
     87      accelerationRotateUpDown_ = rotateUp_;
     88      if(speedRotateUpDown_ < maxSpeedRotateUpDown_)
     89        speedRotateUpDown_ += accelerationRotateUpDown_*time;
     90      if(speedRotateUpDown_ > maxSpeedRotateUpDown_)
     91        speedRotateUpDown_ = maxSpeedRotateUpDown_;
     92    }
     93    if(rotateDown_ > 0) {
     94      accelerationRotateUpDown_ = rotateDown_;
     95      if(speedRotateUpDown_ > -maxSpeedRotateUpDown_)
     96        speedRotateUpDown_ -= accelerationRotateUpDown_*time;
     97      if(speedRotateUpDown_ < -maxSpeedRotateUpDown_)
     98        speedRotateUpDown_ = -maxSpeedRotateUpDown_;
     99    }
     100    if(rotateUp_ == 0 && rotateDown_ == 0) {
     101      accelerationRotateUpDown_ = brakeRotate_;
     102      if(speedRotateUpDown_ > 0)
     103        speedRotateUpDown_ -= accelerationRotateUpDown_*time;
     104      if(speedRotateUpDown_ < 0)
     105        speedRotateUpDown_ += accelerationRotateUpDown_*time;
     106      if(abs(speedRotateUpDown_)<accelerationRotateUpDown_*time)
     107        speedRotateUpDown_ = 0;
     108    }
     109
     110    if(rotateRight_ > 0) {
     111      accelerationRotateRightLeft_ = rotateRight_;
     112      if(speedRotateRightLeft_ > -maxSpeedRotateRightLeft_)
     113        speedRotateRightLeft_ -= accelerationRotateRightLeft_*time;
     114      if(speedRotateRightLeft_ < -maxSpeedRotateRightLeft_)
     115        speedRotateRightLeft_ = -maxSpeedRotateRightLeft_;
     116    }
     117    if(rotateLeft_ > 0) {
     118      accelerationRotateRightLeft_ = rotateLeft_;
     119      if(speedRotateRightLeft_ < maxSpeedRotateRightLeft_)
     120        speedRotateRightLeft_ += accelerationRotateRightLeft_*time;
     121      if(speedRotateRightLeft_ > maxSpeedRotateRightLeft_)
     122        speedRotateRightLeft_ = maxSpeedRotateRightLeft_;
     123    }
     124    if(rotateRight_ == 0 && rotateLeft_ == 0) {
     125      accelerationRotateRightLeft_ = brakeRotate_;
     126      if(speedRotateRightLeft_ > 0)
     127        speedRotateRightLeft_ -= accelerationRotateRightLeft_*time;
     128      if(speedRotateRightLeft_ < 0)
     129        speedRotateRightLeft_ += accelerationRotateRightLeft_*time;
     130      if(abs(speedRotateRightLeft_)<accelerationRotateRightLeft_*time)
     131        speedRotateRightLeft_ = 0;
     132    }
     133
     134    if(loopRight_ > 0) {
     135      accelerationLoopRightLeft_ = loopRight_;
     136      if(speedLoopRightLeft_ < maxSpeedLoopRightLeft_)
     137        speedLoopRightLeft_ += accelerationLoopRightLeft_*time;
     138      if(speedLoopRightLeft_ > maxSpeedLoopRightLeft_)
     139        speedLoopRightLeft_ = maxSpeedLoopRightLeft_;
     140    }
     141    if(loopLeft_ > 0) {
     142      accelerationLoopRightLeft_ = loopLeft_;
     143      if(speedLoopRightLeft_ > -maxSpeedLoopRightLeft_)
     144        speedLoopRightLeft_ -= accelerationLoopRightLeft_*time;
     145      if(speedLoopRightLeft_ < -maxSpeedLoopRightLeft_)
     146        speedLoopRightLeft_ = -maxSpeedLoopRightLeft_;
     147    }
     148    if(loopLeft_ == 0 && loopRight_ == 0) {
     149      accelerationLoopRightLeft_ = brakeLoop_;
     150      if(speedLoopRightLeft_ > 0)
     151        speedLoopRightLeft_ -= accelerationLoopRightLeft_*time;
     152      if(speedLoopRightLeft_ < 0)
     153        speedLoopRightLeft_ += accelerationLoopRightLeft_*time;
     154      if(abs(speedLoopRightLeft_)<accelerationLoopRightLeft_*time)
     155        speedLoopRightLeft_ = 0;
     156    }
     157
     158    Vector3 transVector = Vector3::ZERO;
     159    transVector.z = 1;
     160    steeringNode_->translate(transVector*speedForward_*time,
     161      Ogre::SceneNode::TS_LOCAL);
     162    steeringNode_->pitch(Degree(speedRotateUpDown_*time),
     163      Ogre::SceneNode::TS_LOCAL);
     164    steeringNode_->yaw(Degree(speedRotateRightLeft_*time),
     165      Ogre::SceneNode::TS_LOCAL);
     166    steeringNode_->roll(Degree(speedLoopRightLeft_*time),
     167      Ogre::SceneNode::TS_LOCAL);
     168
     169  }
     170
     171  void SpaceshipSteering::moveForward(float moveForward) {
     172    moveForward_ = moveForward;
     173  }
     174
     175  void SpaceshipSteering::rotateUp(float rotateUp) {
     176    rotateUp_ = rotateUp;
     177  }
     178
     179  void SpaceshipSteering::rotateDown(float rotateDown) {
     180    rotateDown_ = rotateDown;
     181  }
     182
     183  void SpaceshipSteering::rotateLeft(float rotateLeft) {
     184    rotateLeft_ = rotateLeft;
     185  }
     186
     187  void SpaceshipSteering::rotateRight(float rotateRight) {
     188    rotateRight_ = rotateRight;
     189  }
     190
     191  void SpaceshipSteering::loopLeft(float loopLeft) {
     192    loopLeft_ = loopLeft;
     193  }
     194
     195  void SpaceshipSteering::loopRight(float loopRight) {
     196    loopRight_ = loopRight;
     197  }
     198
     199  void SpaceshipSteering::brakeForward(float brakeForward) {
     200    brakeForward_ = brakeForward;
     201  }
     202
     203  void SpaceshipSteering::brakeRotate(float brakeRotate) {
     204    brakeRotate_ = brakeRotate;
     205  }
     206
     207  void SpaceshipSteering::brakeLoop(float brakeLoop) {
     208    brakeLoop_ = brakeLoop;
     209  }
     210
     211  void SpaceshipSteering::maxSpeedForward(float maxSpeedForward) {
     212    maxSpeedForward_ = maxSpeedForward;
     213  }
     214
     215  void SpaceshipSteering::maxSpeedRotateUpDown(float maxSpeedRotateUpDown) {
     216    maxSpeedRotateUpDown_ = maxSpeedRotateUpDown;
     217  }
     218
     219  void SpaceshipSteering::maxSpeedRotateRightLeft(float maxSpeedRotateRightLeft) {
     220    maxSpeedRotateRightLeft_ = maxSpeedRotateRightLeft;
     221  }
     222
     223  void SpaceshipSteering::maxSpeedLoopRightLeft(float maxSpeedLoopRightLeft) {
     224    maxSpeedLoopRightLeft_ = maxSpeedLoopRightLeft;
     225  }
     226
     227  void SpaceshipSteering::addNode(Ogre::SceneNode *steeringNode) {
     228    steeringNode_ = steeringNode;
     229  }
     230
    62231}
    63 
    64 void SpaceshipSteering::tick(float time) {
    65 
    66   if(moveForward_ > 0) {
    67     accelerationForward_ = moveForward_;
    68     if(speedForward_ < maxSpeedForward_)
    69       speedForward_ += accelerationForward_*time;
    70     if(speedForward_ > maxSpeedForward_)
    71       speedForward_ = maxSpeedForward_;
    72   }
    73   if(moveForward_ <= 0) {
    74     accelerationForward_ = brakeForward_;
    75     if(speedForward_ > 0)
    76       speedForward_ -= accelerationForward_*time;
    77     if(speedForward_ < 0)
    78       speedForward_ = 0;
    79   }
    80 
    81   if(rotateUp_ > 0) {
    82     accelerationRotateUpDown_ = rotateUp_;
    83     if(speedRotateUpDown_ < maxSpeedRotateUpDown_)
    84       speedRotateUpDown_ += accelerationRotateUpDown_*time;
    85     if(speedRotateUpDown_ > maxSpeedRotateUpDown_)
    86       speedRotateUpDown_ = maxSpeedRotateUpDown_;
    87   }
    88   if(rotateDown_ > 0) {
    89     accelerationRotateUpDown_ = rotateDown_;
    90     if(speedRotateUpDown_ > -maxSpeedRotateUpDown_)
    91       speedRotateUpDown_ -= accelerationRotateUpDown_*time;
    92     if(speedRotateUpDown_ < -maxSpeedRotateUpDown_)
    93       speedRotateUpDown_ = -maxSpeedRotateUpDown_;
    94   }
    95   if(rotateUp_ == 0 && rotateDown_ == 0) {
    96     accelerationRotateUpDown_ = brakeRotate_;
    97     if(speedRotateUpDown_ > 0)
    98       speedRotateUpDown_ -= accelerationRotateUpDown_*time;
    99     if(speedRotateUpDown_ < 0)
    100       speedRotateUpDown_ += accelerationRotateUpDown_*time;
    101     if(abs(speedRotateUpDown_)<accelerationRotateUpDown_*time)
    102       speedRotateUpDown_ = 0;
    103   }
    104 
    105   if(rotateRight_ > 0) {
    106     accelerationRotateRightLeft_ = rotateRight_;
    107     if(speedRotateRightLeft_ > -maxSpeedRotateRightLeft_)
    108       speedRotateRightLeft_ -= accelerationRotateRightLeft_*time;
    109     if(speedRotateRightLeft_ < -maxSpeedRotateRightLeft_)
    110       speedRotateRightLeft_ = -maxSpeedRotateRightLeft_;
    111   }
    112   if(rotateLeft_ > 0) {
    113     accelerationRotateRightLeft_ = rotateLeft_;
    114     if(speedRotateRightLeft_ < maxSpeedRotateRightLeft_)
    115       speedRotateRightLeft_ += accelerationRotateRightLeft_*time;
    116     if(speedRotateRightLeft_ > maxSpeedRotateRightLeft_)
    117       speedRotateRightLeft_ = maxSpeedRotateRightLeft_;
    118   }
    119   if(rotateRight_ == 0 && rotateLeft_ == 0) {
    120     accelerationRotateRightLeft_ = brakeRotate_;
    121     if(speedRotateRightLeft_ > 0)
    122       speedRotateRightLeft_ -= accelerationRotateRightLeft_*time;
    123     if(speedRotateRightLeft_ < 0)
    124       speedRotateRightLeft_ += accelerationRotateRightLeft_*time;
    125     if(abs(speedRotateRightLeft_)<accelerationRotateRightLeft_*time)
    126       speedRotateRightLeft_ = 0;
    127   }
    128 
    129   if(loopRight_ > 0) {
    130     accelerationLoopRightLeft_ = loopRight_;
    131     if(speedLoopRightLeft_ < maxSpeedLoopRightLeft_)
    132       speedLoopRightLeft_ += accelerationLoopRightLeft_*time;
    133     if(speedLoopRightLeft_ > maxSpeedLoopRightLeft_)
    134       speedLoopRightLeft_ = maxSpeedLoopRightLeft_;
    135   }
    136   if(loopLeft_ > 0) {
    137     accelerationLoopRightLeft_ = loopLeft_;
    138     if(speedLoopRightLeft_ > -maxSpeedLoopRightLeft_)
    139       speedLoopRightLeft_ -= accelerationLoopRightLeft_*time;
    140     if(speedLoopRightLeft_ < -maxSpeedLoopRightLeft_)
    141       speedLoopRightLeft_ = -maxSpeedLoopRightLeft_;
    142   }
    143   if(loopLeft_ == 0 && loopRight_ == 0) {
    144     accelerationLoopRightLeft_ = brakeLoop_;
    145     if(speedLoopRightLeft_ > 0)
    146       speedLoopRightLeft_ -= accelerationLoopRightLeft_*time;
    147     if(speedLoopRightLeft_ < 0)
    148       speedLoopRightLeft_ += accelerationLoopRightLeft_*time;
    149     if(abs(speedLoopRightLeft_)<accelerationLoopRightLeft_*time)
    150       speedLoopRightLeft_ = 0;
    151   }
    152 
    153   Vector3 transVector = Vector3::ZERO;
    154   transVector.z = 1;
    155   steeringNode_->translate(transVector*speedForward_*time,
    156   Node::TS_LOCAL);
    157   steeringNode_->pitch(Degree(speedRotateUpDown_*time),
    158   Node::TS_LOCAL);
    159   steeringNode_->yaw(Degree(speedRotateRightLeft_*time),
    160   Node::TS_LOCAL);
    161   steeringNode_->roll(Degree(speedLoopRightLeft_*time),
    162   Node::TS_LOCAL);
    163 
    164 }
    165 
    166 void SpaceshipSteering::moveForward(float moveForward) {
    167   moveForward_ = moveForward;
    168 }
    169 
    170 void SpaceshipSteering::rotateUp(float rotateUp) {
    171   rotateUp_ = rotateUp;
    172 }
    173 
    174 void SpaceshipSteering::rotateDown(float rotateDown) {
    175   rotateDown_ = rotateDown;
    176 }
    177 
    178 void SpaceshipSteering::rotateLeft(float rotateLeft) {
    179   rotateLeft_ = rotateLeft;
    180 }
    181 
    182 void SpaceshipSteering::rotateRight(float rotateRight) {
    183   rotateRight_ = rotateRight;
    184 }
    185 
    186 void SpaceshipSteering::loopLeft(float loopLeft) {
    187   loopLeft_ = loopLeft;
    188 }
    189 
    190 void SpaceshipSteering::loopRight(float loopRight) {
    191   loopRight_ = loopRight;
    192 }
    193 
    194 void SpaceshipSteering::brakeForward(float brakeForward) {
    195   brakeForward_ = brakeForward;
    196 }
    197 
    198 void SpaceshipSteering::brakeRotate(float brakeRotate) {
    199   brakeRotate_ = brakeRotate;
    200 }
    201 
    202 void SpaceshipSteering::brakeLoop(float brakeLoop) {
    203   brakeLoop_ = brakeLoop;
    204 }
    205 
    206 void SpaceshipSteering::maxSpeedForward(float maxSpeedForward) {
    207   maxSpeedForward_ = maxSpeedForward;
    208 }
    209 
    210 void SpaceshipSteering::maxSpeedRotateUpDown(float maxSpeedRotateUpDown) {
    211   maxSpeedRotateUpDown_ = maxSpeedRotateUpDown;
    212 }
    213 
    214 void SpaceshipSteering::maxSpeedRotateRightLeft(float maxSpeedRotateRightLeft) {
    215   maxSpeedRotateRightLeft_ = maxSpeedRotateRightLeft;
    216 }
    217 
    218 void SpaceshipSteering::maxSpeedLoopRightLeft(float maxSpeedLoopRightLeft) {
    219   maxSpeedLoopRightLeft_ = maxSpeedLoopRightLeft;
    220 }
    221 
    222 void SpaceshipSteering::addNode(Ogre::SceneNode *steeringNode) {
    223   steeringNode_ = steeringNode;
    224 }
Note: See TracChangeset for help on using the changeset viewer.