Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 5839 in orxonox.OLD for branches


Ignore:
Timestamp:
Nov 30, 2005, 9:40:41 PM (19 years ago)
Author:
snellen
Message:

player.cc and player.h changed (both files in ../src/world_entities)

Location:
branches/spaceshipcontrol/src
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • branches/spaceshipcontrol/src/defs/class_id.h

    r5822 r5839  
    118118  CL_GLGUI_MAIN_WIDGET          =    0x00000f41,
    119119  CL_NETWORK_MANAGER            =    0x00000f50,
     120 
    120121
    121122

  • branches/spaceshipcontrol/src/world_entities/player.cc

    r5767 r5839  
    4949}
    5050
    51 /**
    52  * loads a Players information from a specified file.
    53  * @param fileName the name of the File to load the player from (absolute path)
    54  */
    55 Player::Player(const char* fileName)
    56 {
    57   this->init();
    58   TiXmlDocument doc(fileName);
    59 
    60   if(!doc.LoadFile())
    61   {
    62     PRINTF(2)("Loading file %s failed for player.\n", fileName);
    63     return;
    64   }
    65 
    66   this->loadParams(doc.RootElement());
    67 }
    68 
    69 /**
    70  *  creates a new Player from Xml Data
    71  * @param root the xml element containing player data
    72 
    73    @todo add more parameters to load
    74 */
    75 Player::Player(const TiXmlElement* root)
    76 {
    77   this->init();
    78   if (root != NULL)
    79     this->loadParams(root);
    80 
    81   //weapons:
    82   Weapon* wpRight = new TestGun(0);
    83   wpRight->setName("testGun Right");
    84   Weapon* wpLeft = new TestGun(1);
    85   wpLeft->setName("testGun Left");
    86   Weapon* cannon = dynamic_cast<Weapon*>(Factory::getFirst()->fabricate(CL_CANNON));
    87 
    88   cannon->setName("BFG");
    89 
    90   this->weaponMan->addWeapon(wpLeft, 1, 0);
    91   this->weaponMan->addWeapon(wpRight,1 ,1);
    92   this->weaponMan->addWeapon(cannon, 0, 6);
    93 
    94   //this->weaponMan->addWeapon(turret, 3, 0);
    95 
    96   this->weaponMan->changeWeaponConfig(1);
    97 }
    9851
    9952/**
    … …  
    10255Player::~Player ()
    10356{
    104   /* do not delete the weapons, they are contained in the pnode tree
    105   and will be deleted there.
    106   this only frees the memory allocated to save the list.
    107   */
    108   delete this->weaponMan;
    10957}
    11058
    … …  
    12068
    12169  PRINTF(4)("PLAYER INIT\n");
    122   travelSpeed = 15.0;
    123   bUp = bDown = bLeft = bRight = bAscend = bDescend = false;
    124   bFire = false;
    125   acceleration = 10.0;
    126 
    127 //   GLGuiButton* button = new GLGuiPushButton();
    128 //   button->show();
    129 //   button->setLabel("orxonox");
    130 //   button->setBindNode(this);
    131 
    132   this->weaponMan = new WeaponManager(this);
    133   this->weaponMan->setSlotCount(7);
    134 
    135   this->weaponMan->setSlotPosition(0, Vector(-2.6, .1, -3.0));
    136   this->weaponMan->setSlotCapability(0, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
    137 
    138   this->weaponMan->setSlotPosition(1, Vector(-2.6, .1, 3.0));
    139   this->weaponMan->setSlotCapability(1, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
    140 
    141   this->weaponMan->setSlotPosition(2, Vector(-1.5, .5, -.5));
    142   this->weaponMan->setSlotDirection(2, Quaternion(-M_PI_4*.5, Vector(1,0,0)));
    143 
    144   this->weaponMan->setSlotPosition(3, Vector(-1.5, .5, .5));
    145   this->weaponMan->setSlotDirection(3, Quaternion(M_PI_4*.5, Vector(1,0,0)));
    146 
    147   this->weaponMan->setSlotPosition(4, Vector(-1.5, -.5, .5));
    148   this->weaponMan->setSlotDirection(4, Quaternion(-M_PI_4*.5+M_PI, Vector(1,0,0)));
    149 
    150   this->weaponMan->setSlotPosition(5, Vector(-1.5, -.5, -.5));
    151   this->weaponMan->setSlotDirection(5, Quaternion(+M_PI_4*.5-M_PI, Vector(1,0,0)));
    152 //
    153    this->weaponMan->setSlotPosition(6, Vector(-1, 0.0, 0));
    154    this->weaponMan->setSlotCapability(6, WTYPE_ALLDIRS | WTYPE_DIRECTIONAL);
    155    //
    156 //   this->weaponMan->setSlotPosition(8, Vector(-2.5, -0.3, -2.0));
    157 //   this->weaponMan->setSlotDirection(8, Quaternion(-M_PI, Vector(1,0,0)));
    158 //
    159 //   this->weaponMan->setSlotPosition(9, Vector(-2.5, -0.3, 2.0));
    160 //   this->weaponMan->setSlotDirection(9, Quaternion(+M_PI, Vector(1,0,0)));:
    16170
    16271}
    16372
    16473
    165 /**
    166  * loads the Settings of a Player from an XML-element.
    167  * @param root the XML-element to load the Player's properties from
    168  */
    169 void Player::loadParams(const TiXmlElement* root)
     74void Player::process(const Event &event)
    17075{
    171   static_cast<WorldEntity*>(this)->loadParams(root);
    172 
    173 
    174 
     76  this->controllable->process(event);
    17577}
    17678
    177 /**
    178  * adds a weapon to the weapon list of player
    179  * @param weapon to add
    180 */
    181 void Player::addWeapon(Weapon* weapon)
    182 {
    183   this->weaponMan->addWeapon(weapon);
    184 }
    185 
    186 
    187 /**
    188  *  removes a weapon from the player
    189  * @param weapon to remove
    190 */
    191 void Player::removeWeapon(Weapon* weapon)
    192 {
    193   this->weaponMan->removeWeapon(weapon);
    194 }
    195 
    196 
    197 /**
    198  *  effect that occurs after the player is spawned
    199 */
    200 void Player::postSpawn ()
    201 {
    202   //setCollision(new CollisionCluster(1.0, Vector(0,0,0)));
    203 }
    204 
    205 
    206 /**
    207  *  the action occuring if the player left the game
    208 */
    209 void Player::leftWorld ()
    210 {}
    211 
    212 
    213 WorldEntity* ref = NULL;
    214 /**
    215  *  this function is called, when two entities collide
    216  * @param entity: the world entity with whom it collides
    217  *
    218  * Implement behaviour like damage application or other miscellaneous collision stuff in this function
    219  */
    220 void Player::collidesWith(WorldEntity* entity, const Vector& location)
    221 {
    222   if (entity->isA(CL_TURRET_POWER_UP) && entity != ref)
    223   {
    224     this->ADDWEAPON();
    225     ref = entity;
    226     }
    227 //  PRINTF(3)("collision %s vs %s @ (%f,%f,%f)\n", this->getClassName(), entity->getClassName(), location.x, location.y, location.z);
    228 }
    229 
    230 /**
    231  *  draws the player after transforming him.
    232 */
    233 void Player::draw () const
    234 {
    235   glMatrixMode(GL_MODELVIEW);
    236   glPushMatrix();
    237   /* translate */
    238   glTranslatef (this->getAbsCoor ().x,
    239                 this->getAbsCoor ().y,
    240                 this->getAbsCoor ().z);
    241   /* rotate */
    242   Vector tmpRot = this->getAbsDir().getSpacialAxis();
    243   glRotatef (this->getAbsDir().getSpacialAxisAngle(), tmpRot.x, tmpRot.y, tmpRot.z );
    244   this->model->draw();
    245   glPopMatrix();
    246 
    247   this->weaponMan->draw();
    248 
    249   //this->debug(0);
    250 }
    251 
    252 
    253 /**
    254  *  the function called for each passing timeSnap
    255  * @param time The timespan passed since last update
    256 */
    257 void Player::tick (float time)
    258 {
    259   // player controlled movement
    260   this->move(time);
    261 
    262   this->weaponMan->tick(time);
    263   // weapon system manipulation
    264   this->weaponAction();
    265 }
    266 
    267 
    268 /**
    269  *  action if player moves
    270  * @param time the timeslice since the last frame
    271 */
    272 void Player::move (float time)
    273 {
    274   Vector accel(0.0, 0.0, 0.0);
    275   Vector rot(0.0, 0.0, 0.0);
    276   float rotVal = 0.0;
    277   /* FIXME: calculating the direction and orthDirection every timeSlice is redundant! save it somewhere */
    278   /* calculate the direction in which the craft is heading  */
    279   Vector direction (1.0, 0.0, 0.0);
    280   //direction = this->absDirection.apply (direction);
    281   Vector orthDirection (0.0, 0.0, 1.0);
    282   //orthDirection = orthDirection.cross (direction);
    283 
    284   if( this->bUp && this->getRelCoor().x < 20)
    285     accel += direction;
    286   if( this->bDown && this->getRelCoor().x > -5)
    287     accel -= direction;
    288 
    289   if( this->bLeft && TrackManager::getInstance()->getWidth() > -this->getRelCoor().z*2)
    290   {
    291     accel -=(orthDirection);
    292     rot +=Vector(1,0,0);
    293     rotVal -= .4;
    294   }
    295   if( this->bRight && TrackManager::getInstance()->getWidth() > this->getRelCoor().z*2)
    296   {
    297     accel += orthDirection;
    298     rot += Vector(1,0,0);
    299     rotVal += .4;
    300   }
    301   if (this->bAscend )
    302   {
    303     accel += Vector(0,1,0);
    304     rot += Vector(0,0,1);
    305     rotVal += .4;
    306   }
    307   if (this->bDescend )
    308   {
    309     accel -= Vector(0,1,0);
    310     rot += Vector(0,0,1);
    311     rotVal -= .4;
    312   }
    313 
    314   Vector move = accel * time *acceleration;
    315 
    316 /*  if (accel.z < 0)
    317     this->setRelDirSoft(Quaternion(-.4, accel), 5);
    318   else if (accel.z > 0)
    319     this->setRelDirSoft(Quaternion(.4, accel), 5);
    320   else*/
    321   rot.normalize();
    322   this->setRelDirSoft(Quaternion(rotVal, rot), 5);
    323   this->shiftCoor (move);
    324 }
    325 
    326 
    327 /**
    328  * weapon manipulation by the player
    329 */
    330 void Player::weaponAction()
    331 {
    332   if( this->bFire)
    333     {
    334       this->weaponMan->fire();
    335     }
    336 }
    337 
    338 /**
    339  * @todo switch statement ??
    340  */
    341 void Player::process(const Event &event)
    342 {
    343   if( event.type == KeyMapper::PEV_UP)
    344       this->bUp = event.bPressed;
    345   else if( event.type == KeyMapper::PEV_DOWN)
    346       this->bDown = event.bPressed;
    347   else if( event.type == KeyMapper::PEV_RIGHT)
    348       this->bRight= event.bPressed;
    349   else if( event.type == KeyMapper::PEV_LEFT)
    350       this->bLeft = event.bPressed;
    351   else if( event.type == KeyMapper::PEV_FIRE1)
    352       this->bFire = event.bPressed;
    353   else if( event.type == KeyMapper::PEV_NEXT_WEAPON && event.bPressed)
    354     this->weaponMan->nextWeaponConfig();//if( !event.bPressed) this->bWeaponChange = !this->bWeaponChange;
    355   else if ( event.type == KeyMapper::PEV_PREVIOUS_WEAPON && event.bPressed)
    356     this->weaponMan->previousWeaponConfig();
    357 
    358   else if( event.type == SDLK_PAGEUP)
    359     this->bAscend = event.bPressed; //this->shiftCoor(0,.1,0);
    360   else if( event.type == SDLK_PAGEDOWN)
    361     this->bDescend = event.bPressed; //this->shiftCoor(0,-.1,0);
    362 }
    363 
    364 #include "weapons/aiming_turret.h"
    365 // FIXME THIS MIGHT BE CONSIDERED EITHER A FEATURE, OR A BUG
    366 void Player::ADDWEAPON()
    367 {
    368   Weapon* turret = NULL;
    369 
    370   if ((float)rand()/RAND_MAX < .1)
    371   {
    372     //if (this->weaponMan->hasFreeSlot(2, WTYPE_TURRET))
    373     {
    374       turret = new Turret();
    375       this->weaponMan->addWeapon(turret, 2);
    376       this->weaponMan->changeWeaponConfig(2);
    377     }
    378   }
    379   else
    380   {
    381     //if (this->weaponMan->hasFreeSlot(3))
    382     {
    383       turret = new AimingTurret();
    384       this->weaponMan->addWeapon(turret, 3);
    385 
    386       this->weaponMan->changeWeaponConfig(3);
    387     }
    388   }
    389 
    390   if(turret != NULL)
    391   {
    392     turret->setName("Turret");
    393     turret->setStateDuration(WS_SHOOTING, (float)rand()/RAND_MAX*.5+.1);
    394   }
    395 }

  • branches/spaceshipcontrol/src/world_entities/player.h

    r5500 r5839  
    1010#include "physics_interface.h"
    1111#include "event_listener.h"
     12#include "playable.h"
    1213
    13 template<class T> class tList;
    14 class Weapon;
    15 class WeaponManager;
    16 class Vector;
    17 class Event;
    1814
    1915//! Basic controllable WorldEntity
    … …  
    2319     the player.cc for debug also
    2420*/
    25 class Player : public WorldEntity, public EventListener
     21class Player : public EventListener
    2622{
    27   friend class World;
    2823
    2924  public:
    3025    Player();
    31     Player(const char* fileName);
    32     Player(const TiXmlElement* root);
    3326    virtual ~Player();
    3427
    3528    void init();
    36     void loadParams(const TiXmlElement* root);
    37 
    38     void addWeapon(Weapon* weapon);
    39     void removeWeapon(Weapon* weapon);
    40 
    41     virtual void postSpawn();
    42     virtual void leftWorld();
    43 
    44     virtual void collidesWith(WorldEntity* entity, const Vector& location);
    45     virtual void tick(float time);
    46     virtual void draw() const;
    4729
    4830    virtual void process(const Event &event);
    … …  
    5032
    5133  private:
    52     void move(float time);
    53     void weaponAction();
     34    Playable* controllable;
    5435
    55     // !! temporary !!
    56     void ADDWEAPON();
    5736
    58   private:
    59     bool                  bUp;                //!< up button pressed.
    60     bool                  bDown;              //!< down button pressed.
    61     bool                  bLeft;              //!< left button pressed.
    62     bool                  bRight;             //!< right button pressed.
    63     bool                  bAscend;            //!< ascend button pressed.
    64     bool                  bDescend;           //!< descend button presses.
    65     bool                  bFire;              //!< fire button pressed.
    66 
    67     WeaponManager*        weaponMan;          //!< the weapon manager: managing a list of weapon to wepaon-slot mapping
    68 
    69     Vector                velocity;           //!< the velocity of the player.
    70     float                 travelSpeed;        //!< the current speed of the player (to make soft movement)
    71     float                 acceleration;       //!< the acceleration of the player.
    7237};
    7338
Note: See TracChangeset for help on using the changeset viewer.