Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Dec 17, 2008, 8:00:43 AM (16 years ago)
Author:
landauf
Message:

merged pickups2 to presentation

Location:
code/branches/presentation
Files:
2 added
8 edited
5 copied

Legend:

Unmodified
Added
Removed
  • code/branches/presentation

  • code/branches/presentation/src/orxonox/objects/pickup/CMakeLists.txt

    r2131 r2500  
    11SET( SRC_FILES
    2   ShipEquipmentClasses.cc
    3   ShipItem.cc
     2  PickupSpawner.cc
     3  Item.cc
     4  Turbo.cc
     5  ShipEquipment.cc
    46)
    57
  • code/branches/presentation/src/orxonox/objects/pickup/PickupSpawner.cc

    • Property svn:eol-style set to native
    r2498 r2500  
    11#include "PickupSpawner.h"
    2 #include "Item.h"
     2#include "BaseItem.h"
    33#include "objects/worldentities/pawns/Pawn.h"
    44#include "objects/worldentities/triggers/DistanceTrigger.h"
     
    1111CreateFactory(PickupSpawner);
    1212
    13 PickupSpawner::PickupSpawner(BaseObject* creator) : PositionableEntity(creator)
     13PickupSpawner::PickupSpawner(BaseObject* creator) : StaticEntity(creator)
    1414{
    1515        RegisterObject(PickupSpawner);
     
    3131        XMLPortParam(PickupSpawner, "distance", setDistance, getDistance, xmlelement, mode).defaultValues(20.0f);
    3232        XMLPortParam(PickupSpawner, "respawntimer", setRespawnTimer, getRespawnTimer, xmlelement, mode);
    33        
     33
    3434}
    3535
     
    5858        {
    5959                COUT(0) << "ITEM PICKED UP" << std::endl;
    60                 //if(player->isA(itemtemplate_->getPlayerBaseClass())) 
     60                //if(player->isA(itemtemplate_->getPlayerBaseClass()))
    6161                {
    6262                BaseObject* newobject = this->template_->getBaseclassIdentifier()->fabricate(this);
    63                 Item* newitem = dynamic_cast<Item*>(newobject);
     63                BaseItem* newitem = dynamic_cast<BaseItem*>(newobject);
    6464                if (newitem)
    6565                {
     
    7171                                this->setActive(false);
    7272                                this->fireEvent();
    73                         }       
     73                        }
    7474                        else
    7575                                delete newobject;
     
    8282
    8383void PickupSpawner::triggerRespawnTimer()
    84 {       
    85        
     84{
     85
    8686        if(respawntimer_!=0)
    8787        {
     
    9090                RespawnTimer_.setTimer(this->respawntimer_, false, (BaseObject*)this, executor);
    9191                COUT(0) << "TIMER SET" << std::endl;
    92         }       
     92        }
    9393}
    9494void PickupSpawner::changedActivity()
     
    106106                COUT(0) << "INvisble!" << std::endl;
    107107        }
    108                
     108
    109109*/
    110110        SUPER(PickupSpawner, changedActivity);
  • code/branches/presentation/src/orxonox/objects/pickup/PickupSpawner.h

    • Property svn:eol-style set to native
    r2498 r2500  
    33
    44#include "OrxonoxPrereqs.h"
    5 #include "Item.h"
     5#include "BaseItem.h"
    66#include "tools/Timer.h"
    7 #include "objects/worldentities/PositionableEntity.h"
     7#include "objects/worldentities/StaticEntity.h"
    88#include "objects/Tickable.h"
    99
    1010namespace orxonox
    1111{
    12         class _OrxonoxExport PickupSpawner : public PositionableEntity, public Tickable
     12        class _OrxonoxExport PickupSpawner : public StaticEntity, public Tickable
    1313        {
    1414        public:
  • code/branches/presentation/src/orxonox/objects/pickup/ShipEquipment.cc

    • Property svn:eol-style set to native
    r2498 r2500  
    1 #include "Item.h"
     1#include "BaseItem.h"
    22#include "ShipEquipment.h"
    33#include "objects/worldentities/pawns/Pawn.h"
     
    99@brief
    1010    Insert a permanent Item to the Equipment. Is usually called by the addTo function in Items.
    11    
     11
    1212@param item
    1313    pointer to the item which is to be inserted.
     
    1616    if new item has sucessfully been added it will return true, in any other case the return value is false.
    1717*/
    18         bool ShipEquipment::insert(Item* item)
     18        bool ShipEquipment::insert(BaseItem* item)
    1919        {
    2020        if(checkSlot(item)==NULL)
    2121        {
    22                 Equipment.insert ( std::pair<std::string, Item*>(item->getName(),item) );
     22                Equipment.insert ( std::pair<std::string, BaseItem*>(item->getName(),item) );
    2323                return true;
    2424        }
     
    2626        {
    2727                COUT(3) << "SWAP?" <<  endl;
    28                 //Abfrage- irgendne ifschleife... 
     28                //Abfrage- irgendne ifschleife...
    2929                if((checkSlot(item)->dropped(player))==true);
    3030                {
    31                         Equipment.insert ( std::pair<std::string, Item*>(item->getName(),item) );
     31                        Equipment.insert ( std::pair<std::string, BaseItem*>(item->getName(),item) );
    3232                        COUT(3) << "SWAPPED!" <<  endl;
    3333                        return true;
     
    4242@brief
    4343    Erases a permanent Item in the Equipment. Is usually called by the remove/dropped function in Items.
    44    
     44
    4545@param item
    4646    pointer to the item which is to be erased.
     
    4949    if new item has sucessfully been erased it will return true, in any other case the return value is false.
    5050*/
    51         bool ShipEquipment::erase (Item* item)
     51        bool ShipEquipment::erase (BaseItem* item)
    5252        {
    53         std::multimap<std::string,Item*>::iterator it = Equipment.find(item->getName());
     53        std::multimap<std::string,BaseItem*>::iterator it = Equipment.find(item->getName());
    5454        if(it != Equipment.end())
    5555        {
     
    5959        return false;
    6060        };
    61         /*void print(std::multimap<std::string, Item*> eut)
     61        /*void print(std::multimap<std::string, BaseItem*> eut)
    6262        {
    63                 std::multimap<std::string,Item*>::iterator it;
     63                std::multimap<std::string,BaseItem*>::iterator it;
    6464                COUT(3) << "Liste:" <<  endl;
    6565                for ( it=eut.begin() ; it != eut.end(); ++it )
     
    7575        {
    7676                //print(Equipment);
    77                 for (std::multimap<std::string,Item*>::iterator it = Equipment.begin(); it != Equipment.end(); )
     77                for (std::multimap<std::string,BaseItem*>::iterator it = Equipment.begin(); it != Equipment.end(); )
    7878                {
    7979
     
    8383        }
    8484
    85         Item* ShipEquipment::checkSlot(Item* item)
     85        BaseItem* ShipEquipment::checkSlot(BaseItem* item)
    8686        {
    87         std::multimap<std::string,Item*>::iterator it;
     87        std::multimap<std::string,BaseItem*>::iterator it;
    8888        for ( it= getPlayer()->getPickUp().getEquipment().begin() ; it != getPlayer()->getPickUp().getEquipment().end(); it++ )
    8989        {
     
    9494        return NULL;
    9595        };
    96        
     96
    9797}
  • code/branches/presentation/src/orxonox/objects/pickup/ShipEquipment.h

    r2094 r2500  
    1 
    21#ifndef _ShipEquipment_H__
    32#define _ShipEquipment_H__
    43#include <string>
    5 #include <multimap>
     4#include <map>
     5
     6/*
     7multimap<std::string, BaseItem*> equipment_;
     8equipment_.insert(pair<std::string, BaseItem*>("Weapon", new BaseItem()));*/
    69
    710
    8 /*
    9 multimap<std::string, Item*> equipment_;
    10 equipment_.insert(pair<std::string, Item*>("Weapon", new Item()));*/
     11/*          std::map<std::itemtype, BaseItem*> EQClasses;
     12            EQClasses["jacke"] = 0;
     13            BaseItem* item = itemMap_["jacke"];
    1114
    12 
     15           if (itemMap_["jacke"])
     16           if (itemMap_.find("jacke") != itemMap_.end()) */
    1317namespace orxonox
    1418{
     19    class BaseItem;
     20/**
     21@brief
     22    ShipEquipment is the inventory of a player. It's part of the Pawn class.
     23
     24*/
    1525    class _OrxonoxExport ShipEquipment
    1626    {
    1727        public:
    18             void AddItem(Shipitem toAddItem);
    19             void RemoveItem(Shipitem toRemoveItem);
    20             bool CheckifValid(Shipitem toBeChecked);
    21             int
    22 
     28        inline int getSpace()
     29        {
     30        return Usable.size()+Trunk.size();
     31        };
     32        bool insert(BaseItem* item);
     33        bool erase (BaseItem* item);
     34        //void print(std::multimap<std::string, BaseItem*> eut);
     35        void eraseAll();
     36        //bool checkSlot(BaseItem* item);
     37        BaseItem* checkSlot(BaseItem* item);
     38//      const std::multimap<std::string, BaseItem*>& getEquipment() const { return this->Equipment; }
     39        inline std::multimap<std::string, BaseItem*>& getEquipment() {return this->Equipment;}
     40        inline std::multimap<std::string, BaseItem*>& getUsable() {return this->Usable;}
     41        inline std::multimap<std::string, BaseItem*>& getTrunk() {return this->Trunk;}
     42        inline Pawn* getPlayer() {return this->player ;}
     43        inline void setPlayer(Pawn* setplayer)
     44        {this->player = setplayer;}
    2345        private:
    24             std::multimap<std::string, Item*> Equipment;
     46            Pawn* player;//!< Is a pointer to the belonging player
     47            std::multimap<std::string, BaseItem*> Equipment;//!< the Equipment for permanent Items
     48            std::multimap<std::string, BaseItem*> Usable;//!< Where Usables are stored
     49            std::multimap<std::string, BaseItem*> Trunk;//!< Every other Item is stored here
    2550    };
    2651}
     
    3964
    4065
    41 
    42 
    43 
    44 
    4566#endif
  • code/branches/presentation/src/orxonox/objects/pickup/ShipEquipmentClasses.cc

    r2094 r2500  
    5757                }
    5858                break;
    59             default:;
    6059            }
    6160        case Useable:
    6261            return CheckifSpace();
    63         case default:;
    6462        }
    6563        return true;
     
    6765
    6866    /*Adds the Item to the Ship*/
    69     void ShipEquipment::AddItem(Shipitem* toAddItem)
     67    void ShipEquipment::AddItem(ShipItem* toAddItem)
    7068    {
    7169        if(CheckifValid(toAddItem)==true)
     
    9088        }
    9189    }
     90
     91    /*Adds the Item to the Ship*/
     92    void ShipEquipment::AddItem(Shipitem* toAddItem)
     93    {
     94        if(CheckifValid(toAddItem)==true)
     95        {
     96            switch(toAddItem.CheckType()){
     97                case Permanent:
     98                    Equipment.insert ( pair<std::string, ShipItem*>(toAddItem.itemname,toAddItem) );
     99                    break;
     100                case Usable:
     101                    Usable.insert ( pair<std::string, ShipItem*>(toAddItem.itemname,toAddItem) );
     102                    break;
     103                case Trunk:
     104                    Trunk.insert ( pair<std::string, ShipItem*>(toAddItem.itemname,toAddItem) );
     105                    break;
     106            }
     107        }
     108        else if(toAddItem.CheckType()==Permanent)
     109        {
     110            if(CheckifSpace()==true)
     111                Trunk.insert ( pair<std::string, ShipItem*>(toAddItem.itemname,toAddItem) );
     112        }
     113    }
     114
     115    void ShipEquipment::SwitchItem(Permanent* toSwitchItem)
     116    {
     117        multimap<string, ShipItem*>::iterator it;
     118        string equippedname;
     119        equippedname=GetNameofPermanent(toSwitchItem.CheckSubType());
     120        it=Equipment.find(equippedname);
     121        Trunk.insert (find(equippedname));
     122        Equipment.erase (it);
     123        Equipment.insert(pair<std::string, ShipItem*>(toSwitchItem.itemname,toSwitchItem)
     124    }
     125
     126    string ShipEquipment::GetNameofPermanent (subItemTypePermanent NametoGet)
     127    {
     128        multimap<string, ShipItem*>::iterator it;
     129        for ( it=Equipment.begin() ; it != Equipment.end(); it++ ){
     130            if((*it).second->CheckSubType()==NametoGet){
     131                return (*it).first.itemname;
     132            }
     133        }
     134        return 0;
     135    }
    92136}
  • code/branches/presentation/src/orxonox/objects/pickup/ShipEquipmentClasses.h

    r2094 r2500  
    88
    99/*
    10 multimap<std::string, Item*> equipment_;
    11 equipment_.insert(pair<std::string, Item*>("Weapon", new Item()));*/
     10multimap<std::string, BaseItem*> equipment_;
     11equipment_.insert(pair<std::string, BaseItem*>("Weapon", new BaseItem()));*/
    1212
    1313
    14 /*          std::map<std::itemtype, Item*> EQClasses;
     14/*          std::map<std::itemtype, BaseItem*> EQClasses;
    1515            EQClasses["jacke"] = 0;
    16             Item* item = itemMap_["jacke"];
     16            BaseItem* item = itemMap_["jacke"];
    1717
    1818           if (itemMap_["jacke"])
     
    2323    {
    2424        public:
    25             void AddItem(Shipitem* toAddItem);
     25            /*void AddItem(Shipitem* toAddItem);
    2626            void RemoveItem(Shipitem* toRemoveItem);
    2727            bool CheckifValid(Shipitem* toBeChecked);
    2828            bool CheckifSpace();
     29            void SwitchItem(Permanent* toSwitchItem);
     30            string GetNameofPermanent (subItemTypePermanent NametoGet);*/ //holt den Namen des getragenen Items im jeweiligen Slot.
    2931
    3032        private:
    31             multimap<std::string, ShipItem*> Equipment;
    32             multimap<std::string, ShipItem*> Usable;
    33             multimap<std::string, ShipItem*> Trunk;
     33            multimap<std::string, BaseItem*> Equipment;
     34            multimap<std::string, BaseItem*> Usable;
     35            multimap<std::string, BaseItem*> Trunk;
    3436    };
    3537}
  • code/branches/presentation/src/orxonox/objects/pickup/ShipItem.cc

    r2089 r2500  
    55    itemtype ShipItem::CheckType()
    66    {
    7         return this.type;
     7        return this->type;
    88    }
    99
    1010    subItemTypePermanent CheckSubType()
    1111    {
    12         return this.subtype_permanent;
     12        return this->subtype_permanent;
    1313    }
     14
     15    subItemTypePowerups CheckSubType()
     16    {
     17        return this->subtype_powerups;
     18    }
     19    subItemTypeUsable CheckSubType()
     20    {
     21        return this->subtype_usables;
     22    }
     23
    1424}
  • code/branches/presentation/src/orxonox/objects/pickup/ShipItem.h

    r2094 r2500  
    2121        public:
    2222            itemType CheckType();
    23             virtual
     23            //virtual ChecksubType();
    2424
    2525        private:
     
    2727            string itemname;
    2828    };
    29 
    3029
    3130    /* Useables are Items the Player can choose when to activate and then show an instant action/effect
     
    3736            Rockets,
    3837            Repairkits,
    39             Triggers,           //trigger events usable by the player (Quests f.exp.)
     38            Triggers,       //trigger events usable by the player (Quests f.exp.)
    4039            Boosters,
    4140            Shields,
  • code/branches/presentation/src/orxonox/objects/pickup/Turbo.cc

    • Property svn:eol-style set to native
    r2498 r2500  
    88namespace orxonox
    99{
    10        
     10
    1111
    1212        CreateFactory(Turbo);
    1313
    14         Turbo::Turbo(BaseObject* creator) : Item(creator)
     14        Turbo::Turbo(BaseObject* creator) : BaseItem(creator)
    1515        {
    1616                RegisterObject(Turbo);
     
    3333        XMLPortParam(Turbo, "duration", setDuration, getDuration, xmlelement, mode);
    3434        XMLPortParam(Turbo, "accboost", setAccBoost, getAccBoost, xmlelement, mode);
    35         XMLPortParam(Turbo, "rotacc", setRotAcc, getRotAcc, xmlelement, mode);
    36        
     35        XMLPortParam(Turbo, "rotacc", setRotAcc, getRotAcc, xmlelement, mode);
    3736    }
    3837
    3938        bool Turbo::pickedUp(Pawn* player)
    4039        {
    41                
     40
    4241                if(player-> isA(this->getPlayerBaseClass()))
    4342                        {
    4443                        SpaceShip* ship = dynamic_cast <SpaceShip*>(player);
    4544                        if(duration_==0 )
    46                         {       
     45                        {
    4746                                if(addTo(player))
    48                                 {       
     47                                {
    4948                                                COUT(3)<<"ITEM EQUIPPED"<<std::endl;
    5049                                                this->setSpeedBoost(ship);
     
    6362
    6463        }
    65        
    66        
     64
     65
    6766        void Turbo::unsetSpeedBoost(SpaceShip* ship)
    6867        {
     68/*
    6969        ship->setMaxSpeed( ship->getMaxSpeed() - this->boost_);
    7070        ship->setTransAcc( ship->getTransAcc()/this->accboost_);
     
    7373        COUT(3)<<"BOOST UNSET"<<std::endl;
    7474        COUT(3)<<"Speed:"<< ship->getMaxSpeed()<<std::endl;
     75*/
     76        ship->setPermanentBoost(false);
    7577        }
    7678
    7779        void Turbo::setSpeedBoost(SpaceShip* ship)
    7880        {
     81/*
    7982        COUT(3)<<"Speed:"<< ship->getMaxSpeed()<<std::endl;
    8083        ship->setMaxSpeed( ship->getMaxSpeed() + this->boost_);
     
    8285        ship->setMaxRotation( ship->getMaxRotation()+this->rotacc_);
    8386        ship->setRotAcc( ship->getRotAcc()+this->rotacc_);
     87*/
     88    ship->setPermanentBoost(true);
     89    ship->setBoost(true);
     90
    8491        if( this->duration_ != 0)
    8592        {
     
    8895                turbotimer_.setTimer(this->duration_, false, this, executor);
    8996        }
    90         COUT(3)<<"Speed:"<< ship->getMaxSpeed()<<std::endl;
     97//      COUT(3)<<"Speed:"<< ship->getMaxSpeed()<<std::endl;
    9198        }
    9299        bool Turbo::dropped(Pawn* player)
     
    99106                        SpaceShip* ship = dynamic_cast <SpaceShip*>(player);
    100107                        this->unsetSpeedBoost(ship);
    101                         }       
     108                        }
    102109                }
    103110                return true;
    104111        }
    105        
     112
    106113}
    107114/*<Template baseclass="Turbo" name=turboitem>
     
    115122    </PickupSpawner>*/
    116123
    117        
    118        
    119        
    120        
     124
     125
     126
     127
  • code/branches/presentation/src/orxonox/objects/pickup/Turbo.h

    • Property svn:eol-style set to native
    r2498 r2500  
    33
    44#include "tools/Timer.h"
    5 #include "Item.h"
     5#include "BaseItem.h"
    66#include "OrxonoxPrereqs.h"
    77#include "util/Math.h"
     
    99namespace orxonox
    1010{
    11         class _OrxonoxExport Turbo : public Item
     11        class _OrxonoxExport Turbo : public BaseItem
    1212        {
    13        
     13
    1414        public:
    1515        Turbo(BaseObject* creator);
     
    3939                { return this->rotacc_; }
    4040
    41        
     41
    4242        inline void setAccBoost(float accboost)
    4343                { this->accboost_ = accboost; }
  • code/branches/presentation/src/orxonox/objects/pickup/Usable.h

Note: See TracChangeset for help on using the changeset viewer.