Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/util/multiplayer_team_deathmatch.cc @ 9617

Last change on this file since 9617 was 9494, checked in by bensch, 18 years ago

merged the proxy back

File size: 20.6 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.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
51
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->enterPushed.connect(this, &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      if( SharedNetworkData::getInstance()->isClient() ||  SharedNetworkData::getInstance()->isProxyServerActive())
155      {
156        OrxGui::GLGuiPushButton * buttonSpectator = new OrxGui::GLGuiPushButton("Spectator");
157        box->pack( buttonSpectator );
158        buttonSpectator->released.connect(this, &MultiplayerTeamDeathmatch::onButtonSpectator);
159
160        OrxGui::GLGuiPushButton * buttonRandom = new OrxGui::GLGuiPushButton("Random");
161        box->pack( buttonRandom );
162        buttonRandom->released.connect(this, &MultiplayerTeamDeathmatch::onButtonRandom);
163
164        OrxGui::GLGuiPushButton * buttonTeam0 = new OrxGui::GLGuiPushButton("Blue Team");
165        box->pack( buttonTeam0 );
166        buttonTeam0->released.connect(this, &MultiplayerTeamDeathmatch::onButtonTeam0);
167
168        OrxGui::GLGuiPushButton * buttonTeam1 = new OrxGui::GLGuiPushButton("Red Team");
169        box->pack( buttonTeam1 );
170        buttonTeam1->released.connect(this, &MultiplayerTeamDeathmatch::onButtonTeam1);
171      }
172      else
173      {
174        OrxGui::GLGuiText* text = new OrxGui::GLGuiText();
175        text->setText("Server Mode: not able to play at this node");
176        box->pack( text);
177      }
178
179
180      if ( bShowTeamChange )
181      {
182        OrxGui::GLGuiPushButton * buttonCancel = new OrxGui::GLGuiPushButton("Cancel");
183        box->pack( buttonCancel );
184        buttonCancel->released.connect(this, &MultiplayerTeamDeathmatch::onButtonCancel);
185      }
186
187      OrxGui::GLGuiPushButton * buttonExit = new OrxGui::GLGuiPushButton("Exit");
188      box->pack( buttonExit );
189      buttonExit->released.connect(this, &MultiplayerTeamDeathmatch::onButtonExit);
190
191      box->showAll();
192    }
193  }
194
195  if ( box != NULL
196       && PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )
197       && PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )->getPreferedTeamId() != TEAM_NOTEAM
198       && !bShowTeamChange
199     )
200  {
201    delete box;
202    box = NULL;
203
204    OrxGui::GLGuiHandler::getInstance()->deactivateCursor( true );
205
206    EventHandler::getInstance()->popState();
207  }
208
209  if ( box != NULL )
210  {
211    OrxGui::GLGuiHandler::getInstance()->tick( dt );
212  }
213
214  assignPlayable();
215
216  if ( SharedNetworkData::getInstance()->isClient() || SharedNetworkData::getInstance()->isProxyServerActive())
217    return;
218
219  //handle kills
220  while ( this->killList.begin() != this->killList.end() )
221  {
222    PRINTF(0)("KKKKKKKKIIIIIIIIILLLLLLLLLLLLL\n");
223    onKill( this->killList.begin()->getVictim(), this->killList.begin()->getKiller() );
224    this->killList.erase( this->killList.begin() );
225  }
226
227
228
229  gameStateTimer -= dt;
230  //PRINTF(0)("TICK %f\n", gameStateTimer);
231
232  if ( currentGameState != GAMESTATE_GAME && gameStateTimer < 0 )
233    nextGameState();
234
235  this->currentGameState = NetworkGameManager::getInstance()->getGameState();
236
237  if ( currentGameState == GAMESTATE_GAME )
238  {
239    handleTeamChanges();
240  }
241
242  this->calculateTeamScore();
243
244  this->checkGameRules();
245
246  // is the local player dead and inactive
247  if( unlikely(this->bLocalPlayerDead))
248  {
249    this->timeout += dt;
250    PRINTF(0)("TICK DEATH: %f of %f\n", this->timeout, this->deathTimeout);
251    // long enough dead?
252    if( this->timeout >= this->deathTimeout)
253    {
254      this->timeout = 0.0f;
255      // respawn
256      PRINTF(0)("RESPAWN\n");
257      (State::getPlayer())->getPlayable()->respawn();
258    }
259  }
260}
261
262
263/**
264 * draws the stuff
265 */
266void MultiplayerTeamDeathmatch::draw()
267{
268  if( unlikely( this->bLocalPlayerDead))
269  {
270
271  }
272}
273
274
275/**
276 * check the game rules for consistency
277 */
278void MultiplayerTeamDeathmatch::checkGameRules()
279{
280  if ( SharedNetworkData::getInstance()->isClient() || SharedNetworkData::getInstance()->isProxyServerActive())
281    return;
282
283  // check for max killing count
284  for ( int i = 0; i<numTeams; i++ )
285  {
286    if ( teamScore[i] >= maxKills )
287    {
288      nextGameState();
289    }
290  }
291}
292
293/**
294 * find group for new player
295 * @return group id
296 */
297int MultiplayerTeamDeathmatch::getTeamForNewUser()
298{
299  return TEAM_NOTEAM;
300}
301
302ClassID MultiplayerTeamDeathmatch::getPlayableClassId( int userId, int team )
303{
304  if ( team == TEAM_NOTEAM || team == TEAM_SPECTATOR )
305    return CL_SPECTATOR;
306
307  if ( team == 0 || team == 1 )
308    return CL_TURBINE_HOVER;
309
310  assert( false );
311}
312
313std::string MultiplayerTeamDeathmatch::getPlayableModelFileName( int userId, int team, ClassID classId )
314{
315  if (classId == CL_TURBINE_HOVER)
316   return "models/ships/hoverglider_mainbody.obj";
317  if ( team == 0 )
318    return "models/creatures/doom_guy.md2";
319  else if ( team == 1 )
320    return "models/creatures/male.md2";
321  else
322    return "";
323}
324
325std::string MultiplayerTeamDeathmatch::getPlayableModelTextureFileName( int userId, int team, ClassID classId )
326{
327  if ( classId == CL_FPS_PLAYER )
328  {
329    if ( team == 0 )
330      return "maps/doom_guy.png";
331    else
332      return "maps/male_fiend.pcx";
333  }
334
335  return "";
336}
337
338float MultiplayerTeamDeathmatch::getPlayableScale( int userId, int team, ClassID classId )
339{
340  if ( classId == CL_FPS_PLAYER )
341  {
342    return 10.0f;
343  }
344
345  return 1.0f;
346}
347
348/**
349 * calculate team score
350 */
351void MultiplayerTeamDeathmatch::calculateTeamScore( )
352{
353  teamScore.clear();
354
355  for ( int i = 0; i<numTeams; i++ )
356    teamScore[i] = 0;
357
358
359  const std::list<BaseObject*> * list = ClassList::getList( CL_PLAYER_STATS );
360
361  if ( !list )
362    return;
363
364  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
365  {
366    PlayerStats & stats = *dynamic_cast<PlayerStats*>(*it);
367
368    if ( stats.getTeamId() >= 0 )
369    {
370      teamScore[stats.getTeamId()] += stats.getScore();
371    }
372  }
373}
374
375/**
376 * get team for player who choose to join random team
377 * @return smallest team
378 */
379int MultiplayerTeamDeathmatch::getRandomTeam( )
380{
381  std::map<int,int> playersInTeam;
382
383  for ( int i = 0; i<numTeams; i++ )
384    playersInTeam[i] = 0;
385
386  const std::list<BaseObject*> * list = ClassList::getList( CL_PLAYER_STATS );
387
388  if ( !list )
389    return 0;
390
391  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
392  {
393    PlayerStats & stats = *dynamic_cast<PlayerStats*>(*it);
394
395    if ( stats.getTeamId() >= 0 )
396    {
397      playersInTeam[stats.getTeamId()]++;
398    }
399  }
400
401
402  int minPlayers = 0xFFFF;
403  int minTeam = -1;
404
405  for ( int i = 0; i<numTeams; i++ )
406  {
407    if ( playersInTeam[i] < minPlayers )
408    {
409      minTeam = i;
410      minPlayers = playersInTeam[i];
411    }
412  }
413
414  assert( minTeam != -1 );
415
416  return minTeam;
417}
418
419void MultiplayerTeamDeathmatch::nextGameState( )
420{
421  if ( currentGameState == GAMESTATE_PRE_GAME )
422  {
423    NetworkGameManager::getInstance()->setGameState( GAMESTATE_GAME );
424
425    return;
426  }
427
428  if ( currentGameState == GAMESTATE_GAME )
429  {
430    NetworkGameManager::getInstance()->setGameState( GAMESTATE_POST_GAME );
431
432    return;
433  }
434
435  if ( currentGameState == GAMESTATE_POST_GAME )
436  {
437    //State::getCurrentStoryEntity()->stop();
438    this->bShowTeamChange = false;
439
440    return;
441  }
442}
443
444void MultiplayerTeamDeathmatch::handleTeamChanges( )
445{
446  const std::list<BaseObject*> * list = ClassList::getList( CL_PLAYER_STATS );
447
448  if ( !list )
449    return;
450
451  //first server players with choices
452  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
453  {
454    PlayerStats & stats = *dynamic_cast<PlayerStats*>(*it);
455
456    if ( stats.getTeamId() != stats.getPreferedTeamId() )
457    {
458      if ( stats.getPreferedTeamId() == TEAM_SPECTATOR || ( stats.getPreferedTeamId() >= 0 && stats.getPreferedTeamId() < numTeams ) )
459      {
460        teamChange( stats.getUserId() );
461      }
462    }
463  }
464
465  //now serve player who want join a random team
466  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
467  {
468    PlayerStats & stats = *dynamic_cast<PlayerStats*>(*it);
469
470    if ( stats.getTeamId() != stats.getPreferedTeamId() )
471    {
472      if ( stats.getPreferedTeamId() == TEAM_RANDOM )
473      {
474        stats.setPreferedTeamId( getRandomTeam() );
475        teamChange( stats.getUserId() );
476      }
477    }
478  }
479}
480
481void MultiplayerTeamDeathmatch::teamChange( int userId )
482{
483  assert( PlayerStats::getStats( userId ) );
484  PlayerStats & stats = *(PlayerStats::getStats( userId ));
485
486  stats.setTeamId( stats.getPreferedTeamId() );
487
488  Playable * oldPlayable = stats.getPlayable();
489
490
491  ClassID playableClassId = getPlayableClassId( userId, stats.getPreferedTeamId() );
492  std::string playableModel = getPlayableModelFileName( userId, stats.getPreferedTeamId(), playableClassId );
493  std::string playableTexture = getPlayableModelTextureFileName( userId, stats.getPreferedTeamId(), playableClassId );
494  float       playableScale = getPlayableScale( userId, stats.getPreferedTeamId(), playableClassId );
495
496  BaseObject * bo = Factory::fabricate( playableClassId );
497
498  assert( bo != NULL );
499  assert( bo->isA( CL_PLAYABLE ) );
500
501  Playable & playable = *(dynamic_cast<Playable*>(bo));
502
503  playable.loadMD2Texture( playableTexture );
504  playable.loadModel( playableModel, playableScale );
505  playable.setOwner( userId );
506  playable.setUniqueID( SharedNetworkData::getInstance()->getNewUniqueID() );
507  playable.setSynchronized( true );
508
509  stats.setTeamId( stats.getPreferedTeamId() );
510  stats.setPlayableClassId( playableClassId );
511  stats.setPlayableUniqueId( playable.getUniqueID() );
512  stats.setModelFileName( playableModel );
513
514  this->respawnPlayable( &playable, stats.getPreferedTeamId(), 0.0f );
515
516  if ( oldPlayable )
517  {
518    //if ( userId == SharedNetworkData::getInstance()->getHostID() )
519    //  State::getPlayer()->setPlayable( NULL );
520    delete oldPlayable;
521  }
522}
523
524void MultiplayerTeamDeathmatch::onButtonExit( )
525{
526  State::getCurrentStoryEntity()->stop();
527  this->bShowTeamChange = false;
528}
529
530void MultiplayerTeamDeathmatch::onButtonRandom( )
531{
532  NetworkGameManager::getInstance()->prefereTeam( TEAM_RANDOM );
533  this->bShowTeamChange = false;
534}
535
536void MultiplayerTeamDeathmatch::onButtonTeam0( )
537{
538  NetworkGameManager::getInstance()->prefereTeam( 0 );
539  this->bShowTeamChange = false;
540}
541
542void MultiplayerTeamDeathmatch::onButtonTeam1( )
543{
544  NetworkGameManager::getInstance()->prefereTeam( 1 );
545  this->bShowTeamChange = false;
546}
547
548void MultiplayerTeamDeathmatch::onButtonSpectator( )
549{
550  NetworkGameManager::getInstance()->prefereTeam( TEAM_SPECTATOR );
551  this->bShowTeamChange = false;
552}
553
554void MultiplayerTeamDeathmatch::assignPlayable( )
555{
556  if ( PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() ) )
557    PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )->getPlayable();
558}
559
560  /**
561   * function that processes events from the handler
562   * @param event: the event
563   * @todo replace SDLK_o with something from KeyMapper
564   */
565void MultiplayerTeamDeathmatch::process( const Event & event )
566{
567  if ( event.type == SDLK_o )
568  {
569    if ( event.bPressed )
570      this->bShowTeamChange = true;
571  } else if ( event.type == SDLK_F1 )
572  {
573    if ( this->statsBox && !this->bLocalPlayerDead && event.bPressed )
574    {
575      PRINTF(0)("hide stats\n");
576      this->hideStats();
577    }
578    else if ( !this->statsBox && event.bPressed )
579    {
580      PRINTF(0)("show stats\n");
581      this->showStats();
582    }
583  }
584  else if ( event.type == SDLK_TAB )
585  {
586    if ( currentGameState == GAMESTATE_GAME && event.bPressed && !EventHandler::getInstance()->isPressed( SDLK_RALT ) && !EventHandler::getInstance()->isPressed( SDLK_LALT ) )
587    {
588      EventHandler::getInstance()->pushState( ES_MENU );
589      OrxGui::GLGuiHandler::getInstance()->activateCursor();
590      OrxGui::GLGuiHandler::getInstance()->deactivateCursor();
591      input->show();
592      input->giveMouseFocus();
593      input->setText("say ");
594    }
595  }
596  else if ( this->bLocalPlayerDead && statsBox && event.type == KeyMapper::PEV_FIRE1 )
597  {
598    this->hideStats();
599  }
600}
601
602void MultiplayerTeamDeathmatch::onButtonCancel( )
603{
604  this->bShowTeamChange = false;
605}
606
607
608
609/**
610 * this method is called by NetworkGameManger when he recieved a chat message
611 * @param userId senders user id
612 * @param message message string
613 * @param messageType some int
614 */
615void MultiplayerTeamDeathmatch::handleChatMessage( int userId, const std::string & message, int messageType )
616{
617  std::string name = "unknown";
618
619  if ( PlayerStats::getStats( userId ) )
620  {
621    name = PlayerStats::getStats( userId )->getNickName();
622  }
623
624  PRINTF(0)("CHATMESSAGE %s (%d): %s\n", name.c_str(), userId, message.c_str() );
625  State::getPlayer()->hud().notifyUser(name + ": " + message);
626}
627
628void MultiplayerTeamDeathmatch::onInputEnter( const std::string & text )
629{
630  EventHandler::getInstance()->popState();
631  input->breakMouseFocus();
632  input->hide();
633  input->setText("");
634
635  std::string command = text;
636
637  //HACK insert " in say commands so user doesn't have to type them
638  if ( command.length() >= 4 && command[0] == 's' && command[1] == 'a' && command[2] == 'y' && command[3] == ' ' )
639  {
640    command.insert( 4, "\"" );
641    command = command + "\"";
642  }
643
644  OrxShell::ShellCommand::execute( command );
645}
646
647/**
648 * show table with frags
649 */
650void MultiplayerTeamDeathmatch::showStats( )
651{
652  statsBox = new OrxGui::GLGuiBox();
653  statsBox->setAbsCoor2D( 100, 100 );
654
655  this->table = new OrxGui::GLGuiTable(10,5);
656
657  statsBox->pack( this->table );
658
659  statsBox->showAll();
660}
661
662/**
663 * hide table with frags
664 */
665void MultiplayerTeamDeathmatch::hideStats( )
666{
667    if ( statsBox )
668    {
669      delete statsBox;
670      statsBox = NULL;
671    }
672}
673
674/**
675 * fill stats table with values
676 */
677void MultiplayerTeamDeathmatch::tickStatsTable( )
678{
679  if ( !this->statsBox )
680    return;
681
682  std::vector<std::string> headers;
683  headers.push_back("Blue Team");
684  headers.push_back("");
685  headers.push_back("");
686  headers.push_back("Red Team");
687  headers.push_back("");
688  this->table->setHeader(headers);
689
690  ScoreList scoreList = PlayerStats::getScoreList();
691
692  char st[10];
693  int i = 0;
694
695  i = 2;
696  for ( TeamScoreList::const_iterator it = scoreList[0].begin(); it != scoreList[0].end(); it++ )
697  {
698    this->table->setEntry( i, 0, it->name );
699    snprintf( st, 10, "%d", it->score );
700    this->table->setEntry( i, 1, st );
701    this->table->setEntry( i, 2, "" );
702    i++;
703  }
704
705  i = 2;
706  for ( TeamScoreList::const_iterator it = scoreList[1].begin(); it != scoreList[1].end(); it++ )
707  {
708    this->table->setEntry( i, 3, it->name );
709    snprintf( st, 10, "%d", it->score );
710    this->table->setEntry( i, 4, st );
711    i++;
712  }
713
714}
715
716/**
717 * this function is called when a player kills another one or himself
718 * @param killedUserId
719 * @param userId
720 */
721void MultiplayerTeamDeathmatch::onKill( WorldEntity * victim, WorldEntity * killer )
722{
723  if ( !victim )
724  {
725    PRINTF(0)("victim == NULL\n");
726    return;
727  }
728  if ( !killer )
729  {
730    PRINTF(0)("killer == NULL\n");
731    return;
732  }
733
734  int killerUserId = killer->getOwner();
735  int victimUserId = victim->getOwner();
736
737  PRINTF(0)("%d %d %x %x %s %s\n", killerUserId, victimUserId, killer, victim, killer->getClassCName(), victim->getClassCName());
738
739  PlayerStats & victimStats = *PlayerStats::getStats( victimUserId );
740  PlayerStats & killerStats = *PlayerStats::getStats( killerUserId );
741
742  if ( killerStats.getPlayable() != killer || victimStats.getPlayable() != victim )
743  {
744    PRINTF(0)("killerStats.getPlayable() != killer || victimStats.getPlayable() != victim\n");
745    PRINTF(0)("%x %x %x %x\n", killerStats.getPlayable(), killer, victimStats.getPlayable(), victim );
746    PRINTF(0)("%d %d %d %d\n", killerStats.getPlayable()->getUniqueID(), killer->getUniqueID(), victimStats.getPlayable()->getUniqueID(), victim->getUniqueID() );
747    return;
748  }
749
750  //check for suicide
751  if ( killerUserId != victimUserId )
752  {
753    //check for teamkill
754    if ( victimStats.getTeamId() != killerStats.getTeamId() )
755    {
756      killerStats.setScore( killerStats.getScore() + 1 );
757    }
758    else
759    {
760      killerStats.setScore( killerStats.getScore() - 1 );
761    }
762  }
763  else
764    killerStats.setScore( killerStats.getScore() - 1 );
765
766  if ( victimUserId == SharedNetworkData::getInstance()->getHostID() )
767  {
768    this->bLocalPlayerDead = true;
769    this->showStats();
770  }
771
772  this->respawnPlayable( victimStats.getPlayable(), victimStats.getTeamId(), 3.0f );
773}
774
775/**
776 * this function is called on player respawn
777 * @param userId
778 */
779void MultiplayerTeamDeathmatch::onRespawn( int userId )
780{
781  if ( userId == SharedNetworkData::getInstance()->getHostID() )
782  {
783    this->bLocalPlayerDead = false;
784    this->hideStats();
785  }
786}
787
788/**
789 * this function is called on player respawn
790 * @param we
791 */
792void MultiplayerTeamDeathmatch::registerSpawn( WorldEntity * we )
793{
794  onRespawn( we->getOwner() );
795}
796
797
798void MultiplayerTeamDeathmatch::respawnPlayable( Playable * playable, int teamId, float delay )
799{
800  const std::list<BaseObject*> * list = ClassList::getList( CL_SPAWNING_POINT );
801
802  assert( list );
803
804  std::vector<SpawningPoint*> spList;
805
806  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
807  {
808    SpawningPoint * sp = dynamic_cast<SpawningPoint*>(*it);
809
810    if ( sp->getTeamId() == teamId )
811      spList.push_back( sp );
812  }
813
814  if ( spList.size() == 0 )
815  {
816    for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
817    {
818      SpawningPoint * sp = dynamic_cast<SpawningPoint*>(*it);
819
820      if ( sp->getTeamId() < 0 )
821        spList.push_back( sp );
822    }
823  }
824
825  assert( spList.size() != 0 );
826
827  int n = (int)((float)spList.size() * (float)rand()/(float)RAND_MAX);
828
829  spList[n]->pushEntity( playable, delay );
830}
831
832
Note: See TracBrowser for help on using the repository browser.