Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/presentation2012merge/src/orxonox/gametypes/Gametype.cc @ 9339

Last change on this file since 9339 was 9339, checked in by jo, 12 years ago

Found reason why players are not always detected correctly: numberOfPlayers only count players that have been added before the gametype started.

  • Property svn:eol-style set to native
File size: 16.2 KB
RevLine 
[2072]1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29#include "Gametype.h"
30
[3196]31#include "util/Math.h"
[8079]32#include "core/Core.h"
[2072]33#include "core/CoreIncludes.h"
[2662]34#include "core/ConfigValueIncludes.h"
[2896]35#include "core/GameMode.h"
[7284]36#include "core/command/ConsoleCommand.h"
[3196]37
[5735]38#include "infos/PlayerInfo.h"
39#include "infos/Bot.h"
[5737]40#include "graphics/Camera.h"
[5735]41#include "worldentities/ControllableEntity.h"
42#include "worldentities/SpawnPoint.h"
43#include "worldentities/pawns/Spectator.h"
44#include "worldentities/pawns/Pawn.h"
[3196]45#include "overlays/OverlayGroup.h"
[2072]46
47namespace orxonox
48{
49    CreateUnloadableFactory(Gametype);
50
[5929]51    Gametype::Gametype(BaseObject* creator) : BaseObject(creator)
[2072]52    {
53        RegisterObject(Gametype);
[6417]54
[5929]55        this->gtinfo_ = new GametypeInfo(creator);
[2072]56
[5929]57        this->setGametype(SmartPtr<Gametype>(this, false));
[2662]58
[2072]59        this->defaultControllableEntity_ = Class(Spectator);
60
61        this->bAutoStart_ = false;
62        this->bForceSpawn_ = false;
[2662]63        this->numberOfBots_ = 0;
[2072]64
[3033]65        this->timeLimit_ = 0;
66        this->time_ = 0;
67        this->timerIsActive_ = false;
68
[2072]69        this->initialStartCountdown_ = 3;
[2662]70
71        this->setConfigValues();
72
73        // load the corresponding score board
[6417]74        if (GameMode::showsGraphics() && !this->scoreboardTemplate_.empty())
[2662]75        {
76            this->scoreboard_ = new OverlayGroup(this);
77            this->scoreboard_->addTemplate(this->scoreboardTemplate_);
78            this->scoreboard_->setGametype(this);
79        }
80        else
81            this->scoreboard_ = 0;
[7801]82
83        /* HACK HACK HACK */
84        this->dedicatedAddBots_ = createConsoleCommand( "dedicatedAddBots", createExecutor( createFunctor(&Gametype::addBots, this) ) );
85        this->dedicatedKillBots_ = createConsoleCommand( "dedicatedKillBots", createExecutor( createFunctor(&Gametype::killBots, this) ) );
86        /* HACK HACK HACK */
[2072]87    }
[6417]88
[5929]89    Gametype::~Gametype()
90    {
91        if (this->isInitialized())
92        {
93            this->gtinfo_->destroy();
[7801]94            if( this->dedicatedAddBots_ )
95                delete this->dedicatedAddBots_;
96            if( this->dedicatedKillBots_ )
97                delete this->dedicatedKillBots_;
[5929]98        }
99    }
[2072]100
[2662]101    void Gametype::setConfigValues()
102    {
103        SetConfigValue(initialStartCountdown_, 3.0f);
104        SetConfigValue(bAutoStart_, false);
105        SetConfigValue(bForceSpawn_, false);
106        SetConfigValue(numberOfBots_, 0);
107        SetConfigValue(scoreboardTemplate_, "defaultScoreboard");
108    }
109
[2072]110    void Gametype::tick(float dt)
111    {
[2662]112        SUPER(Gametype, tick, dt);
[2072]113
[3033]114        //count timer
115        if (timerIsActive_)
116        {
117            if (this->timeLimit_ == 0)
118                this->time_ += dt;
119            else
120                this->time_ -= dt;
121        }
122
[8706]123        if (this->gtinfo_->isStartCountdownRunning() && !this->gtinfo_->hasStarted())
124            this->gtinfo_->countdownStartCountdown(dt);
[9260]125
[8706]126        if (!this->gtinfo_->hasStarted())
127        {
128            for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
129            {
130                // Inform the GametypeInfo that the player is ready to spawn.
131                if(it->first->isHumanPlayer() && it->first->isReadyToSpawn())
132                    this->gtinfo_->playerReadyToSpawn(it->first);
133            }
[9260]134
[2072]135            this->checkStart();
[8706]136        }
137        else if (!this->gtinfo_->hasEnded())
[2171]138            this->spawnDeadPlayersIfRequested();
[2072]139
140        this->assignDefaultPawnsIfNeeded();
141    }
142
143    void Gametype::start()
144    {
[2826]145        this->addBots(this->numberOfBots_);
146
[8706]147        this->gtinfo_->start();
[2072]148
149        this->spawnPlayersIfRequested();
150    }
151
152    void Gametype::end()
153    {
[8706]154        this->gtinfo_->end();
[3033]155
156        for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
157        {
158            if (it->first->getControllableEntity())
159            {
160                ControllableEntity* oldentity = it->first->getControllableEntity();
[3038]161
[5929]162                ControllableEntity* entity = this->defaultControllableEntity_.fabricate(oldentity);
[3033]163                if (oldentity->getCamera())
164                {
165                    entity->setPosition(oldentity->getCamera()->getWorldPosition());
166                    entity->setOrientation(oldentity->getCamera()->getWorldOrientation());
167                }
168                else
169                {
170                    entity->setPosition(oldentity->getWorldPosition());
171                    entity->setOrientation(oldentity->getWorldOrientation());
172                }
173
174                it->first->startControl(entity);
175            }
176            else
177                this->spawnPlayerAsDefaultPawn(it->first);
178        }
[2072]179    }
180
181    void Gametype::playerEntered(PlayerInfo* player)
182    {
[2662]183        this->players_[player].state_ = PlayerState::Joined;
[8706]184        this->gtinfo_->playerEntered(player);
[9339]185        orxout() << "# Players: " << this->getNumberOfPlayers() <<endl;
[2072]186    }
187
[2826]188    bool Gametype::playerLeft(PlayerInfo* player)
[2072]189    {
[2662]190        std::map<PlayerInfo*, Player>::iterator it = this->players_.find(player);
[2072]191        if (it != this->players_.end())
192        {
193            this->players_.erase(it);
[9339]194            orxout() << "# Players: " << this->getNumberOfPlayers() <<endl;
[2826]195            return true;
[2072]196        }
[2826]197        return false;
[2072]198    }
199
200    void Gametype::playerSwitched(PlayerInfo* player, Gametype* newgametype)
201    {
202    }
203
204    void Gametype::playerSwitchedBack(PlayerInfo* player, Gametype* oldgametype)
205    {
206    }
207
[2826]208    bool Gametype::playerChangedName(PlayerInfo* player)
[2072]209    {
210        if (this->players_.find(player) != this->players_.end())
211        {
212            if (player->getName() != player->getOldName())
213            {
[2826]214                return true;
[2072]215            }
216        }
[2826]217        return false;
[2072]218    }
219
220    void Gametype::pawnPreSpawn(Pawn* pawn)
221    {
222    }
223
224    void Gametype::pawnPostSpawn(Pawn* pawn)
225    {
226    }
227
[2826]228    void Gametype::playerPreSpawn(PlayerInfo* player)
[2072]229    {
[2826]230    }
[2662]231
[2826]232    void Gametype::playerPostSpawn(PlayerInfo* player)
233    {
234    }
[2662]235
[2826]236    void Gametype::playerStartsControllingPawn(PlayerInfo* player, Pawn* pawn)
237    {
238    }
239
240    void Gametype::playerStopsControllingPawn(PlayerInfo* player, Pawn* pawn)
241    {
242    }
243
244    bool Gametype::allowPawnHit(Pawn* victim, Pawn* originator)
245    {
246        return true;
247    }
248
249    bool Gametype::allowPawnDamage(Pawn* victim, Pawn* originator)
250    {
251        return true;
252    }
253
254    bool Gametype::allowPawnDeath(Pawn* victim, Pawn* originator)
255    {
256        return true;
257    }
258
259    void Gametype::pawnKilled(Pawn* victim, Pawn* killer)
260    {
[2662]261        if (victim && victim->getPlayer())
262        {
263            std::map<PlayerInfo*, Player>::iterator it = this->players_.find(victim->getPlayer());
264            if (it != this->players_.end())
265            {
266                it->second.state_ = PlayerState::Dead;
267                it->second.killed_++;
268
269                // Reward killer
[3099]270                if (killer && killer->getPlayer())
[2839]271                {
272                    std::map<PlayerInfo*, Player>::iterator it = this->players_.find(killer->getPlayer());
273                    if (it != this->players_.end())
[3099]274                    {
[2839]275                        it->second.frags_++;
[3099]276
[8327]277                        if (killer->getPlayer()->getClientID() != NETWORK_PEER_ID_UNKNOWN)
[5929]278                            this->gtinfo_->sendKillMessage("You killed " + victim->getPlayer()->getName(), killer->getPlayer()->getClientID());
[8327]279                        if (victim->getPlayer()->getClientID() != NETWORK_PEER_ID_UNKNOWN)
[5929]280                            this->gtinfo_->sendDeathMessage("You were killed by " + killer->getPlayer()->getName(), victim->getPlayer()->getClientID());
[3099]281                    }
[2839]282                }
[2662]283
[8706]284                if(victim->getPlayer()->isHumanPlayer())
285                    this->gtinfo_->pawnKilled(victim->getPlayer());
286
[2662]287                ControllableEntity* entity = this->defaultControllableEntity_.fabricate(victim->getCreator());
288                if (victim->getCamera())
289                {
290                    entity->setPosition(victim->getCamera()->getWorldPosition());
291                    entity->setOrientation(victim->getCamera()->getWorldOrientation());
292                }
293                else
294                {
295                    entity->setPosition(victim->getWorldPosition());
296                    entity->setOrientation(victim->getWorldOrientation());
297                }
298                it->first->startControl(entity);
299            }
300            else
[8858]301                orxout(internal_warning) << "Killed Pawn was not in the playerlist" << endl;
[2662]302        }
[2072]303    }
304
[9339]305    void Gametype::playerScored(PlayerInfo* player, int score)
[2072]306    {
[2826]307        std::map<PlayerInfo*, Player>::iterator it = this->players_.find(player);
308        if (it != this->players_.end())
[9339]309            it->second.frags_ += score;
[2072]310    }
311
[2890]312    int Gametype::getScore(PlayerInfo* player) const
313    {
314        std::map<PlayerInfo*, Player>::const_iterator it = this->players_.find(player);
315        if (it != this->players_.end())
316            return it->second.frags_;
317        else
318            return 0;
319    }
320
[2072]321    SpawnPoint* Gametype::getBestSpawnPoint(PlayerInfo* player) const
322    {
[8706]323        // If there is at least one SpawnPoint.
[2072]324        if (this->spawnpoints_.size() > 0)
325        {
[8706]326            // Fallback spawn point if there is no active one, choose a random one.
[7163]327            SpawnPoint* fallbackSpawnPoint = NULL;
[3196]328            unsigned int randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(this->spawnpoints_.size())));
[2072]329            unsigned int index = 0;
[8706]330            std::vector<SpawnPoint*> activeSpawnPoints;
[2072]331            for (std::set<SpawnPoint*>::const_iterator it = this->spawnpoints_.begin(); it != this->spawnpoints_.end(); ++it)
332            {
333                if (index == randomspawn)
[7163]334                    fallbackSpawnPoint = (*it);
335
[8706]336                if (*it != NULL && (*it)->isActive())
337                    activeSpawnPoints.push_back(*it);
[7163]338
339                ++index;
340            }
341
[8706]342            if(activeSpawnPoints.size() > 0)
[7163]343            {
[8706]344                randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(activeSpawnPoints.size())));
345                return activeSpawnPoints[randomspawn];
[2072]346            }
[7163]347
[8858]348            orxout(internal_warning) << "Fallback SpawnPoint was used because there were no active SpawnPoints." << endl;
[7163]349            return fallbackSpawnPoint;
[2072]350        }
351        return 0;
352    }
353
[2171]354    void Gametype::assignDefaultPawnsIfNeeded()
[2072]355    {
[2662]356        for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
[2072]357        {
[2662]358            if (!it->first->getControllableEntity())
[2072]359            {
[2662]360                it->second.state_ = PlayerState::Dead;
361
[8706]362                if (!it->first->isReadyToSpawn() || !this->gtinfo_->hasStarted())
[2072]363                {
[3033]364                    this->spawnPlayerAsDefaultPawn(it->first);
365                    it->second.state_ = PlayerState::Dead;
[2072]366                }
367            }
368        }
369    }
370
371    void Gametype::checkStart()
372    {
[8706]373        if (!this->gtinfo_->hasStarted())
[2072]374        {
[8706]375            if (this->gtinfo_->isStartCountdownRunning())
[2072]376            {
[8706]377                if (this->gtinfo_->getStartCountdown() <= 0.0f)
[2072]378                {
[8706]379                    this->gtinfo_->stopStartCountdown();
[9016]380                    this->gtinfo_->setStartCountdown(0.0f);
[2072]381                    this->start();
382                }
383            }
384            else if (this->players_.size() > 0)
385            {
386                if (this->bAutoStart_)
387                {
388                    this->start();
389                }
390                else
391                {
392                    bool allplayersready = true;
[2662]393                    bool hashumanplayers = false;
394                    for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
[2072]395                    {
[2171]396                        if (!it->first->isReadyToSpawn())
[2072]397                            allplayersready = false;
[2662]398                        if (it->first->isHumanPlayer())
399                            hashumanplayers = true;
[2072]400                    }
[9260]401
[2662]402                    if (allplayersready && hashumanplayers)
[2072]403                    {
[8079]404                        // If in developer's mode, there is no start countdown.
405                        if(Core::getInstance().inDevMode())
[8706]406                            this->start();
[8079]407                        else
[9261]408                        {
[8706]409                            this->gtinfo_->setStartCountdown(this->initialStartCountdown_);
[9261]410                            this->gtinfo_->startStartCountdown();
411                        }
[2072]412                    }
413                }
414            }
415        }
416    }
417
418    void Gametype::spawnPlayersIfRequested()
419    {
[2662]420        for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
[8706]421        {
[2171]422            if (it->first->isReadyToSpawn() || this->bForceSpawn_)
423                this->spawnPlayer(it->first);
[8706]424        }
[2072]425    }
426
427    void Gametype::spawnDeadPlayersIfRequested()
428    {
[2662]429        for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
430            if (it->second.state_ == PlayerState::Dead)
[2171]431                if (it->first->isReadyToSpawn() || this->bForceSpawn_)
432                    this->spawnPlayer(it->first);
[2072]433    }
434
435    void Gametype::spawnPlayer(PlayerInfo* player)
436    {
437        SpawnPoint* spawnpoint = this->getBestSpawnPoint(player);
438        if (spawnpoint)
439        {
[2826]440            this->playerPreSpawn(player);
[2072]441            player->startControl(spawnpoint->spawn());
[2662]442            this->players_[player].state_ = PlayerState::Alive;
[8706]443
444            if(player->isHumanPlayer())
445                this->gtinfo_->playerSpawned(player);
[9016]446
[2826]447            this->playerPostSpawn(player);
[2072]448        }
449        else
450        {
[8858]451            orxout(user_error) << "No SpawnPoints in current Gametype" << endl;
[2072]452            abort();
453        }
454    }
[2662]455
[3033]456    void Gametype::spawnPlayerAsDefaultPawn(PlayerInfo* player)
457    {
458        SpawnPoint* spawn = this->getBestSpawnPoint(player);
459        if (spawn)
460        {
461            // force spawn at spawnpoint with default pawn
462            ControllableEntity* entity = this->defaultControllableEntity_.fabricate(spawn);
463            spawn->spawn(entity);
464            player->startControl(entity);
465        }
466        else
467        {
[8858]468            orxout(user_error) << "No SpawnPoints in current Gametype" << endl;
[3033]469            abort();
470        }
471    }
472
[2662]473    void Gametype::addBots(unsigned int amount)
474    {
475        for (unsigned int i = 0; i < amount; ++i)
[2839]476            this->botclass_.fabricate(this);
[2662]477    }
478
479    void Gametype::killBots(unsigned int amount)
480    {
481        unsigned int i = 0;
482        for (ObjectList<Bot>::iterator it = ObjectList<Bot>::begin(); (it != ObjectList<Bot>::end()) && ((amount == 0) || (i < amount)); )
483        {
484            if (it->getGametype() == this)
485            {
[5929]486                (it++)->destroy();
[2662]487                ++i;
488            }
[5929]489            else
490                ++it;
[2662]491        }
492    }
[3033]493
494    void Gametype::addTime(float t)
[3038]495    {
[3033]496        if (this->timeLimit_ == 0)
497          this->time_ -= t;
498        else
499          this->time_ += t;
500    }
501
502    void Gametype::removeTime(float t)
[3038]503    {
[3033]504        if (this->timeLimit_ == 0)
505          this->time_ += t;
506        else
507          this->time_ -= t;
508    }
509
510    void Gametype::resetTimer()
[3038]511    {
[3033]512        this->resetTimer(timeLimit_);
513    }
514
515    void Gametype::resetTimer(float t)
[3038]516    {
[3033]517        this->timeLimit_ = t;
518        this->time_ = t;
519    }
[2072]520}
Note: See TracBrowser for help on using the repository browser.