Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 10629 for code/trunk/src


Ignore:
Timestamp:
Oct 10, 2015, 4:34:26 PM (9 years ago)
Author:
fvultier
Message:

Merged towerdefenseFabien branch back to trunk. The towerdefense Minigame is now a plugin.

Location:
code/trunk/src/modules
Files:
16 added
3 deleted
22 edited

Legend:

Unmodified
Added
Removed

  • code/trunk/src/modules/towerdefense/CMakeLists.txt

    r10624 r10629  
    88  TowerDefenseEnemy.cc
    99  TowerDefenseSelecter.cc
     10  TowerDefenseField.cc
     11  TDCoordinate.cc
    1012)
    1113

  • code/trunk/src/modules/towerdefense/TDCoordinate.cc

    r10622 r10629  
    88namespace orxonox
    99{
    10     //RegisterClass(TDCoordinate);
    11 
    1210    /**
    1311    @brief
    14         Constructor. Registers and initializes the object.
     12        Constructor. Sets the default coordinates: (0,0)
    1513    */
    1614    TDCoordinate::TDCoordinate()
    1715    {
    18         //RegisterObject(TDCoordinate);
    1916        Set(0,0);
    20 
    2117    }
    2218
    … …  
    7369        coord->x= (_x-8) * tileScale;
    7470        coord->y= (_y-8) * tileScale;
    75         coord->z=100;
     71        coord->z=0;
    7672
    7773        return *coord;

  • code/trunk/src/modules/towerdefense/TDCoordinate.h

    r10624 r10629  
    22#define _TDCoordinate_H__
    33
     4#include "core/CoreIncludes.h"
    45#include "TDCoordinate.h"
    56//#include "towerdefense/TowerDefense.h"
    … …  
    2122            virtual int GetX();
    2223            virtual int GetY();
    23             virtual Vector3 get3dcoordinate(); 
     24            virtual Vector3 get3dcoordinate();
    2425
    2526        private:

  • code/trunk/src/modules/towerdefense/TowerDefense.cc

    r10624 r10629  
    7575#include "TowerDefenseTower.h"
    7676#include "TowerDefenseCenterpoint.h"
    77 //#include "TDCoordinate.h"
    7877#include "worldentities/SpawnPoint.h"
    79 #include "worldentities/pawns/Pawn.h"
    80 #include "worldentities/pawns/SpaceShip.h"
    8178#include "controllers/WaypointController.h"
    8279#include "graphics/Model.h"
    … …  
    8481#include "chat/ChatManager.h"
    8582#include "core/CoreIncludes.h"
    86 /* Part of a temporary hack to allow the player to add towers */
    87 #include "core/command/ConsoleCommandIncludes.h"
    88 #include <cmath>
    89 
    9083
    9184namespace orxonox
    9285{
    93     static const std::string __CC_addTower_name  = "addTower";
    94     static const std::string __CC_upgradeTower_name = "upgradeTower";
    95     static const int upgradeCost = 20;
    96     static const int towerCost = 20;
    97     unsigned int maxspaceships = 30;
    98     int maxspaceshipsstandard = 30;
    99 
    100 
    101 
    102     SetConsoleCommand("TowerDefense", __CC_addTower_name,  &TowerDefense::addTower ).addShortcut().defaultValues(1);
    103     SetConsoleCommand("TowerDefense", __CC_upgradeTower_name, &TowerDefense::upgradeTower).addShortcut().defaultValues(0);
    104 
    10586    RegisterUnloadableClass(TowerDefense);
    10687
    … …  
    10889    {
    10990        RegisterObject(TowerDefense);
    110 /*
    111         for (int i=0; i < 16 ; i++){
    112             for (int j = 0; j< 16 ; j++){
    113                 towermatrix[i][j] = NULL;
    114             }
    115         }*/
    116 
    117         //Timer for the waves (10 seconds between the waves)
     91
    11892        selecter = NULL;
    11993        this->player_ = NULL;       
    12094        this->setHUDTemplate("TowerDefenseHUD");
    121         this->nextwaveTimer_.setTimer(10, false, createExecutor(createFunctor(&TowerDefense::nextwave, this)));
    122         this->nextwaveTimer_.stopTimer();
    123         this->waves_ = 0;
    124         this->time = 0;
     95        this->waveNumber_ = 0;
     96        this->timeSinceLastSpawn_ = 0.0;
     97        this->timeUntilNextWave_ = 0.0;
    12598        this->credit_ = 0;
    12699        this->lifes_ = 0;
    127         this->timeSetTower_ = 0;
    128         spaceships =15;
    129         eggs=3;
    130         ufos=7;
    131         randomships=5;
    132 
    133 
    134         ModifyConsoleCommand(__CC_addTower_name).setObject(this);
    135         ModifyConsoleCommand(__CC_upgradeTower_name).setObject(this);
     100        this->waveSize_ = 0;
     101        offset_ = Vector3(0,0,10);
    136102    }
    137103
    138104    TowerDefense::~TowerDefense()
    139105    {
    140         /* Part of a temporary hack to allow the player to add towers */
    141106        if (this->isInitialized())
    142107        {
    143             ModifyConsoleCommand(__CC_addTower_name).setObject(NULL);
    144             ModifyConsoleCommand(__CC_upgradeTower_name).setObject(NULL);
     108
    145109        }
    146110    }
    … …  
    148112    void TowerDefense::setCenterpoint(TowerDefenseCenterpoint *centerpoint)
    149113    {
    150         orxout() << "Centerpoint now setting..." << endl;
    151114        this->center_ = centerpoint;
    152         orxout() << "Centerpoint now set..." << endl;
    153115    }
    154116
    155117    void TowerDefense::start()
    156     {
     118    {       
    157119        if (center_ != NULL) // There needs to be a TowerDefenseCenterpoint, i.e. the area the game takes place.
    158120        {
    … …  
    170132        }
    171133
     134        enemies_.clear();
     135
     136        createFields();
    172137        TeamDeathmatch::start();
    173138
    174         // Waypoints: [1,3] [10,3] [10,11] [13,11] -> add the points to a matrix so the player cant place towers on the path
    175         for (int i=0; i < 16 ; i++)
    176         {
    177             for (int j = 0; j< 16 ; j++)
    178             {
    179                 towerModelMatrix[i][j] = NULL;
    180                 towerTurretMatrix[i][j] = NULL;
    181             }
    182         }
    183 
    184        
    185 
    186         if (player_ != NULL)
    187         {
    188             //this->player_->startControl(selecter);
    189         }
    190         else
    191         {
    192             orxout() << "player=NULL" << endl;
    193         }
    194 
    195 
    196         Model* dummyModel = new Model(this->center_->getContext());
    197 
    198         //the path of the spacehips has to be blocked, so that no towers can be build there
    199         for (int k=0; k<3; k++)
    200             towerModelMatrix[1][k]=dummyModel;
    201         for (int l=1; l<11; l++)
    202                 towerModelMatrix[l][3]=dummyModel;
    203         for (int m=3; m<12; m++)
    204                 towerModelMatrix[10][m]=dummyModel;
    205         for (int n=10; n<14; n++)
    206                 towerModelMatrix[n][11]=dummyModel;
    207         for (int o=13; o<16; o++)
    208                 towerModelMatrix[13][o]=dummyModel;
    209 
    210 
    211139        //set initial credits, lifes and WaveNumber
    212         this->setCredit(100);
    213         this->setLifes(100);
     140        this->setCredit(1000);
     141        this->setLifes(100);       
     142        this->timeSinceLastSpawn_ = 0.0;
     143        this->timeUntilNextWave_ = 5.0;
     144        this->waveSize_ = 0;
    214145        this->setWaveNumber(0);
    215         time=0.0;
    216 
    217         /*
    218         //adds initial towers
    219         for (int i=0; i <7; i++){
    220             addTower(i+3,4);
    221         }
    222                 */
    223146    }
    224147
    225148    // Generates a TowerDefenseEnemy. Uses Template "enemytowerdefense". Sets position at first waypoint of path.
    226     void TowerDefense::addTowerDefenseEnemy(std::vector<TDCoordinate*> path, int templatenr){
    227 
    228 
     149    void TowerDefense::addTowerDefenseEnemy(int templatenr)
     150    {
    229151        TowerDefenseEnemy* en1 = new TowerDefenseEnemy(this->center_->getContext());
    230152       
    … …  
    234156            en1->addTemplate("enemytowerdefense1");
    235157            en1->setScale(3);
    236             en1->lookAt(Vector3(0,0,100000));
    237             en1->setHealth(en1->getHealth() +50 + this->getWaveNumber()*4);
     158            en1->setHealth(en1->getHealth() + this->getWaveNumber()*4);
    238159            break;
    239160
    … …  
    241162            en1->addTemplate("enemytowerdefense2");
    242163            en1->setScale(2);
    243             en1->lookAt(Vector3(0,0,100000));
    244             en1->roll(Degree(120));
    245             en1->setHealth(en1->getHealth() -30 + this->getWaveNumber()*4);
    246             //  en1->setShieldHealth(en1->getShield() = this->getWaveNumber()*2))
     164            en1->setHealth(en1->getHealth() + this->getWaveNumber()*4);
    247165            break;
    248166
    … …  
    250168            en1->addTemplate("enemytowerdefense3");
    251169            en1->setScale(1);
    252             en1->lookAt(Vector3(0,0,100000));
    253             en1->roll(Degree(120));
    254             en1->setHealth(en1->getHealth() -10 + this->getWaveNumber()*4);
     170            en1->setHealth(en1->getHealth() + this->getWaveNumber()*4);
    255171            break;
    256         }
     172        }       
    257173
    258174        en1->setTeam(2);
    259         en1->getController();
    260         en1->setPosition(path.at(0)->get3dcoordinate());       
    261         TowerDefenseEnemyvector.push_back(en1);
    262 
    263         for(unsigned int i = 0; i < path.size(); ++i)
    264         {
    265             en1->addWaypoint((path.at(i)));
    266         }
     175
     176        WaypointController* controller = (WaypointController*)(en1->getXMLController());
     177
     178        if (controller != NULL && waypoints_.size() > 1)
     179        {
     180            en1->setPosition(waypoints_.at(0)->getPosition() + offset_);
     181            en1->setOrientation(Vector3(0,0,10), Degree(0));
     182            en1->setDirection(Vector3(0,1,0));
     183            en1->lookAt(waypoints_.at(1)->getPosition() + offset_);
     184
     185            for (unsigned int i = 0; i < waypoints_.size(); ++ i)
     186            {
     187                orxonox::WeakPtr<MovableEntity> waypoint = new MovableEntity(this->center_->getContext());
     188                waypoint->setPosition(waypoints_.at(i)->getPosition() + offset_);
     189                controller->addWaypoint(waypoint);
     190            }
     191        }
     192
     193        enemies_.push_back(en1);
    267194    }
    268195
    … …  
    279206    {
    280207        assert(player);
    281         this->player_ = player;
     208        player_ = player;
    282209
    283210        if (selecter->getPlayer() == NULL)
    284211        {
    285             this->player_ = player;
    286             player->startControl(selecter);
     212            player_->startControl(selecter);
    287213            players_[player].state_ = PlayerState::Alive;
    288214        }
    … …  
    301227
    302228    //not working yet
    303     void TowerDefense::upgradeTower(int x,int y)
     229    void TowerDefense::addTower(int x,int y)
    304230    {
    305231        TDCoordinate* coord = new TDCoordinate(x,y);
    306232        x = coord->GetX();
    307233        y = coord->GetY();
    308        
    309 
    310         if (!this->hasEnoughCreditForTower(upgradeCost))
    311         {
    312             orxout() << "not enough credit: " << (this->getCredit()) << " available, " << upgradeCost << " needed.";
    313             return;
    314         }
    315 
    316 
    317         Model* dummyModel2 = new Model(this->center_->getContext());
    318 
    319         if (towerModelMatrix [x][y] == NULL || (towerModelMatrix [x][y])->getMeshSource() == dummyModel2->getMeshSource())
    320         {
    321             orxout() << "no tower on this position" << endl;
    322             return;
    323         }
    324 
    325         else
    326         {
    327             (towerTurretMatrix [x][y])->upgradeTower();
    328             switch(towerTurretMatrix[x][y]->upgrade)
    329                    {
    330                    case 1 :
    331                            towerModelMatrix[x][y]->setMeshSource("TD_T2.mesh");
    332                            break;
    333 
    334                    case 2 :
    335                            towerModelMatrix[x][y]->setMeshSource("TD_T3.mesh");
    336                            break;
    337                    case 3 :
    338                            towerModelMatrix[x][y]->setMeshSource("TD_T4.mesh");
    339                            break;
    340                    case 4 :
    341                            towerModelMatrix[x][y]->setMeshSource("TD_T5.mesh");
    342                            break;
    343 
    344                    }
    345 
    346             this->buyTower(upgradeCost);
     234
     235        int cost = center_->getTowerCost(1);
     236
     237        if (fields_[x][y]->isFree() == true && getCredit() >= cost)
     238        {
     239            payCredit(cost);
     240            fields_[x][y]->createTower(1);
    347241        }
    348242    }
    … …  
    352246    */
    353247
    354     void TowerDefense::addTower(int x, int y)
    355     {       
     248    void TowerDefense::upgradeTower(int x, int y)
     249    {   
    356250        TDCoordinate* coord = new TDCoordinate(x,y);
    357251        x = coord->GetX();
    358         y = coord->GetY();
    359 
    360 
    361         if (!this->hasEnoughCreditForTower(towerCost))
    362         {
    363             orxout() << "not enough credit: " << (this->getCredit()) << " available, " << towerCost << " needed.";
     252        y = coord->GetY();     
     253
     254        int cost = center_->getTowerCost(fields_[x][y]->getUpgrade() + 1);
     255
     256        if (fields_[x][y]->isFree() == false && fields_[x][y]->canUpgrade() == true && getCredit() >= cost)
     257        {
     258            payCredit(cost);
     259            fields_[x][y]->upgrade();
     260        }
     261    }   
     262
     263    void TowerDefense::tick(float dt)
     264    {
     265        SUPER(TowerDefense, tick, dt);
     266
     267        if (hasStarted() == false || player_ == NULL)
     268        {
    364269            return;
    365270        }
    366 
    367         if (towerModelMatrix [x][y]!=NULL)
    368         {
    369             orxout() << "not possible to put tower here!!" << endl;
    370             return;
    371         }
    372 
    373 /*
    374         unsigned int width = this->center_->getWidth();
    375         unsigned int height = this->center_->getHeight();
    376 */
    377 
    378         int tileScale = (int) this->center_->getTileScale();
    379 
    380         /*if (x > 15 || y > 15 || x < 0 || y < 0)
    381         {
    382             //Hard coded: TODO: let this depend on the centerpoint's height, width and fieldsize (fieldsize doesn't exist yet)
    383             orxout() << "Can not add Tower: x and y should be between 0 and 15" << endl;
    384             return;
    385         }*/
    386 
    387         //orxout() << "Will add tower at (" << (x-8) * tileScale << "," << (y-8) * tileScale << ")" << endl;
    388         orxout() << "Will add tower at (" << x << "," << y << ")" << endl;
    389 
    390 
    391         //Create Model
    392         Model* newTowerModel = new Model(this->center_->getContext());
    393         newTowerModel->setMeshSource("TD_T1.mesh");
    394         newTowerModel->setScale(30);
    395         newTowerModel->pitch(Degree(90));
    396         newTowerModel->setPosition(static_cast<float>((x-8) * tileScale), static_cast<float>((y-8) * tileScale), 80);
    397 
    398         //Creates tower
    399         TowerDefenseTower* towernew = new TowerDefenseTower(this->center_->getContext());
    400         towernew->setPosition(static_cast<float>((x-8) * tileScale), static_cast<float>((y-8) * tileScale), 275);
    401         towernew->setGame(this);
    402         towernew->setTeam(1);
    403 
    404         //Reduce credit
    405          this->buyTower(towerCost);
    406          towerModelMatrix [x][y]= newTowerModel;
    407          towerTurretMatrix [x][y]= towernew;
    408     }   
    409 
    410     bool TowerDefense::hasEnoughCreditForTower(int towerCost)
    411     {
    412         return ((this->getCredit()) >= towerCost);
    413     }
    414 
    415 
    416     bool TowerDefense::hasEnoughCreditForUpgrade()
    417     {
    418         return true;
    419     }
    420 
    421  
    422     void TowerDefense::nextwave()
    423     {
    424 
    425         orxout() << "newwave" << endl;
    426         TowerDefenseEnemyvector.clear();
    427         waves_++;
    428         //maxspaceships = round(maxspaceshipsstandard + 0.25*(waves_));
    429         time=0;
    430 
    431         int helpnumber = 40 -(waves_);
    432         if(helpnumber <= 0) {helpnumber =1;}
    433         float numSpaceships = std::abs((rand() % 100)*5.0f*(helpnumber));
    434         float numEggs = std::abs((rand() % 100)*1.0f*(waves_));
    435         float numUfos = std::abs((rand() % 100)*1.5f*(0.5f*(waves_))) ;
    436 
    437         float totalnumber = (numSpaceships + numEggs + numUfos)*1.3f;
    438 
    439         int newspaceships = (int)(maxspaceships* numSpaceships / totalnumber);
    440         int neweggs = (int)(maxspaceships*numEggs / totalnumber);
    441         int newufos = (int)(maxspaceships*numUfos / totalnumber);
    442         int newrandomships = maxspaceships -newspaceships - neweggs - newufos;
    443         spaceships =newspaceships;
    444         eggs=neweggs;
    445         ufos=newufos;
    446         randomships=newrandomships;
    447 
    448         orxout() << spaceships << endl;
    449         orxout() << eggs << endl;
    450         orxout() << ufos << endl;
    451         orxout() << randomships << endl;
    452 
    453 
    454 
    455 
    456 
    457     }
    458 
    459     void TowerDefense::tick(float dt)
    460     {
    461         SUPER(TowerDefense, tick, dt);
    462         time +=dt;
    463         timeSetTower_ +=dt;
    464 
    465         //Check if tower has to be set (because TowerDefenseSelecter asks for it)
    466         if(timeSetTower_ >= 0.25)
    467         {
    468                 timeSetTower_ =0;
    469                         if(selecter != NULL && selecter->firePressed_)
    470                         {
    471 
    472                                 int x = selecter->selectedPos_->GetX();
    473                                 int y = selecter->selectedPos_->GetY();
    474                                 Model* dummyModel2 = new Model(this->center_->getContext());
    475 
    476 
    477 
    478                                 if(towerModelMatrix[x][y] == NULL)
    479                                 {
    480                                         addTower(x,y);
    481                                 }
    482                                 else
    483                                 {
    484                                         if(!((towerModelMatrix [x][y])->getMeshSource() == dummyModel2->getMeshSource()))
    485                                         {
    486                                                 towerTurretMatrix[x][y]->upgradeTower();
    487                                         if(towerTurretMatrix[x][y]->upgrade < towerTurretMatrix[x][y]->upgradeMax)
    488                                         {
    489                                                 int specificupgradecost = (int)(upgradeCost*(std::pow(1.5,towerTurretMatrix[x][y]->upgrade)));
    490                                                 if(this->credit_ >= specificupgradecost)
    491                                                 {
    492                                                         this->buyTower(specificupgradecost);
    493                                                                 switch(towerTurretMatrix[x][y]->upgrade)
    494                                                            {
    495                                                                    case 1 :
    496                                                                            towerModelMatrix[x][y]->setMeshSource("TD_T2.mesh");
    497                                                                            break;
    498 
    499                                                                    case 2 :
    500                                                                            towerModelMatrix[x][y]->setMeshSource("TD_T3.mesh");
    501                                                                            break;
    502                                                    case 3 :
    503                                                            towerModelMatrix[x][y]->setMeshSource("TD_T4.mesh");
    504                                                            break;
    505                                                    case 4 :
    506                                                            towerModelMatrix[x][y]->setMeshSource("TD_T5.mesh");
    507                                                            break;
    508 
    509                                                            }
    510                                                 }
    511 
    512 
    513                                         }
    514                                         }
    515                                 }
    516                                 selecter->firePressed_ = false;
    517                         }
    518         }
    519 
    520         TDCoordinate* coord1 = new TDCoordinate(1,1);
    521         std::vector<TDCoordinate*> path;
    522         path.push_back(coord1);
    523 
    524 
    525 
    526 
    527 
    528         if(time>=TowerDefenseEnemyvector.size() && TowerDefenseEnemyvector.size() < maxspaceships)
    529                 {
    530 
    531                 //adds different types of enemys depending on the WaveNumber progressively making the combination of enemys more difficult
    532                 if(spaceships>0)
    533                 {
    534                         addTowerDefenseEnemy(path, 1);
    535                         spaceships--;
    536 
    537                 }else if(ufos>0)
    538                 {
    539                         addTowerDefenseEnemy(path, 3);
    540                         ufos--;
    541                 }else if(eggs>0)
    542                 {
    543                         addTowerDefenseEnemy(path, 2);
    544                         eggs--;
    545                 }else if(randomships>0)
    546                 {
    547                         addTowerDefenseEnemy(path, rand() % 3 +1);
    548                         randomships--;
    549 
    550                 }
    551 
    552                 }
    553 
    554 
    555         Vector3* endpoint = new Vector3(500, 700, 150);
    556         //if ships are at the end they get destroyed
    557         for(unsigned int i =0; i < TowerDefenseEnemyvector.size(); ++i)
    558         {
    559             if(TowerDefenseEnemyvector.at(i) != NULL && TowerDefenseEnemyvector.at(i)->isAlive())
    560             {
    561                 //destroys enemys at the end of the path and reduces the life by 1. no credits gifted
    562 
    563                 Vector3 ship = TowerDefenseEnemyvector.at(i)->getRVWorldPosition();
    564                 float distance = ship.distance(*endpoint);
    565 
    566                 if(distance <50){
    567                     TowerDefenseEnemyvector.at(i)->destroy();
     271        timeUntilNextWave_ -= dt;
     272        timeSinceLastSpawn_ += dt;
     273
     274        //build/upgrade tower at selecter position
     275        if (selecter != NULL && selecter->buildTower_ == true)
     276        {
     277            selecter->buildTower_ = false;
     278
     279            if (getField(selecter->selectedPos_)->canUpgrade() == true)
     280            {
     281                upgradeTower(selecter->selectedPos_->GetX(), selecter->selectedPos_->GetY());
     282            }
     283            else
     284            {
     285                addTower(selecter->selectedPos_->GetX(), selecter->selectedPos_->GetY());
     286            }           
     287        }
     288       
     289        for (std::list<WeakPtr<TowerDefenseEnemy> >::iterator it = enemies_.begin(); it != enemies_.end(); )
     290        {
     291            if (*it == NULL)
     292            {
     293                // the enemy was destroyed by a tower - remove it from the list
     294                enemies_.erase(it++);
     295                addCredit(1);
     296            }
     297            else
     298            {
     299                //if ships are at the end they get destroyed
     300                Vector3 ship = (*it)->getRVWorldPosition();
     301                float distance = ship.distance(endpoint_);
     302                if(distance < 40)
     303                {
     304                    (*it)->destroy();
     305                    enemies_.erase(it++);
    568306                    this->reduceLifes(1);
    569                     this->buyTower(1);
    570                     if (this->getLifes()==0)
     307                    if (this->getLifes() == 0)
    571308                    {
    572309                        this->end();
    573310                    }
    574311                }
    575             }
    576         }
    577 
    578         //goes thorugh vector to see if an enemy is still alive. if not next wave is launched
    579         int count= 0;
    580         for(unsigned int i =0; i < TowerDefenseEnemyvector.size(); ++i)
    581         {
    582             if(TowerDefenseEnemyvector.at(i)!= NULL)
    583             {
    584                 ++count;
    585             }
    586         }
    587 
    588         if (count == 0 && !this->nextwaveTimer_.isActive())
    589             this->nextwaveTimer_.startTimer();
    590 
    591 /*            time2 +=dt;
    592         if(count== 0)
    593         {
    594             if(time2 > 10)
    595             {
    596                 TowerDefenseEnemyvector.clear();
    597                 this->nextwave();
    598                 time=0;
    599                 time2=0;
    600             }
    601         }
    602 */
    603 
    604     }
    605 
    606 
    607     // Function to test if we can add waypoints using code only. Doesn't work yet
    608 
    609     // THE PROBLEM: WaypointController's getControllableEntity() returns null, so it won't track. How do we get the controlableEntity to NOT BE NULL???
    610     /*
    611     void TowerDefense::addWaypointsAndFirstEnemy()
    612     {
    613         SpaceShip *newShip = new SpaceShip(this->center_);
    614         newShip->addTemplate("spaceshipassff");
    615 
    616         WaypointController *newController = new WaypointController(newShip);
    617         newController->setAccuracy(3);
    618 
    619         Model *wayPoint1 = new Model(newController);
    620         wayPoint1->setMeshSource("crate.mesh");
    621         wayPoint1->setPosition(7,-7,5);
    622         wayPoint1->setScale(0.2);
    623 
    624         Model *wayPoint2 = new Model(newController);
    625         wayPoint2->setMeshSource("crate.mesh");
    626         wayPoint2->setPosition(7,7,5);
    627         wayPoint2->setScale(0.2);
    628 
    629         newController->addWaypoint(wayPoint1);
    630         newController->addWaypoint(wayPoint2);
    631 
    632         // The following line causes the game to crash
    633 
    634         newShip->setController(newController);
    635 //        newController -> getPlayer() -> startControl(newShip);
    636         newShip->setPosition(-7,-7,5);
    637         newShip->setScale(0.1);
    638         //newShip->addSpeed(1);
    639 
    640 
    641 
    642 //      this->center_->attach(newShip);
    643     }
    644     */
    645     /*
    646     void TowerDefense::playerEntered(PlayerInfo* player)
    647     {
    648         TeamDeathmatch::playerEntered(player);
    649 
    650         const std::string& message = player->getName() + " entered the game";
    651         ChatManager::message(message);
    652     }
    653 
    654     bool TowerDefense::playerLeft(PlayerInfo* player)
    655     {
    656         bool valid_player = TeamDeathmatch::playerLeft(player);
    657 
    658         if (valid_player)
    659         {
    660             const std::string& message = player->getName() + " left the game";
    661             ChatManager::message(message);
    662         }
    663 
    664         return valid_player;
    665     }
    666 
    667 
    668     void TowerDefense::pawnKilled(Pawn* victim, Pawn* killer)
    669     {
    670         if (victim && victim->getPlayer())
    671         {
    672             std::string message;
    673             if (killer)
    674             {
    675                 if (killer->getPlayer())
    676                     message = victim->getPlayer()->getName() + " was killed by " + killer->getPlayer()->getName();
    677312                else
    678                     message = victim->getPlayer()->getName() + " was killed";
    679             }
    680             else
    681                 message = victim->getPlayer()->getName() + " died";
    682 
    683             ChatManager::message(message);
    684         }
    685 
    686         TeamDeathmatch::pawnKilled(victim, killer);
    687     }
    688 
    689     void TowerDefense::playerScored(PlayerInfo* player, int score)
    690     {
    691         Gametype::playerScored(player, score);
    692     }*/
     313                {
     314                    ++ it;
     315                }
     316            }
     317        } 
     318
     319        // Add new enemy?
     320        if (timeSinceLastSpawn_ >= 1.0 && waveSize_ > 0)
     321        {
     322            // Add new enemy
     323            timeSinceLastSpawn_ -= 1.0;
     324            -- waveSize_;
     325            addTowerDefenseEnemy(this->getWaveNumber() % 3 + 1);
     326        }
     327        else if (timeUntilNextWave_ <= 0.0 && waveSize_ <= 0)
     328        {
     329            //New wave
     330            ++ waveNumber_;
     331            timeSinceLastSpawn_ = 0.0;
     332
     333            timeUntilNextWave_ = waveNumber_+20;
     334            waveSize_ = waveNumber_+5;
     335        }
     336
     337    }
     338
     339    void TowerDefense::createFields()
     340    {
     341        assert(center_);
     342        TDCoordinate coord(0,0);
     343        TDCoordinate startCoord(0,0);
     344        std::string fields = center_->getFields();
     345        int pos = 0;
     346        for (int j = 15; j >= 0; --j)
     347        {
     348            for (int i = 0; i < 16; ++i)
     349            {
     350                coord.Set(i,j);
     351                fields_[i][j] = new TowerDefenseField(center_->getContext());
     352                fields_[i][j]->setCenterpoint(center_);
     353                center_->attach(fields_[i][j]);
     354                fields_[i][j]->setPosition(coord.get3dcoordinate());
     355                fields_[i][j]->create(fields.at(pos), fields.at(pos+1));
     356                pos += 2;
     357                if (fields_[i][j]->getType() == START)
     358                {
     359                    startCoord.Set(i,j);
     360                    waypoints_.push_back(fields_[i][j]);
     361                }
     362            }
     363        }
     364        //Place waypoints along the street for the waypoint controllers of the enemies
     365        TDCoordinate* thisCoord = &startCoord;
     366        TDCoordinate* nextCoord;
     367        while ((nextCoord = getNextStreetCoord(thisCoord)) != NULL)
     368        {
     369            waypoints_.push_back(fields_[nextCoord->GetX()][nextCoord->GetY()]);           
     370            thisCoord = nextCoord;
     371            endpoint_ = nextCoord->get3dcoordinate();
     372        }
     373
     374    }
     375
     376    TDCoordinate* TowerDefense::getNextStreetCoord(TDCoordinate* thisCoord)
     377    {       
     378        TowerDefenseField* thisField = fields_[thisCoord->GetX()][thisCoord->GetY()];
     379        TDCoordinate* nextCoord = new TDCoordinate(0,0);
     380
     381        if (thisField->getType() != STREET && thisField->getType() != START)
     382        {
     383            return NULL;
     384        }
     385
     386        if (thisField->getAngle() == 0)
     387        {
     388            nextCoord->Set(thisCoord->GetX(), thisCoord->GetY() - 1);
     389        }
     390        else if (thisField->getAngle() == 1)
     391        {
     392            nextCoord->Set(thisCoord->GetX() + 1, thisCoord->GetY());
     393        }
     394        else if (thisField->getAngle() == 2)
     395        {
     396            nextCoord->Set(thisCoord->GetX(), thisCoord->GetY() + 1);
     397        }
     398        else if (thisField->getAngle() == 3)
     399        {
     400            nextCoord->Set(thisCoord->GetX() - 1, thisCoord->GetY());
     401        }
     402
     403        if (thisCoord->GetX() != nextCoord->GetX() || thisCoord->GetY() != nextCoord->GetY())
     404        {
     405            return nextCoord;
     406        }
     407
     408        return NULL;
     409    }
    693410}

  • code/trunk/src/modules/towerdefense/TowerDefense.h

    r10622 r10629  
    4343#include "TowerDefenseEnemy.h"
    4444#include "util/Output.h"
    45 #include "core/object/WeakPtr.h"
    46 #include "TowerDefenseSelecter.h"
    47 #include "graphics/Camera.h"   
    48 
     45#include "TowerDefenseField.h"
    4946
    5047namespace orxonox
    … …  
    5451    public:
    5552        TowerDefense(Context* context);
    56         virtual ~TowerDefense();
    57 
    58         std::vector<orxonox::WeakPtr<TowerDefenseEnemy> > TowerDefenseEnemyvector;
    59         Model* towerModelMatrix[16][16];
    60         TowerDefenseTower* towerTurretMatrix[16][16];
    61         void addTowerDefenseEnemy(std::vector<TDCoordinate*> path, int templatenr);
     53        virtual ~TowerDefense();       
     54        void addTowerDefenseEnemy(int templatenr);
    6255        virtual void start(); //<! The function is called when the gametype starts
    6356        virtual void end();
    … …  
    6659        PlayerInfo* getPlayer(void) const;
    6760        int getCredit(){ return this->credit_; }
     61        void payCredit(int pay){ this->credit_ -= pay; }
    6862        int getLifes(){ return this->lifes_; }
    69         int getWaveNumber(){ return this->waves_; }
     63        int getWaveNumber(){ return this->waveNumber_; }
     64        void setWaveNumber(int wavenumber){ waveNumber_=wavenumber; }
    7065        void setCredit(int credit){ credit_ = credit; }
    71         void setLifes(int lifes){ lifes_ = lifes; }
    72         void setWaveNumber(int wavenumber){ waves_=wavenumber; }
    73         void buyTower(int cost){ credit_ -= cost;}
     66        void setLifes(int lifes){ lifes_ = lifes; }       
     67        void buyTower(int cost){ cost -= cost;}
    7468        void addCredit(int credit) { credit_+=credit; }
    75         void nextwave();
    7669        int reduceLifes(int NumberofLifes){ return lifes_-=NumberofLifes; }
    77         TowerDefenseSelecter* selecter;
    78         int spaceships;
    79         int eggs;
    80         int ufos;
    81         int randomships;
    82 
    83 
    84         //virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
    85         //virtual void playerScored(PlayerInfo* player, int score);
    86 
    87 
    88         /*  Called by TowerDefenseCenterpoint upon game start
    89             The centerpoint is used to create towers
    90         */
    91         void setCenterpoint(TowerDefenseCenterpoint *centerpoint);
    92 
    93         /* Adds a tower at x, y in the playfield */
     70        TowerDefenseField* getField(TDCoordinate* coord){ return fields_[coord->GetX()][coord->GetY()]; }
     71        void setCenterpoint(TowerDefenseCenterpoint* centerpoint);       
    9472        void addTower(int x, int y);
    95         void upgradeTower(int x, int y);
    96 
    97         //TODO: void spawnNewWave()
    98         //TODO: create a timer which regularly calls the spawnNewWave function  (time driven)
    99         //      or spawn a new wave when the old wave has been killed           (event driven)
    100 
     73        void upgradeTower(int x, int y);
     74        virtual TDCoordinate* getNextStreetCoord(TDCoordinate*);
     75       
     76        TowerDefenseSelecter* selecter;       
    10177
    10278    private:
    103         TowerDefenseCenterpoint *center_;
     79        void createFields();
     80
     81        orxonox::WeakPtr<TowerDefenseCenterpoint> center_;
    10482        PlayerInfo* player_;
    105         float time;
    106         float timeSetTower_;
    107 //        float time2;
     83        float timeSinceLastSpawn_;
     84        float timeUntilNextWave_;
     85        int waveSize_;
    10886        int credit_;
    109         int waves_;
     87        int waveNumber_;
    11088        int lifes_;
    111         Timer nextwaveTimer_;
    112 
    113         /* handles stats */
    114         bool hasEnoughCreditForTower(int towerCost);
    115         bool hasEnoughCreditForUpgrade();
     89        std::list<orxonox::WeakPtr<TowerDefenseEnemy> > enemies_;
     90        TowerDefenseField* fields_[16][16];
     91        std::vector<orxonox::WeakPtr<TowerDefenseField> > waypoints_;
     92        Vector3 endpoint_;
     93        Vector3 offset_;       
    11694    };
    11795}

  • code/trunk/src/modules/towerdefense/TowerDefenseCenterpoint.cc

    r10624 r10629  
    3636#include "core/CoreIncludes.h"
    3737#include "core/XMLPort.h"
     38#include "core/class/Super.h"
    3839
    3940#include "TowerDefense.h"
    … …  
    7273        XMLPortParam(TowerDefenseCenterpoint, "tileScale", setTileScale, getTileScale, xmlelement, mode);
    7374        XMLPortParam(TowerDefenseCenterpoint, "selecterTemplate", setSelecterTemplate, getSelecterTemplate, xmlelement, mode);
    74 
    75         //TODO: add XMLPortObject(TowerDefenseCenterpoint, WorldEntity, "waypoints", addWaypoint, getWaypoint,  xmlelement, mode);
    76         // This was copied and shightly modified from WaypointController.cc ; there are no getters and setters and no membervariable yet
    77         // The centerpoint should have all waypoints for "attached" to it. By using this function you can seperately add waypoints
    78         // When you spawn a new enemy you should let it be controlled by a WaypointController. And that controller should get the waypoints.
    79 
    80         // Alternatively you can manage the waypoints directly in TowerDefense.cc
     75        XMLPortParam(TowerDefenseCenterpoint, "tower1Template", setTower1Template, getTower1Template, xmlelement, mode);
     76        XMLPortParam(TowerDefenseCenterpoint, "tower2Template", setTower2Template, getTower2Template, xmlelement, mode);
     77        XMLPortParam(TowerDefenseCenterpoint, "tower3Template", setTower3Template, getTower3Template, xmlelement, mode);
     78        XMLPortParam(TowerDefenseCenterpoint, "tower4Template", setTower4Template, getTower4Template, xmlelement, mode);
     79        XMLPortParam(TowerDefenseCenterpoint, "tower5Template", setTower5Template, getTower5Template, xmlelement, mode);
     80        XMLPortParam(TowerDefenseCenterpoint, "fields", setFields, getFields, xmlelement, mode);
     81        XMLPortParam(TowerDefenseCenterpoint, "tower1Cost", setTower1Cost, getTower1Cost, xmlelement, mode);
     82        XMLPortParam(TowerDefenseCenterpoint, "tower2Cost", setTower2Cost, getTower2Cost, xmlelement, mode);
     83        XMLPortParam(TowerDefenseCenterpoint, "tower3Cost", setTower3Cost, getTower3Cost, xmlelement, mode);
     84        XMLPortParam(TowerDefenseCenterpoint, "tower4Cost", setTower4Cost, getTower4Cost, xmlelement, mode);
     85        XMLPortParam(TowerDefenseCenterpoint, "tower5Cost", setTower5Cost, getTower5Cost, xmlelement, mode);
    8186    }
    8287
    … …  
    9499        }
    95100    }
     101
     102    /**
     103    @brief
     104        Removes all blanks, tabs and returns from the string passed.
     105    */
     106    void TowerDefenseCenterpoint::trimString(std::string* str)
     107    {
     108        std::string* trimmed = new std::string("");
     109        int length = str->size();
     110        char temp;
     111        for (int i = 0; i < length; ++ i)
     112        {
     113            temp = str->at(i);
     114            if (temp != ' ' && temp != '\t' && temp != '\n')
     115            {
     116                trimmed->push_back(temp);
     117            }
     118        }
     119
     120        *str = *trimmed;
     121    }
     122
     123    const int TowerDefenseCenterpoint::getTowerCost(int upgrade) const
     124    {
     125        return towerCosts_[(upgrade%5)];
     126    }
    96127}

  • code/trunk/src/modules/towerdefense/TowerDefenseCenterpoint.h

    r10624 r10629  
    4141#include <string>
    4242#include <util/Math.h>
    43 
     43#include "TowerDefenseTower.h"
    4444#include "worldentities/MobileEntity.h"
    4545
    … …  
    6565            unsigned int getHeight(void) const
    6666                { return this->height_; }
     67            void setFields(const std::string& newFields)
     68                { this->fields_ = newFields; trimString(&fields_); }
     69            const std::string& getFields() const
     70                { return this->fields_; }                   
    6771            void setSelecterTemplate(const std::string& newTemplate)
    6872                { this->selecterTemplate_ = newTemplate; }
    6973            const std::string& getSelecterTemplate() const
    7074                { return this->selecterTemplate_; }   
     75
     76            void setTower1Template(const std::string& newTemplate)
     77                { this->towerTemplates_[0] = newTemplate;}
     78            const std::string& getTower1Template() const
     79                { return this->towerTemplates_[0]; } 
     80            void setTower2Template(const std::string& newTemplate)
     81                { this->towerTemplates_[1] = newTemplate; }
     82            const std::string& getTower2Template() const
     83                { return this->towerTemplates_[1]; }
     84            void setTower3Template(const std::string& newTemplate)
     85                { this->towerTemplates_[2] = newTemplate; }
     86            const std::string& getTower3Template() const
     87                { return this->towerTemplates_[2]; }
     88            void setTower4Template(const std::string& newTemplate)
     89                { this->towerTemplates_[3] = newTemplate; }
     90            const std::string& getTower4Template() const
     91                { return this->towerTemplates_[3]; }
     92            void setTower5Template(const std::string& newTemplate)
     93                { this->towerTemplates_[4] = newTemplate; }
     94            const std::string& getTower5Template() const
     95                { return this->towerTemplates_[4]; } 
     96
     97            void setTower1Cost(const int& newCost)
     98                { this->towerCosts_[0] = newCost;}
     99            const int& getTower1Cost() const
     100                { return this->towerCosts_[0]; } 
     101            void setTower2Cost(const int& newCost)
     102                { this->towerCosts_[1] = newCost; }
     103            const int& getTower2Cost() const
     104                { return this->towerCosts_[1]; }
     105            void setTower3Cost(const int& newCost)
     106                { this->towerCosts_[2] = newCost; }
     107            const int& getTower3Cost() const
     108                { return this->towerCosts_[2]; }
     109            void setTower4Cost(const int& newCost)
     110                { this->towerCosts_[3] = newCost; }
     111            const int& getTower4Cost() const
     112                { return this->towerCosts_[3]; }
     113            void setTower5Cost(const int& newCost)
     114                { this->towerCosts_[4] = newCost; }
     115            const int& getTower5Cost() const
     116                { return this->towerCosts_[4]; }
     117
     118            const int getTowerCost(int upgrade) const;
     119                                           
     120
    71121            /**
    72122                @brief How to convert to world coordinates, e.g. that 0,15 is not at -8,-8 but at -80,-80 (if scale would be 10)
    … …  
    80130        private:
    81131            void checkGametype();
    82 
     132            void trimString(std::string*);
    83133            std::string selecterTemplate_;
     134            std::string towerTemplates_[5];
     135            int towerCosts_[5];
     136            std::string fields_;
    84137            unsigned int width_;
    85138            unsigned int height_;

  • code/trunk/src/modules/towerdefense/TowerDefenseEnemy.cc

    r10628 r10629  
    3030        //needed to keep track of the PlayerStats coded in TowerDefense.h
    3131        this->td = orxonox_cast<TowerDefense*>(this->getGametype());
    32         once_=false;
     32        once_ = false;
     33    }
     34
     35    TowerDefenseEnemy::~TowerDefenseEnemy()
     36    {
    3337
    3438    }
    35     //add credit if enemy is destroyed
    36     TowerDefenseEnemy::~TowerDefenseEnemy(){
    3739
    38         if (this->isInitialized())
    39         {
    40                 getGame()->addCredit(1);
    41         }
     40    void TowerDefenseEnemy::tick(float dt)
     41    {   
     42        //orxout() << "TDE tick1" << endl;
     43        SUPER(TowerDefenseEnemy, tick, dt);
     44        //orxout() << "TDE tick2" << endl;
    4245    }
    4346
    44     void TowerDefenseEnemy::addWaypoint(TDCoordinate* coord)
    45     {
    46         this->Waypointsvector_.push_back(coord);
    47     }
    48 
    49 
    50     void TowerDefenseEnemy::tick(float dt)
    51     {
    52         SUPER(TowerDefenseEnemy, tick, dt);
    53     }
    54 
    55     TowerDefense* TowerDefenseEnemy::getGame()
     47    WeakPtr<TowerDefense> TowerDefenseEnemy::getGame()
    5648    {
    5749        if (game == NULL)
    … …  
    6355    }
    6456
    65     void TowerDefenseEnemy::damage(float damage, float healthdamage, float shielddamage, Pawn* originator, const btCollisionShape* cs)
     57    void TowerDefenseEnemy::damage(float damage, float healthdamage, float shielddamage, Pawn* originator)
    6658    {
    67         Pawn::damage(damage, healthdamage, shielddamage, originator, cs);
     59        Pawn::damage(damage, healthdamage, shielddamage, originator);
     60       
    6861        if (getGame() && once_ == false && getHealth() <= 0)
    6962        {
    70                 orxout() << "damagefunctionIF" << endl;
    7163            getGame()->addCredit(1);
    7264            once_ = true;
    7365        }
    74         orxout() << "damagefunction" << endl;
    75 
    7666    }
    77 
    78 /*
    79     void TowerDefenseEnemy::popWaypoint()
    80     {
    81         if(Waypointsvector_.size()>0)
    82             Waypointsvector_.pop_back();
    83     }
    84 
    85     TDCoordinate TowerDefenseEnemy::peekWaypoint()
    86     {
    87         if(Waypointsvector_.size()<=0){
    88             TDCoordinate* coord = TDCoordinate(-1,-1);
    89             return coord;
    90         }else{
    91             return Waypointsvector_.at(Waypointsvector_.size()-1);
    92 
    93         }
    94 
    95 
    96     }
    97 */
    98 
    9967}

  • code/trunk/src/modules/towerdefense/TowerDefenseEnemy.h

    r10626 r10629  
    2222#include "worldentities/pawns/SpaceShip.h"
    2323#include "util/Output.h"
    24 #include "controllers/ArtificialController.h"
    2524#include "TowerDefense.h"
    2625
    … …  
    3938
    4039        virtual void tick(float dt);
    41         void addWaypoint(TDCoordinate* coord);
    42         void popWaypoint();
    43         TDCoordinate peekWaypoint();
    44 
    45         virtual void damage(float damage, float healthdamage, float shielddamage, Pawn* originator, const btCollisionShape* cs);
    46 
     40        virtual void damage(float damage, float healthdamage, float shielddamage, Pawn* originator);
    4741
    4842    private:
    49         TowerDefense* getGame();
     43        WeakPtr<TowerDefense> getGame();
    5044        WeakPtr<TowerDefense> game;
    5145        TowerDefense* td;
    5246        bool once_;
    53         std::vector<TDCoordinate*> Waypointsvector_;
    54 
    5547    };
    5648

  • code/trunk/src/modules/towerdefense/TowerDefenseHUDController.cc

    r10624 r10629  
    5050    {
    5151        SUPER(TowerDefenseHUDController, tick, dt);
     52
    5253        const std::string& lifes = multi_cast<std::string>(this->td->getLifes());
    5354        const std::string& credits = multi_cast<std::string>(this->td->getCredit());
    … …  
    5556
    5657        if(showlives == true)
    57           this->setCaption(multi_cast<std::string>(lifes));
     58        {
     59            this->setCaption(multi_cast<std::string>(lifes));
     60        }         
    5861        else if(showcredits == true)
    59           this->setCaption(multi_cast<std::string>(credits));
     62        {
     63            this->setCaption(multi_cast<std::string>(credits));
     64        }         
    6065        else if(showwaves == true)
    61           this->setCaption(multi_cast<std::string>(wave));
    62 
    63 
     66        {
     67            this->setCaption(multi_cast<std::string>(wave));
     68        }         
    6469    }
    6570

  • code/trunk/src/modules/towerdefense/TowerDefenseSelecter.cc

    r10622 r10629  
    5151        moveLeftPressed_ = false;
    5252        moveRightPressed_ = false;
    53         firePressed_ = false;
    54         setSelectedPosition(6,6);
    55         timerSetFire_=0;
     53        boostPressed_ = false;
     54        buildTower_ = false;
     55        setSelectedPosition(0,0);     
    5656    }
    5757
    … …  
    7070        SUPER(TowerDefenseSelecter, tick, dt);
    7171
     72        time_ += dt;
    7273
    73         if (hasLocalController())
    74         {
    75                 timerSetFire_ +=dt;
     74        if (hasLocalController() && time_ >= 0.25)
     75        {   
     76            time_ = 0;
    7677
    77                 if(timerSetFire_ >= 0.25)
    78                 {
    79                         timerSetFire_ = 0;
     78            int selecterPosX = selectedPos_->GetX();
     79            int selecterPosY = selectedPos_->GetY();
    8080
    81                         int selecterPosX = selectedPos_->GetX();
    82                                 int selecterPosY = selectedPos_->GetY();
    83 
    84                                 if (moveUpPressed_ == true)
    85                                 {
    86                                         moveUpPressed_ = false;
    87                                         selectedPos_->Set(selecterPosX, selecterPosY + 1);
    88                                         updatePosition();
    89                                 }
    90                                 if (moveDownPressed_ == true)
    91                                 {
    92                                         moveDownPressed_ = false;
    93                                         selectedPos_->Set(selecterPosX, selecterPosY - 1);
    94                                         updatePosition();
    95                                 }
    96 
    97                                 if (moveLeftPressed_ == true)
    98                                 {
    99                                         moveLeftPressed_ = false;
    100                                         selectedPos_->Set(selecterPosX - 1, selecterPosY);
    101                                         updatePosition();
    102                                 }
    103                                 if (moveRightPressed_ == true)
    104                                 {
    105                                         moveRightPressed_ = false;
    106                                         selectedPos_->Set(selecterPosX + 1, selecterPosY);
    107                                         updatePosition();
    108                                 }
    109 
    110 
    111                         }
    112 
    113 
    114 
    115         }
    116      }
     81            if (moveUpPressed_ == true)
     82            {               
     83                moveUpPressed_ = false;
     84                selectedPos_->Set(selecterPosX, selecterPosY + 1);
     85                updatePosition();
     86            }
     87            if (moveDownPressed_ == true)
     88            {
     89                moveDownPressed_ = false;
     90                selectedPos_->Set(selecterPosX, selecterPosY - 1);
     91                updatePosition();
     92            }
     93            if (moveLeftPressed_ == true)
     94            {
     95                moveLeftPressed_ = false;
     96                selectedPos_->Set(selecterPosX - 1, selecterPosY);
     97                updatePosition();
     98            }
     99            if (moveRightPressed_ == true)
     100            {
     101                moveRightPressed_ = false;
     102                selectedPos_->Set(selecterPosX + 1, selecterPosY);
     103                updatePosition();
     104            }
     105            if (boostPressed_ == true)
     106            {
     107                boostPressed_ = false;
     108                buildTower_ = true;
     109            }
     110        }         
     111    }
    117112
    118113
    … …  
    157152    }
    158153
     154    void TowerDefenseSelecter::fire(unsigned int firemode)
     155    {
     156    }
     157
     158    void TowerDefenseSelecter::fired(unsigned int firemode)
     159    {
     160       
     161    }
    159162
    160163    void TowerDefenseSelecter::boost(bool bBoost)
    161164    {
    162         firePressed_ = true;
    163         orxout() << "boost" << endl;
     165        if (bBoost == true)
     166        {
     167            boostPressed_ = true;
     168        }
    164169    }
    165 
    166170
    167171    void TowerDefenseSelecter::updatePosition()
    … …  
    180184        setSelectedPosition(new TDCoordinate(x,y));
    181185    }
    182 
    183 
    184186}

  • code/trunk/src/modules/towerdefense/TowerDefenseSelecter.h

    r10622 r10629  
    4848            virtual void rotatePitch(const Vector2& value);
    4949            virtual void rotateRoll(const Vector2& value);
     50            void fire(unsigned int firemode);
     51            virtual void fired(unsigned int firemode);
    5052            virtual void boost(bool bBoost);
    5153            virtual void setSelectedPosition(TDCoordinate* newPos);
    5254            virtual void setSelectedPosition(int x, int y);
    53             bool firePressed_;
     55
     56            bool buildTower_;
    5457            TDCoordinate* selectedPos_;
    55 
    56 
    5758        private:           
    58             virtual void updatePosition();
    59             float timerSetFire_;
     59            virtual void updatePosition();                       
     60            float time_;
    6061            bool moveUpPressed_;
    6162            bool moveDownPressed_;
    6263            bool moveLeftPressed_;
    63             bool moveRightPressed_;           
     64            bool moveRightPressed_;                       
     65            bool boostPressed_;           
    6466    };
    6567}

  • code/trunk/src/modules/towerdefense/TowerDefenseTower.cc

    r10622 r10629  
    2727        game_ =NULL;
    2828        this->setCollisionType(WorldEntity::None);
    29         upgrade = 0;
    30         this->addTemplate("towerdefensetower");
    31 
    32         upgradeMax = 5;
    33 
     29        upgrade = 1;
    3430
    3531        //this->removeAllEngines();
    … …  
    6258    bool TowerDefenseTower::upgradeTower()
    6359    {
    64         if(upgrade < upgradeMax)
     60        if(upgrade < 5)
    6561        {
    6662            upgrade++;
    6763            float reloadrate = getReloadRate();
    6864            float reloadwaittime = getReloadWaitTime();
    69             this->setDamageMultiplier((upgrade+1)*1.5f);
    70             this->setRotationThrust(2*this->getRotationThrust());
    71             reloadrate = 0.7f*reloadrate;
    72             reloadwaittime = 0.7f*reloadwaittime;
     65            this->setDamageMultiplier((upgrade+1)*2);
     66            //this->setRotationThrust(2*this->getRotationThrust());
     67            reloadrate = 0.5f*reloadrate;
     68            reloadwaittime = 0.5f*reloadwaittime;
    7369            setReloadRate(reloadrate);
    7470            setReloadWaitTime(reloadwaittime);

  • code/trunk/src/modules/towerdefense/TowerDefenseTower.h

    r10622 r10629  
    1919
    2020#include "towerdefense/TowerDefensePrereqs.h"
    21 #include "worldentities/pawns/SpaceShip.h"
    2221#include "objects/Turret.h"
    2322
    … …  
    3837
    3938        // Overriding these to stop TowerDefenseTowers from spasing out
    40         /*
    41         void setOrientation(const Quaternion& orientation);
    42         virtual void rotateYaw(const Vector2& value);
    43         virtual void rotatePitch(const Vector2& value);
    44         virtual void rotateRoll(const Vector2& value);
    45         */
     39        //void setOrientation(const Quaternion& orientation);
     40        //virtual void rotateYaw(const Vector2& value);
     41        //virtual void rotatePitch(const Vector2& value);
     42        //virtual void rotateRoll(const Vector2& value);
    4643        virtual bool upgradeTower();
    4744
    … …  
    4946        void setGame(TowerDefense* Towerdefense)
    5047        { assert(Towerdefense); game_ = Towerdefense; }
    51         int upgrade;
    52         int upgradeMax;
    5348    private:
    5449        TowerDefense* game_;
    55 
     50        int upgrade;
    5651    };
    5752}

  • code/trunk/src/modules/weapons/CMakeLists.txt

    r7163 r10629  
    22  MuzzleFlash.cc
    33  RocketController.cc
     4  IceGunFreezer.cc
    45)
    56

  • code/trunk/src/modules/weapons/munitions/CMakeLists.txt

    r10622 r10629  
    55  RocketMunition.cc
    66  GravityBombMunition.cc
     7  IceMunition.cc
     8  SplitMunition.cc
    79)

  • code/trunk/src/modules/weapons/projectiles/BillboardProjectile.cc

    r9667 r10629  
    8888    /**
    8989    @brief
     90        Get the material of the BillboardProjectile.
     91    @return
     92        The material name.
     93    */
     94    const std::string& BillboardProjectile::getMaterial()
     95    {
     96        return this->billboard_.getMaterial();
     97    }
     98
     99    /**
     100    @brief
    90101        Is called when the visibility of the BillboardProjectile has changed.
    91102    */

  • code/trunk/src/modules/weapons/projectiles/BillboardProjectile.h

    r9667 r10629  
    6060            virtual void setColour(const ColourValue& colour);
    6161            virtual void setMaterial(const std::string& material);
     62            virtual const std::string& getMaterial();
    6263            virtual void changedVisibility();
    6364

  • code/trunk/src/modules/weapons/projectiles/CMakeLists.txt

    r10622 r10629  
    55  Projectile.cc
    66  LightningGunProjectile.cc
     7  SplitGunProjectile.cc
     8  IceGunProjectile.cc
    79  Rocket.cc
    810  RocketOld.cc

  • code/trunk/src/modules/weapons/projectiles/Projectile.cc

    r10287 r10629  
    3939#include "core/command/Executor.h"
    4040
    41 #include "objects/collisionshapes/SphereCollisionShape.h"
    4241#include "worldentities/pawns/Pawn.h"
    4342
    … …  
    6059            this->setCollisionType(Dynamic);
    6160
    62             SphereCollisionShape* shape = new SphereCollisionShape(this->getContext());
    63             shape->setRadius(20.0f);
    64             this->attachCollisionShape(shape);
     61            // Create a sphere collision shape and attach it to the projectile.
     62            collisionShape_ = new SphereCollisionShape(this->getContext());
     63            setCollisionShapeRadius(20.0f);
     64            this->attachCollisionShape(collisionShape_);
    6565
    6666            this->destroyTimer_.setTimer(this->lifetime_, false, createExecutor(createFunctor(&BasicProjectile::destroyObject, this)));
    … …  
    7676        SetConfigValue(lifetime_, 4.0f).description("The time in seconds a projectile stays alive");
    7777    }
    78 
    7978
    8079    void Projectile::tick(float dt)
    … …  
    9392    }
    9493
     94    void Projectile::setCollisionShapeRadius(float radius)
     95    {
     96        if (collisionShape_ != NULL && radius > 0)
     97        {
     98            collisionShape_->setRadius(radius);
     99        }       
     100    }
    95101}

  • code/trunk/src/modules/weapons/projectiles/Projectile.h

    r10216 r10629  
    3939#include "tools/Timer.h"
    4040#include "worldentities/MovableEntity.h"
     41#include "objects/collisionshapes/SphereCollisionShape.h"
    4142
    4243#include "BasicProjectile.h"
    … …  
    6667            virtual bool collidesAgainst(WorldEntity* otherObject, const btCollisionShape* cs, btManifoldPoint& contactPoint);
    6768
     69        protected:
     70            virtual void setCollisionShapeRadius(float radius);
     71
    6872        private:
    6973            float lifetime_; //!< The time the projectile exists.
    7074            Timer destroyTimer_; //!< Timer to destroy the projectile after its lifetime has run out.
     75            WeakPtr<SphereCollisionShape> collisionShape_; // The collision shape of the projectile.           
    7176    };
    7277}

  • code/trunk/src/modules/weapons/weaponmodes/CMakeLists.txt

    r10622 r10629  
    55  HsW01.cc
    66  LightningGun.cc
     7  SplitGun.cc
     8  IceGun.cc
    79  RocketFire.cc
    810  RocketFireOld.cc
Note: See TracChangeset for help on using the changeset viewer.