Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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}
Note: See TracChangeset for help on using the changeset viewer.