Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/branches/terrain.old/src/util/multiplayer_team_deathmatch.cc @ 9412

Last change on this file since 9412 was 9140, checked in by bensch, 18 years ago

merged back

File size: 19.4 KB
Line 
1/*
2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2004 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11### File Specific:
12   main-programmer: Patrick Boenzli
13*/
14
15#define DEBUG_MODULE_GAME_RULES
16
17#include <map>
18
19#include "multiplayer_team_deathmatch.h"
20
21#include "util/loading/load_param.h"
22#include "util/loading/factory.h"
23
24#include "render2D/image_plane.h"
25#include "state.h"
26#include "class_list.h"
27
28#include "player.h"
29#include "playable.h"
30#include "space_ships/space_ship.h"
31
32
33#include "shared_network_data.h"
34#include "terrain_entity.h"
35#include "class_list.h"
36#include "space_ships/space_ship.h"
37
38#include "network_game_manager.h"
39
40#include "event_handler.h"
41
42#include "glgui.h"
43
44#include "story_entity.h"
45
46#include "shell_command.h"
47
48#include "spawning_point.h"
49
50
51using namespace std;
52
53
54CREATE_FACTORY(MultiplayerTeamDeathmatch, CL_MULTIPLAYER_TEAM_DEATHMATCH);
55
56
57/**
58 * constructor
59 */
60MultiplayerTeamDeathmatch::MultiplayerTeamDeathmatch(const TiXmlElement* root)
61  : NetworkGameRules(root)
62{
63  this->setClassID(CL_MULTIPLAYER_TEAM_DEATHMATCH, "MultiplayerTeamDeathmatch");
64
65  this->bLocalPlayerDead = false;
66  this->deathTimeout = 10.0f;     // 5 seconds
67  this->timeout = 0.0f;
68  this->numTeams = 2;
69  this->currentGameState = GAMESTATE_PRE_GAME;
70  this->gameStateTimer = 3.0f;
71  this->bShowTeamChange = false;
72
73  this->box = NULL;
74  this->table = NULL;
75  this->statsBox = NULL;
76
77  this->localPlayer = State::getPlayer();
78
79  if( root != NULL)
80    this->loadParams(root);
81
82  subscribeEvent( ES_GAME, SDLK_o );
83  subscribeEvent( ES_GAME, SDLK_TAB );
84  subscribeEvent( ES_GAME, SDLK_F1 );
85  subscribeEvent( ES_MENU, KeyMapper::PEV_FIRE1 );
86
87  this->input = new OrxGui::GLGuiInputLine();
88  this->input->setAbsCoor2D(180, 5);
89  this->input->connect(SIGNAL(input, enterPushed), this, SLOT(MultiplayerTeamDeathmatch, onInputEnter));
90}
91
92/**
93 * decontsructor
94 */
95MultiplayerTeamDeathmatch::~MultiplayerTeamDeathmatch()
96{
97  unsubscribeEvent( ES_GAME, SDLK_o );
98  unsubscribeEvent( ES_GAME, SDLK_TAB );
99  unsubscribeEvent( ES_GAME, SDLK_F1 );
100  unsubscribeEvent( ES_MENU, KeyMapper::PEV_FIRE1 );
101
102  if ( this->input )
103  {
104    delete this->input;
105    this->input = NULL;
106  }
107}
108
109
110
111void MultiplayerTeamDeathmatch::loadParams(const TiXmlElement* root)
112{
113  GameRules::loadParams(root) ;
114
115  LoadParam(root, "death-penalty-timeout", this, MultiplayerTeamDeathmatch, setDeathPenaltyTimeout)
116      .describe("sets the time in seconds a player has to wait for respawn");
117
118  LoadParam(root, "max-kills", this, MultiplayerTeamDeathmatch, setMaxKills)
119      .describe("sets the maximal kills for winning condition");
120
121  LoadParam(root, "num-teams", this, MultiplayerTeamDeathmatch, setNumTeams)
122      .describe("sets number of teams");
123
124}
125
126
127/**
128 * time tick
129 * @param dt time
130 */
131void MultiplayerTeamDeathmatch::tick(float dt)
132{
133  tickStatsTable();
134  //on client side hostId is -1 until hanshake finished
135  if ( SharedNetworkData::getInstance()->getHostID() < 0 )
136    return;
137
138  if ( currentGameState == GAMESTATE_PRE_GAME || currentGameState == GAMESTATE_GAME )
139  {
140    if ( PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )
141         && box == NULL
142         &&  (PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )->getPreferedTeamId() == TEAM_NOTEAM
143         || bShowTeamChange )
144
145       )
146    {
147      EventHandler::getInstance()->pushState( ES_MENU );
148
149      OrxGui::GLGuiHandler::getInstance()->activateCursor();
150
151      box = new OrxGui::GLGuiBox();
152      box->setAbsCoor2D( 300, 100 );
153
154      OrxGui::GLGuiPushButton * buttonSpectator = new OrxGui::GLGuiPushButton("Spectator");
155      box->pack( buttonSpectator );
156      buttonSpectator->connect(SIGNAL(buttonSpectator, released), this, SLOT(MultiplayerTeamDeathmatch, onButtonSpectator));
157
158      OrxGui::GLGuiPushButton * buttonRandom = new OrxGui::GLGuiPushButton("Random");
159      box->pack( buttonRandom );
160      buttonRandom->connect(SIGNAL(buttonRandom, released), this, SLOT(MultiplayerTeamDeathmatch, onButtonRandom));
161
162      OrxGui::GLGuiPushButton * buttonTeam0 = new OrxGui::GLGuiPushButton("Blue Team");
163      box->pack( buttonTeam0 );
164      buttonTeam0->connect(SIGNAL(buttonTeam0, released), this, SLOT(MultiplayerTeamDeathmatch, onButtonTeam0));
165
166      OrxGui::GLGuiPushButton * buttonTeam1 = new OrxGui::GLGuiPushButton("Red Team");
167      box->pack( buttonTeam1 );
168      buttonTeam1->connect(SIGNAL(buttonTeam1, released), this, SLOT(MultiplayerTeamDeathmatch, onButtonTeam1));
169
170      if ( bShowTeamChange )
171      {
172        OrxGui::GLGuiPushButton * buttonCancel = new OrxGui::GLGuiPushButton("Cancel");
173        box->pack( buttonCancel );
174        buttonCancel->connect(SIGNAL(buttonCancel, released), this, SLOT(MultiplayerTeamDeathmatch, onButtonCancel));
175      }
176
177      OrxGui::GLGuiPushButton * buttonExit = new OrxGui::GLGuiPushButton("Exit");
178      box->pack( buttonExit );
179      buttonExit->connect(SIGNAL(buttonExit, released), this, SLOT(MultiplayerTeamDeathmatch, onButtonExit));
180
181      box->showAll();
182    }
183  }
184
185  if ( box != NULL
186       && PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )
187       && PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )->getPreferedTeamId() != TEAM_NOTEAM
188       && !bShowTeamChange
189     )
190  {
191    delete box;
192    box = NULL;
193
194    OrxGui::GLGuiHandler::getInstance()->deactivateCursor( true );
195
196    EventHandler::getInstance()->popState();
197  }
198
199  if ( box != NULL )
200  {
201    OrxGui::GLGuiHandler::getInstance()->tick( dt );
202  }
203
204  assignPlayable();
205
206  if ( !SharedNetworkData::getInstance()->isGameServer() )
207    return;
208
209  //handle kills
210  while ( this->killList.begin() != this->killList.end() )
211  {
212    onKill( this->killList.begin()->getVictim(), this->killList.begin()->getKiller() );
213    this->killList.erase( this->killList.begin() );
214  }
215 
216
217
218  gameStateTimer -= dt;
219  //PRINTF(0)("TICK %f\n", gameStateTimer);
220
221  if ( currentGameState != GAMESTATE_GAME && gameStateTimer < 0 )
222    nextGameState();
223
224  this->currentGameState = NetworkGameManager::getInstance()->getGameState();
225
226  if ( currentGameState == GAMESTATE_GAME )
227  {
228    handleTeamChanges();
229  }
230
231  this->calculateTeamScore();
232
233  this->checkGameRules();
234
235  // is the local player dead and inactive
236  if( unlikely(this->bLocalPlayerDead))
237  {
238    this->timeout += dt;
239    PRINTF(0)("TICK DEATH: %f of %f\n", this->timeout, this->deathTimeout);
240    // long enough dead?
241    if( this->timeout >= this->deathTimeout)
242    {
243      this->timeout = 0.0f;
244      // respawn
245      PRINTF(0)("RESPAWN\n");
246      (State::getPlayer())->getPlayable()->respawn();
247    }
248  }
249}
250
251
252/**
253 * draws the stuff
254 */
255void MultiplayerTeamDeathmatch::draw()
256{
257  if( unlikely( this->bLocalPlayerDead))
258  {
259
260  }
261}
262
263
264/**
265 * check the game rules for consistency
266 */
267void MultiplayerTeamDeathmatch::checkGameRules()
268{
269  if ( !SharedNetworkData::getInstance()->isGameServer() )
270    return;
271
272  // check for max killing count
273  for ( int i = 0; i<numTeams; i++ )
274  {
275    if ( teamScore[i] >= maxKills )
276    {
277      nextGameState();
278    }
279  }
280}
281
282/**
283 * find group for new player
284 * @return group id
285 */
286int MultiplayerTeamDeathmatch::getTeamForNewUser()
287{
288  return TEAM_NOTEAM;
289}
290
291ClassID MultiplayerTeamDeathmatch::getPlayableClassId( int userId, int team )
292{
293  if ( team == TEAM_NOTEAM || team == TEAM_SPECTATOR )
294    return CL_SPECTATOR;
295
296  if ( team == 0 || team == 1 )
297    return CL_FPS_PLAYER;
298
299  assert( false );
300}
301
302std::string MultiplayerTeamDeathmatch::getPlayableModelFileName( int userId, int team, ClassID classId )
303{
304  if ( team == 0 )
305    return "models/creatures/doom_guy.md2";
306  else if ( team == 1 )
307    return "models/creatures/doom_guy.md2";
308  else
309    return "";
310}
311
312/**
313 * calculate team score
314 */
315void MultiplayerTeamDeathmatch::calculateTeamScore( )
316{
317  teamScore.clear();
318
319  for ( int i = 0; i<numTeams; i++ )
320    teamScore[i] = 0;
321
322
323  const std::list<BaseObject*> * list = ClassList::getList( CL_PLAYER_STATS );
324
325  if ( !list )
326    return;
327
328  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
329  {
330    PlayerStats & stats = *dynamic_cast<PlayerStats*>(*it);
331
332    if ( stats.getTeamId() >= 0 )
333    {
334      teamScore[stats.getTeamId()] += stats.getScore();
335    }
336  }
337}
338
339/**
340 * get team for player who choose to join random team
341 * @return smallest team
342 */
343int MultiplayerTeamDeathmatch::getRandomTeam( )
344{
345  std::map<int,int> playersInTeam;
346
347  for ( int i = 0; i<numTeams; i++ )
348    playersInTeam[i] = 0;
349
350  const std::list<BaseObject*> * list = ClassList::getList( CL_PLAYER_STATS );
351
352  if ( !list )
353    return 0;
354
355  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
356  {
357    PlayerStats & stats = *dynamic_cast<PlayerStats*>(*it);
358
359    if ( stats.getTeamId() >= 0 )
360    {
361      playersInTeam[stats.getTeamId()]++;
362    }
363  }
364
365
366  int minPlayers = 0xFFFF;
367  int minTeam = -1;
368
369  for ( int i = 0; i<numTeams; i++ )
370  {
371    if ( playersInTeam[i] < minPlayers )
372    {
373      minTeam = i;
374      minPlayers = playersInTeam[i];
375    }
376  }
377
378  assert( minTeam != -1 );
379
380  return minTeam;
381}
382
383void MultiplayerTeamDeathmatch::nextGameState( )
384{
385  if ( currentGameState == GAMESTATE_PRE_GAME )
386  {
387    NetworkGameManager::getInstance()->setGameState( GAMESTATE_GAME );
388
389    return;
390  }
391
392  if ( currentGameState == GAMESTATE_GAME )
393  {
394    NetworkGameManager::getInstance()->setGameState( GAMESTATE_POST_GAME );
395
396    return;
397  }
398
399  if ( currentGameState == GAMESTATE_POST_GAME )
400  {
401    State::getCurrentStoryEntity()->stop();
402    this->bShowTeamChange = false;
403
404    return;
405  }
406}
407
408void MultiplayerTeamDeathmatch::handleTeamChanges( )
409{
410  const std::list<BaseObject*> * list = ClassList::getList( CL_PLAYER_STATS );
411
412  if ( !list )
413    return;
414
415  //first server players with choices
416  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
417  {
418    PlayerStats & stats = *dynamic_cast<PlayerStats*>(*it);
419
420    if ( stats.getTeamId() != stats.getPreferedTeamId() )
421    {
422      if ( stats.getPreferedTeamId() == TEAM_SPECTATOR || ( stats.getPreferedTeamId() >= 0 && stats.getPreferedTeamId() < numTeams ) )
423      {
424        teamChange( stats.getUserId() );
425      }
426    }
427  }
428
429  //now serve player who want join a random team
430  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
431  {
432    PlayerStats & stats = *dynamic_cast<PlayerStats*>(*it);
433
434    if ( stats.getTeamId() != stats.getPreferedTeamId() )
435    {
436      if ( stats.getPreferedTeamId() == TEAM_RANDOM )
437      {
438        stats.setPreferedTeamId( getRandomTeam() );
439        teamChange( stats.getUserId() );
440      }
441    }
442  }
443}
444
445void MultiplayerTeamDeathmatch::teamChange( int userId )
446{
447  assert( PlayerStats::getStats( userId ) );
448  PlayerStats & stats = *(PlayerStats::getStats( userId ));
449
450  stats.setTeamId( stats.getPreferedTeamId() );
451
452  Playable * oldPlayable = stats.getPlayable();
453
454
455  ClassID playableClassId = getPlayableClassId( userId, stats.getPreferedTeamId() );
456  std::string playableModel = getPlayableModelFileName( userId, stats.getPreferedTeamId(), playableClassId );
457  std::string playableTexture = getPlayableModelTextureFileName( userId, stats.getPreferedTeamId(), playableClassId );
458
459  BaseObject * bo = Factory::fabricate( playableClassId );
460
461  assert( bo != NULL );
462  assert( bo->isA( CL_PLAYABLE ) );
463
464  Playable & playable = *(dynamic_cast<Playable*>(bo));
465
466  if ( playableTexture != "" )
467    playable.loadMD2Texture( playableTexture );
468  if ( playableModel != "" )
469    playable.loadModel( playableModel );
470  playable.setOwner( userId );
471  playable.setUniqueID( SharedNetworkData::getInstance()->getNewUniqueID() );
472  playable.setSynchronized( true );
473
474  stats.setTeamId( stats.getPreferedTeamId() );
475  stats.setPlayableClassId( playableClassId );
476  stats.setPlayableUniqueId( playable.getUniqueID() );
477  stats.setModelFileName( playableModel );
478
479  this->respawnPlayable( &playable, stats.getPreferedTeamId(), 0.0f );
480
481  if ( oldPlayable )
482  {
483    //if ( userId == SharedNetworkData::getInstance()->getHostID() )
484    //  State::getPlayer()->setPlayable( NULL );
485    delete oldPlayable;
486  }
487}
488
489void MultiplayerTeamDeathmatch::onButtonExit( )
490{
491  State::getCurrentStoryEntity()->stop();
492  this->bShowTeamChange = false;
493}
494
495void MultiplayerTeamDeathmatch::onButtonRandom( )
496{
497  NetworkGameManager::getInstance()->prefereTeam( TEAM_RANDOM );
498  this->bShowTeamChange = false;
499}
500
501void MultiplayerTeamDeathmatch::onButtonTeam0( )
502{
503  NetworkGameManager::getInstance()->prefereTeam( 0 );
504  this->bShowTeamChange = false;
505}
506
507void MultiplayerTeamDeathmatch::onButtonTeam1( )
508{
509  NetworkGameManager::getInstance()->prefereTeam( 1 );
510  this->bShowTeamChange = false;
511}
512
513void MultiplayerTeamDeathmatch::onButtonSpectator( )
514{
515  NetworkGameManager::getInstance()->prefereTeam( TEAM_SPECTATOR );
516  this->bShowTeamChange = false;
517}
518
519void MultiplayerTeamDeathmatch::assignPlayable( )
520{
521  if ( PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() ) )
522    PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )->getPlayable();
523}
524
525  /**
526   * function that processes events from the handler
527   * @param event: the event
528   * @todo replace SDLK_o with something from KeyMapper
529   */
530void MultiplayerTeamDeathmatch::process( const Event & event )
531{
532  if ( event.type == SDLK_o )
533  {
534    if ( event.bPressed )
535      this->bShowTeamChange = true;
536  } else if ( event.type == SDLK_F1 )
537  {
538    if ( this->statsBox && !this->bLocalPlayerDead && event.bPressed )
539    {
540      PRINTF(0)("hide stats\n");
541      this->hideStats();
542    }
543    else if ( !this->statsBox && event.bPressed )
544    {
545      PRINTF(0)("show stats\n");
546      this->showStats();
547    }
548  }
549  else if ( event.type == SDLK_TAB )
550  {
551    if ( currentGameState == GAMESTATE_GAME && event.bPressed && !EventHandler::getInstance()->isPressed( SDLK_RALT ) && !EventHandler::getInstance()->isPressed( SDLK_LALT ) )
552    {
553      EventHandler::getInstance()->pushState( ES_MENU );
554      OrxGui::GLGuiHandler::getInstance()->activateCursor();
555      OrxGui::GLGuiHandler::getInstance()->deactivateCursor();
556      input->show();
557      input->giveMouseFocus();
558      input->setText("say ");
559    }
560  }
561  else if ( this->bLocalPlayerDead && statsBox && event.type == KeyMapper::PEV_FIRE1 )
562  {
563    this->hideStats();
564  }
565}
566
567void MultiplayerTeamDeathmatch::onButtonCancel( )
568{
569  this->bShowTeamChange = false;
570}
571
572
573
574/**
575 * this method is called by NetworkGameManger when he recieved a chat message
576 * @param userId senders user id
577 * @param message message string
578 * @param messageType some int
579 */
580void MultiplayerTeamDeathmatch::handleChatMessage( int userId, const std::string & message, int messageType )
581{
582  std::string name = "unknown";
583
584  if ( PlayerStats::getStats( userId ) )
585  {
586    name = PlayerStats::getStats( userId )->getNickName();
587  }
588
589  PRINTF(0)("CHATMESSAGE %s (%d): %s\n", name.c_str(), userId, message.c_str() );
590  State::getPlayer()->hud().notifyUser(name + ": " + message);
591}
592
593void MultiplayerTeamDeathmatch::onInputEnter( const std::string & text )
594{
595  EventHandler::getInstance()->popState();
596  input->breakMouseFocus();
597  input->hide();
598  input->setText("");
599
600  std::string command = text;
601
602  //HACK insert " in say commands so user doesn't have to type them
603  if ( command.length() >= 4 && command[0] == 's' && command[1] == 'a' && command[2] == 'y' && command[3] == ' ' )
604  {
605    command.insert( 4, "\"" );
606    command = command + "\"";
607  }
608
609  OrxShell::ShellCommand::execute( command );
610}
611
612/**
613 * show table with frags
614 */
615void MultiplayerTeamDeathmatch::showStats( )
616{
617  statsBox = new OrxGui::GLGuiBox();
618  statsBox->setAbsCoor2D( 100, 100 );
619
620  this->table = new OrxGui::GLGuiTable(10,5);
621
622  statsBox->pack( this->table );
623
624  statsBox->showAll();
625}
626
627/**
628 * hide table with frags
629 */
630void MultiplayerTeamDeathmatch::hideStats( )
631{
632    if ( statsBox )
633    {
634      delete statsBox;
635      statsBox = NULL;
636    }
637}
638
639/**
640 * fill stats table with values
641 */
642void MultiplayerTeamDeathmatch::tickStatsTable( )
643{
644  if ( !this->statsBox )
645    return;
646
647  std::vector<std::string> headers;
648  headers.push_back("Blue Team");
649  headers.push_back("");
650  headers.push_back("");
651  headers.push_back("Red Team");
652  headers.push_back("");
653  this->table->setHeader(headers);
654
655  ScoreList scoreList = PlayerStats::getScoreList();
656
657  char st[10];
658  int i = 0;
659 
660  i = 2;
661  for ( TeamScoreList::const_iterator it = scoreList[0].begin(); it != scoreList[0].end(); it++ )
662  {
663    this->table->setEntry( i, 0, it->name );
664    snprintf( st, 10, "%d", it->score );
665    this->table->setEntry( i, 1, st );
666    this->table->setEntry( i, 2, "" );
667    i++;
668  }
669
670  i = 2;
671  for ( TeamScoreList::const_iterator it = scoreList[1].begin(); it != scoreList[1].end(); it++ )
672  {
673    this->table->setEntry( i, 3, it->name );
674    snprintf( st, 10, "%d", it->score );
675    this->table->setEntry( i, 4, st );
676    i++;
677  }
678
679}
680
681/**
682 * this function is called when a player kills another one or himself
683 * @param killedUserId
684 * @param userId
685 */
686void MultiplayerTeamDeathmatch::onKill( WorldEntity * victim, WorldEntity * killer )
687{
688  if ( !victim )
689    return;
690  if ( !killer )
691    return;
692 
693  int killerUserId = killer->getOwner();
694  int victimUserId = victim->getOwner();
695
696  PlayerStats & victimStats = *PlayerStats::getStats( victimUserId );
697  PlayerStats & killerStats = *PlayerStats::getStats( killerUserId );
698 
699  if ( killerStats.getPlayable() != killer || victimStats.getPlayable() != victim )
700    return;
701
702  //check for suicide
703  if ( killerUserId != victimUserId )
704  {
705    //check for teamkill
706    if ( victimStats.getTeamId() != killerStats.getTeamId() )
707    {
708      killerStats.setScore( killerStats.getScore() + 1 );
709    }
710    else
711    {
712      killerStats.setScore( killerStats.getScore() - 1 );
713    }
714  }
715  else
716    killerStats.setScore( killerStats.getScore() - 1 );
717
718  if ( victimUserId == SharedNetworkData::getInstance()->getHostID() )
719  {
720    this->bLocalPlayerDead = true;
721    this->showStats();
722  }
723
724  this->respawnPlayable( victimStats.getPlayable(), victimStats.getTeamId(), 3.0f );
725}
726
727/**
728 * this function is called on player respawn
729 * @param userId
730 */
731void MultiplayerTeamDeathmatch::onRespawn( int userId )
732{
733  if ( userId == SharedNetworkData::getInstance()->getHostID() )
734  {
735    this->bLocalPlayerDead = false;
736    this->hideStats();
737  }
738}
739
740/**
741 * this function is called on player respawn
742 * @param we
743 */
744void MultiplayerTeamDeathmatch::registerSpawn( WorldEntity * we )
745{
746  onRespawn( we->getOwner() );
747}
748
749
750void MultiplayerTeamDeathmatch::respawnPlayable( Playable * playable, int teamId, float delay )
751{
752  const std::list<BaseObject*> * list = ClassList::getList( CL_SPAWNING_POINT );
753
754  assert( list );
755
756  std::vector<SpawningPoint*> spList;
757
758  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
759  {
760    SpawningPoint * sp = dynamic_cast<SpawningPoint*>(*it);
761
762    if ( sp->getTeamId() == teamId )
763      spList.push_back( sp );
764  }
765
766  if ( spList.size() == 0 )
767  {
768    for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
769    {
770      SpawningPoint * sp = dynamic_cast<SpawningPoint*>(*it);
771
772      if ( sp->getTeamId() < 0 )
773        spList.push_back( sp );
774    }
775  }
776
777  assert( spList.size() != 0 );
778
779  int n = (int)((float)spList.size() * (float)rand()/(float)RAND_MAX);
780
781  spList[n]->pushEntity( playable, delay );
782}
783
784std::string MultiplayerTeamDeathmatch::getPlayableModelTextureFileName( int userId, int team, ClassID classId )
785{
786  if ( classId == CL_FPS_PLAYER )
787  {
788    return "maps/doom_guy.png";
789  }
790 
791  return "";
792}
793
Note: See TracBrowser for help on using the repository browser.