Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Sep 17, 2015, 3:32:50 PM (9 years ago)
Author:
fvultier
Message:

Different wave types with different enemies. New field type: obstacle. It is impossible to build a tower on a field with an obstacle.

Location:
code/branches/towerdefenseFabien/src/modules/towerdefense
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • code/branches/towerdefenseFabien/src/modules/towerdefense/TowerDefense.cc

    r10589 r10591  
    8787namespace orxonox
    8888{
    89     static const std::string __CC_addTower_name  = "addTower";
    90     static const std::string __CC_upgradeTower_name = "upgradeTower";
    91 
    92     SetConsoleCommand("TowerDefense", __CC_addTower_name,  &TowerDefense::addTower ).addShortcut().defaultValues(1);
    93     SetConsoleCommand("TowerDefense", __CC_upgradeTower_name, &TowerDefense::upgradeTower).addShortcut().defaultValues(0);
    94 
    9589    RegisterUnloadableClass(TowerDefense);
    9690
    … …  
    10296        this->player_ = NULL;       
    10397        this->setHUDTemplate("TowerDefenseHUD");
    104         this->nextwaveTimer_.setTimer(10, false, createExecutor(createFunctor(&TowerDefense::nextwave, this)));
    105         this->nextwaveTimer_.stopTimer();
    106         this->waves_ = 0;
    107         this->time = 0;
     98        this->waveNumber_ = 0;
     99        this->timeSinceLastSpawn_ = 0.0;
     100        this->timeUntilNextWave_ = 0.0;
    108101        this->credit_ = 0;
    109102        this->lifes_ = 0;
     103        this->waveSize_ = 0;
     104        offset_ = Vector3(0,0,10);
    110105
    111106        //this->stats_ = new TowerDefensePlayerStats();
    112 
    113         ModifyConsoleCommand(__CC_addTower_name).setObject(this);
    114         ModifyConsoleCommand(__CC_upgradeTower_name).setObject(this);
    115107    }
    116108
    117109    TowerDefense::~TowerDefense()
    118     {        /* Part of a temporary hack to allow the player to add towers */
     110    {
    119111        if (this->isInitialized())
    120112        {
    121             ModifyConsoleCommand(__CC_addTower_name).setObject(NULL);
    122             ModifyConsoleCommand(__CC_upgradeTower_name).setObject(NULL);
     113
    123114        }
    124115    }
    … …  
    149140
    150141        createFields();
    151 
    152142        TeamDeathmatch::start();
    153 
    154         // Waypoints: [1,3] [10,3] [10,11] [13,11] -> add the points to a matrix so the player cant place towers on the path
    155        
    156143
    157144        //set initial credits, lifes and WaveNumber
    158145        this->setCredit(1000);
    159         this->setLifes(100);
     146        this->setLifes(100);       
     147        this->timeSinceLastSpawn_ = 0.0;
     148        this->timeUntilNextWave_ = 5.0;
     149        this->waveSize_ = 0;
    160150        this->setWaveNumber(0);
    161         time = 0.0;
    162151    }
    163152
    … …  
    165154    void TowerDefense::addTowerDefenseEnemy(int templatenr)
    166155    {
    167         orxout() << "addTowerDefenseEnemy" << endl;
    168 
    169156        TowerDefenseEnemy* en1 = new TowerDefenseEnemy(this->center_->getContext());
    170157       
    … …  
    200187        if (controller != NULL && waypoints_.size() > 1)
    201188        {
    202             en1->setPosition(waypoints_.at(0)->getPosition());
     189            en1->setPosition(waypoints_.at(0)->getPosition() + offset_);
    203190            en1->setOrientation(Vector3(0,0,10), Degree(0));
    204191            en1->setDirection(Vector3(0,1,0));
    205             en1->lookAt(waypoints_.at(1)->getPosition());
     192            en1->lookAt(waypoints_.at(1)->getPosition() + offset_);
    206193
    207194            for (unsigned int i = 0; i < waypoints_.size(); ++ i)
    208195            {
    209196                orxonox::WeakPtr<MovableEntity> waypoint = new MovableEntity(this->center_->getContext());
    210                 waypoint->setPosition(waypoints_.at(i)->getPosition());
     197                waypoint->setPosition(waypoints_.at(i)->getPosition() + offset_);
    211198                controller->addWaypoint(waypoint);
    212199            }
    … …  
    229216        assert(player);
    230217        player_ = player;
    231 
    232         orxout() << "spawnPlayer" << endl;
    233218
    234219        if (selecter->getPlayer() == NULL)
    … …  
    287272    void TowerDefense::tick(float dt)
    288273    {
    289         //orxout() << "tick1" << endl;
    290274        SUPER(TowerDefense, tick, dt);
    291         //orxout() << "tick2" << endl;
    292275
    293276        if (hasStarted() == false || player_ == NULL)
    … …  
    295278            return;
    296279        }
    297         time += dt;       
     280        timeUntilNextWave_ -= dt;
     281        timeSinceLastSpawn_ += dt;
    298282
    299283        //build/upgrade tower at selecter position
    … …  
    311295            }           
    312296        }
    313 
    314         if (time >= 1.3 * enemies_.size() && enemies_.size() < 10)
    315         {
    316             //adds different types of enemys depending on the WaveNumber
    317             addTowerDefenseEnemy(this->getWaveNumber() % 3 +1 );
    318         }
    319 
    320         //if ships are at the end they get destroyed
    321 
     297       
    322298        for (std::list<WeakPtr<TowerDefenseEnemy> >::iterator it = enemies_.begin(); it != enemies_.end(); )
    323299        {
    … …  
    326302                // the enemy was destroyed by a tower - remove it from the list
    327303                enemies_.erase(it++);
     304                addCredit(1);
    328305            }
    329306            else
    330307            {
    331                 //destroys enemys at the end of the path and reduces the life by 1. No credits gifted
     308                //if ships are at the end they get destroyed
    332309                Vector3 ship = (*it)->getRVWorldPosition();
    333310                float distance = ship.distance(endpoint_);
    334                 if(distance < 50)
     311                if(distance < 40)
    335312                {
    336                     orxout() << "enemy deleted" << endl;
    337313                    (*it)->destroy();
    338314                    enemies_.erase(it++);
    … …  
    348324                }
    349325            }
    350         }       
    351 
    352         if (enemies_.size() == 0 && !this->nextwaveTimer_.isActive())
    353         {
    354             this->nextwaveTimer_.startTimer();
    355         }
     326        } 
     327
     328        // Add new enemy?
     329        if (timeSinceLastSpawn_ >= 1.0 && waveSize_ > 0)
     330        {
     331            // Add new enemy
     332            timeSinceLastSpawn_ -= 1.0;
     333            -- waveSize_;
     334            addTowerDefenseEnemy(this->getWaveNumber() % 3 + 1);
     335        }
     336        else if (timeUntilNextWave_ <= 0.0 && waveSize_ <= 0)
     337        {
     338            //New wave
     339            ++ waveNumber_;
     340            timeSinceLastSpawn_ = 0.0;
     341
     342            timeUntilNextWave_ = waveNumber_+10;
     343            waveSize_ = waveNumber_+5;
     344        }
     345
    356346    }
    357347
    … …  
    361351        TDCoordinate coord(0,0);
    362352        TDCoordinate startCoord(0,0);
    363 
    364353        std::string fields = center_->getFields();
    365354        int pos = 0;
    … …  
    372361                fields_[i][j]->setCenterpoint(center_);
    373362                center_->attach(fields_[i][j]);
    374                 fields_[i][j]->setPosition(coord.get3dcoordinate());                
    375                 fields_[i][j]->create(fields.at(pos), fields.at(pos+1));           
     363                fields_[i][j]->setPosition(coord.get3dcoordinate());
     364                fields_[i][j]->create(fields.at(pos), fields.at(pos+1));
    376365                pos += 2;
    377366                if (fields_[i][j]->getType() == START)
    … …  
    382371            }
    383372        }
    384 
    385373        //Place waypoints along the street for the waypoint controllers of the enemies
    386374        TDCoordinate* thisCoord = &startCoord;
    … …  
    429417        return NULL;
    430418    }
    431 
    432     /*
    433     void TowerDefense::playerEntered(PlayerInfo* player)
    434     {
    435         TeamDeathmatch::playerEntered(player);
    436 
    437         const std::string& message = player->getName() + " entered the game";
    438         ChatManager::message(message);
    439     }
    440 
    441     bool TowerDefense::playerLeft(PlayerInfo* player)
    442     {
    443         bool valid_player = TeamDeathmatch::playerLeft(player);
    444 
    445         if (valid_player)
    446         {
    447             const std::string& message = player->getName() + " left the game";
    448             ChatManager::message(message);
    449         }
    450 
    451         return valid_player;
    452     }
    453 
    454 
    455     void TowerDefense::pawnKilled(Pawn* victim, Pawn* killer)
    456     {
    457         if (victim && victim->getPlayer())
    458         {
    459             std::string message;
    460             if (killer)
    461             {
    462                 if (killer->getPlayer())
    463                     message = victim->getPlayer()->getName() + " was killed by " + killer->getPlayer()->getName();
    464                 else
    465                     message = victim->getPlayer()->getName() + " was killed";
    466             }
    467             else
    468                 message = victim->getPlayer()->getName() + " died";
    469 
    470             ChatManager::message(message);
    471         }
    472 
    473         TeamDeathmatch::pawnKilled(victim, killer);
    474     }
    475 
    476     void TowerDefense::playerScored(PlayerInfo* player, int score)
    477     {
    478         Gametype::playerScored(player, score);
    479     }*/
    480419}

  • code/branches/towerdefenseFabien/src/modules/towerdefense/TowerDefense.h

    r10587 r10591  
    6161        void payCredit(int pay){ this->credit_ -= pay; }
    6262        int getLifes(){ return this->lifes_; }
    63         int getWaveNumber(){ return this->waves_; }
     63        int getWaveNumber(){ return this->waveNumber_; }
     64        void setWaveNumber(int wavenumber){ waveNumber_=wavenumber; }
    6465        void setCredit(int credit){ credit_ = credit; }
    65         void setLifes(int lifes){ lifes_ = lifes; }
    66         void setWaveNumber(int wavenumber){ waves_=wavenumber; }
    67         void buyTower(int cost){ credit_ -= cost;}
     66        void setLifes(int lifes){ lifes_ = lifes; }       
     67        void buyTower(int cost){ cost -= cost;}
    6868        void addCredit(int credit) { credit_+=credit; }
    69         void nextwave(){ enemies_.clear(); waves_++; time=0;}
    7069        int reduceLifes(int NumberofLifes){ return lifes_-=NumberofLifes; }
    7170        TowerDefenseField* getField(TDCoordinate* coord){ return fields_[coord->GetX()][coord->GetY()]; }
    72         /*  Called by TowerDefenseCenterpoint upon game start
    73             The centerpoint is used to create towers
    74         */
    7571        void setCenterpoint(TowerDefenseCenterpoint* centerpoint);       
    76         /* Adds a tower at x, y in the playfield */
    7772        void addTower(int x, int y);
    7873        void upgradeTower(int x, int y);
    7974        virtual TDCoordinate* getNextStreetCoord(TDCoordinate*);
    80 
    81         //virtual void pawnKilled(Pawn* victim, Pawn* killer = 0);
    82         //virtual void playerScored(PlayerInfo* player, int score);
    83 
     75       
    8476        TowerDefenseSelecter* selecter;       
    8577
    86         //TODO: void spawnNewWave()
    87         //TODO: create a timer which regularly calls the spawnNewWave function  (time driven)
    88         //      or spawn a new wave when the old wave has been killed           (event driven)
     78    private:
     79        void createFields();
    8980
    90     private:
    9181        orxonox::WeakPtr<TowerDefenseCenterpoint> center_;
    9282        PlayerInfo* player_;
    93         float time;       
     83        float timeSinceLastSpawn_;
     84        float timeUntilNextWave_;
     85        int waveSize_;
    9486        int credit_;
    95         int waves_;
     87        int waveNumber_;
    9688        int lifes_;
    97         Timer nextwaveTimer_;
    9889        std::list<orxonox::WeakPtr<TowerDefenseEnemy> > enemies_;
    9990        TowerDefenseField* fields_[16][16];
    10091        std::vector<orxonox::WeakPtr<TowerDefenseField> > waypoints_;
    10192        Vector3 endpoint_;
    102 
    103         void createFields();
     93        Vector3 offset_;       
    10494    };
    10595}

  • code/branches/towerdefenseFabien/src/modules/towerdefense/TowerDefenseEnemy.cc

    r10586 r10591  
    3535    TowerDefenseEnemy::~TowerDefenseEnemy()
    3636    {
    37         orxout() << "TowerDefenseEnemy::~TowerDefenseEnemy" << endl;
     37
    3838    }
    3939
    … …  
    5757    void TowerDefenseEnemy::damage(float damage, float healthdamage, float shielddamage, Pawn* originator)
    5858    {
    59         orxout() << "TowerDefenseEnemy::damage" << endl;
    6059        Pawn::damage(damage, healthdamage, shielddamage, originator);
     60       
    6161        if (getGame() && once_ == false && getHealth() <= 0)
    6262        {

  • code/branches/towerdefenseFabien/src/modules/towerdefense/TowerDefenseField.cc

    r10586 r10591  
    5353        center_ = NULL;
    5454        upgrade_ = 0;
    55         setPosition(0,0,0);       
    56         model_ = new Model(getContext());
    57         model_->setScale(25);
    58         model_->pitch(Degree(90));
    59         attach(model_);
    60         setAngle(0);
     55        setPosition(0,0,0);                           
     56        modelGround_ = new Model(getContext());
     57        modelGround_->setScale(25);
     58        modelGround_->pitch(Degree(90));
     59        attach(modelGround_);
     60        modelObject_ = new Model(getContext());
     61        modelObject_->setScale(25);
     62        modelObject_->pitch(Degree(90));
     63        attach(modelObject_);
     64        setAngle(0);
    6165    }
    6266
    … …  
    125129    void TowerDefenseField::setAngle(int newAngle)
    126130    {
    127         if (model_ == NULL)
    128         {
    129             return;
    130         }
    131 
    132         switch (newAngle)
    133         {
     131        if (modelGround_ != NULL)
     132        {
     133            switch (newAngle)
     134            {
    134135            case 0:
    135                 model_->yaw(Degree(0));
     136                modelGround_->yaw(Degree(0));
    136137                angle_ = 0;
    137138                break;
    138139            case 1:
    139                 model_->yaw(Degree(90));
     140                modelGround_->yaw(Degree(90));
    140141                angle_ = 1;
    141142                break;   
    142143            case 2:
    143                 model_->yaw(Degree(180));
     144                modelGround_->yaw(Degree(180));
    144145                angle_ = 2;
    145146                break;   
    146147            case 3:
    147                 model_->yaw(Degree(270));
     148                modelGround_->yaw(Degree(270));
    148149                angle_ = 3;
    149150                break;                                           
    150         }
     151            }
     152        }
     153
     154        if (modelObject_ != NULL)
     155        {
     156            switch (newAngle)
     157            {
     158            case 0:
     159                modelObject_->yaw(Degree(0));
     160                angle_ = 0;
     161                break;
     162            case 1:
     163                modelObject_->yaw(Degree(90));
     164                angle_ = 1;
     165                break;   
     166            case 2:
     167                modelObject_->yaw(Degree(180));
     168                angle_ = 2;
     169                break;   
     170            case 3:
     171                modelObject_->yaw(Degree(270));
     172                angle_ = 3;
     173                break;                                           
     174            }
     175        }
     176       
    151177    }
    152178
    … …  
    158184    void TowerDefenseField::createFree(int orientation)
    159185    {           
    160         model_->setMeshSource("TD_F1.mesh");
     186        modelGround_->setMeshSource("TD_F1.mesh");
    161187        tower_ = NULL;
    162188        type_ = FREE;
    … …  
    167193    void TowerDefenseField::createStart(int orientation)
    168194    {     
    169         model_->setMeshSource("TD_S5.mesh");
     195        modelGround_->setMeshSource("TD_S5.mesh");
    170196        tower_ = NULL;
    171197        type_ = START;
    … …  
    177203    void TowerDefenseField::createEnd(int orientation)
    178204    {     
    179         model_->setMeshSource("TD_S4.mesh");
     205        modelGround_->setMeshSource("TD_S4.mesh");
    180206        tower_ = NULL;
    181207        type_ = END;
    … …  
    186212    void TowerDefenseField::createStraight(int orientation)
    187213    {     
    188         model_->setMeshSource("TD_S1.mesh");
     214        modelGround_->setMeshSource("TD_S1.mesh");
    189215        tower_ = NULL;
    190216        type_ = STREET;
    … …  
    195221    void TowerDefenseField::createRCurve(int orientation)
    196222    {     
    197         model_->setMeshSource("TD_S2.mesh");
     223        modelGround_->setMeshSource("TD_S2.mesh");
    198224        tower_ = NULL;
    199225        type_ = STREET;
    … …  
    204230    void TowerDefenseField::createLCurve(int orientation)
    205231    {   
    206         model_->setMeshSource("TD_S3.mesh");
     232        modelGround_->setMeshSource("TD_S3.mesh");
    207233        tower_ = NULL;
    208234        type_ = STREET;
    … …  
    210236        setAngle(orientation);
    211237    }
     238
     239    void TowerDefenseField::createObstacle(int orientation)
     240    {   
     241        modelGround_->setMeshSource("TD_F1.mesh");
     242        modelObject_->setMeshSource("TD_O1.mesh");
     243        tower_ = NULL;
     244        type_ = OBSTACLE;
     245        setUpgrade(0);
     246        setAngle(orientation);
     247    }
    212248
    213249    void TowerDefenseField::createTower(int upgrade)
    … …  
    215251        if (tower_ == NULL)
    216252        {
     253            modelGround_->setMeshSource("TD_F1.mesh");
    217254            tower_ = new TowerDefenseTower(center_->getContext());
    218255            attach(tower_);
    219256            type_ = TOWER;
    220257            setUpgrade(upgrade);
    221             if (upgrade_ > 0 && model_ != NULL)
     258            if (upgrade_ > 0 && modelObject_ != NULL)
    222259            {
    223260                switch (upgrade_)
    224261                {
    225262                    case 1:
    226                         model_->setMeshSource("TD_T1.mesh");                   
     263                        modelObject_->setMeshSource("TD_T1.mesh");                   
    227264                        tower_->addTemplate(center_->getTower1Template());
    228265                        break;
    229266                    case 2:
    230                         model_->setMeshSource("TD_T2.mesh");
     267                        modelObject_->setMeshSource("TD_T2.mesh");
    231268                        tower_->addTemplate(center_->getTower2Template());
    232269                        break;
    233270                    case 3:
    234                         model_->setMeshSource("TD_T3.mesh");
     271                        modelObject_->setMeshSource("TD_T3.mesh");
    235272                        tower_->addTemplate(center_->getTower3Template());
    236273                        break;
    237274                    case 4:
    238                         model_->setMeshSource("TD_T4.mesh");
     275                        modelObject_->setMeshSource("TD_T4.mesh");
    239276                        tower_->addTemplate(center_->getTower4Template());
    240277                        break;
    241278                    case 5:
    242                         model_->setMeshSource("TD_T5.mesh");
     279                        modelObject_->setMeshSource("TD_T5.mesh");
    243280                        tower_->addTemplate(center_->getTower5Template());
    244281                        break;
    … …  
    279316            case 'O':               
    280317                createEnd(paramInt);
    281                 break;   
     318                break;
     319            case 'Y':               
     320                createObstacle(paramInt);
     321                break;                 
    282322            case 'T':                               
    283323                createTower(paramInt);               

  • code/branches/towerdefenseFabien/src/modules/towerdefense/TowerDefenseField.h

    r10586 r10591  
    5252        START,
    5353        END,
     54        OBSTACLE,
    5455        TOWER
    5556    };
    … …  
    7778            virtual void createLCurve(int orientation);
    7879            virtual void createRCurve(int orientation);
     80            virtual void createObstacle(int orientation);
    7981            virtual void createTower(int upgrade);
    80             virtual int getAngle();
     82            virtual int getAngle();           
    8183        private:
    8284            virtual void setAngle(int newAngle);           
    … …  
    8486            int angle_;
    8587            TowerDefenseFieldType type_;
    86             Model* model_;
     88            Model* modelGround_;
     89            Model* modelObject_;
    8790            TowerDefenseTower* tower_;
    8891            TowerDefenseCenterpoint* center_;

  • code/branches/towerdefenseFabien/src/modules/towerdefense/TowerDefenseHUDController.cc

    r10258 r10591  
    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
Note: See TracChangeset for help on using the changeset viewer.