Source/Core/DolphinWX/Src/NetFunctions.cpp

   1 // Copyright (C) 2003 Dolphin Project.
   2
   3 // This program is free software: you can redistribute it and/or modify
   4 // it under the terms of the GNU General Public License as published by
   5 // the Free Software Foundation, version 2.0.
   6
   7 // This program is distributed in the hope that it will be useful,
   8 // but WITHOUT ANY WARRANTY; without even the implied warranty of
   9 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10 // GNU General Public License 2.0 for more details.
  11
  12 // A copy of the GPL 2.0 should have been included with the program.
  13 // If not, see http://www.gnu.org/licenses/
  14
  15 // Official SVN repository and contact information can be found at
  16 // http://code.google.com/p/dolphin-emu/
  17
  18 #include "NetSockets.h"
  19 #include "NetWindow.h"
  20 #include "HW/SI_DeviceGCController.h"
  21
  22 NetPlay *NetClass_ptr = NULL;
  23
  24 void NetPlay::IsGameFound(unsigned char * ptr, std::string m_selected)
  25 {
  26         m_critical.Enter();
  27
  28                 m_selectedGame = m_selected;
  29
  30                 if (m_games.find(m_selected) != std::string::npos)
  31                         *ptr = 0x1F;
  32                 else
  33                         *ptr = 0x1A;
  34
  35         m_critical.Leave();
  36 }
  37
  38 void NetPlay::OnNetEvent(wxCommandEvent& event)
  39 {
  40         switch (event.GetId())
  41         {
  42         case HOST_FULL:
  43                 {
  44                         AppendText(_(" Server is Full !\n*You have been Disconnected.\n\n"));
  45                         m_isHosting = 2;
  46                 }
  47                 break;
  48         case HOST_ERROR:
  49                 {
  50                         if (m_isHosting == 0)
  51                         {
  52                                 AppendText(_("ERROR : Network Error !\n*You have been Disconnected.\n\n"));
  53                                 m_isHosting = 2;
  54                         }
  55                         else
  56                         {
  57                                 m_numClients--;
  58                                 AppendText( wxString::Format(wxT("ERROR : Network Error !\n")
  59                                         wxT("*Player : %s has been dropped from the game.\n\n"),
  60                                          (const char *)event.GetString().mb_str()) );
  61                         }
  62                 }
  63                 break;
  64         case HOST_DISCONNECTED:
  65                 {
  66                         // Event sent from Client's thread, it means that the thread
  67                         // has been killed and so we tell the GUI thread.
  68                         AppendText(_("*Connection to Host lost.\n*You have been Disconnected.\n\n"));
  69                         m_isHosting = 2;
  70                         m_numClients--;
  71                 }
  72                 break;
  73         case HOST_PLAYERLEFT:
  74                 {
  75                         m_numClients--;
  76                 }
  77                 break;
  78         case HOST_NEWPLAYER:
  79                 {
  80                         m_numClients++;
  81                         m_NetModel = event.GetInt();
  82                 }
  83                 break;
  84         case CLIENTS_READY:
  85                 {
  86                         m_clients_ready = true;
  87
  88                         // Tell clients everyone is ready...
  89                         if (m_ready)
  90                                 LoadGame();
  91                 }
  92                 break;
  93         case CLIENTS_NOTREADY:
  94                 {
  95                         m_clients_ready = false;
  96                 }
  97                 break;
  98         case GUI_UPDATE:
  99                 UpdateNetWindow(false);
 100                 break;
 101         case ADD_TEXT:
 102                 AppendText(event.GetString());
 103                 break;
 104         case ADD_INFO:
 105                 UpdateNetWindow(true, event.GetString());
 106                 break;
 107         }
 108 }
 109
 110 void ServerSide::IsEveryoneReady()
 111 {
 112         int nb_ready = 0;
 113
 114         for (int i=0; i < m_numplayers ; i++)
 115                 if (m_client[i].ready)
 116                         nb_ready++;
 117
 118         if (nb_ready == m_numplayers)
 119                 Event->SendEvent(CLIENTS_READY);
 120         else
 121                 Event->SendEvent(CLIENTS_NOTREADY);
 122 }
 123
 124 // Actual Core function which is called on every frame
 125 int CSIDevice_GCController::GetNetInput(u8 numPAD, SPADStatus PadStatus, u32 *PADStatus)
 126 {
 127         if (NetClass_ptr != NULL)
 128                 return NetClass_ptr->GetNetPads(numPAD, PadStatus, PADStatus) ? 1 : 0;
 129         else
 130                 return 2;
 131 }
 132
 133 void NetPlay::LoadGame()
 134 {
 135         // Two implementations, one "p2p" implementation which sends to peer
 136         // and receive from peer 2 players max. and another which uses server model
 137         // and always sends to the server which then send it back to all the clients
 138         // -> P2P model is faster, but is limited to 2 players
 139         // -> Server model is slower, but supports up to 4 players
 140
 141         if (m_isHosting == 1)
 142         {
 143                 long ping[3] = {0};
 144                 unsigned char value = 0x50;
 145
 146                 // Get ping
 147                 m_sock_server->Write(0, 0, 0, ping);
 148                 float fping = (ping[0]+ping[1]+ping[2])/(float)m_numClients;
 149
 150                 // Tell client everyone is ready
 151                 for (int i=0; i < m_numClients ; i++)
 152                         m_sock_server->Write(i, (const char*)&value, 1);
 153
 154                 // Sleep a bit to start the game at more or less the same time than the peer
 155                 wxMilliSleep(fping/2);
 156
 157                 m_Logging->AppendText(wxString::Format(wxT("** Everyone is ready... Loading Game ! **\n")
 158                         wxT("** Ping to client(s) is : %f ms\n"), fping));
 159         }
 160         else
 161                 m_Logging->AppendText(_("** Everyone is ready... Loading Game ! **\n"));
 162
 163         // TODO : Throttle should be on by default, to avoid stuttering
 164         //soundStream->GetMixer()->SetThrottle(true);
 165
 166         int line_p = 0;
 167         int line_n = 0;
 168
 169         m_critical.Enter();
 170         std::string tmp = m_games.substr(0, m_games.find(m_selectedGame));
 171
 172         for (int i=0; i < (int)tmp.size(); i++)
 173                 if (tmp.c_str()[i] == '\n')
 174                         line_n++;
 175
 176         // Enable
 177         NetClass_ptr = this;
 178         m_timer.Start();
 179         m_data_received = false;
 180         m_critical.Leave();
 181
 182         // Find corresponding game path
 183         for (int i=0; i < (int)m_paths.size(); i++)
 184         {
 185                 if (m_paths.c_str()[i] == '\n')
 186                         line_p++;
 187
 188                 if (line_n == line_p)   {
 189                         // Game path found, get its string
 190                         int str_pos = line_p > 0 ? i+1 : i;
 191                         int str_end = (int)m_paths.find('\n', str_pos);
 192                         // Boot the selected game
 193                         BootManager::BootCore(m_paths.substr(str_pos, str_end - str_pos));
 194                         break;
 195                 }
 196         }
 197 }
 198
 199 bool NetPlay::GetNetPads(u8 padnb, SPADStatus PadStatus, u32 *netValues)
 200 {
 201         if (m_numClients < 1)
 202         {
 203                 m_Logging->AppendText(_("** WARNING : Ping too high (>2000ms) or connection lost ! \n** WARNING : Stopping Netplay... \n"));
 204                 NetClass_ptr = NULL;
 205                 return false;
 206         }
 207
 208         // Store current pad status in netValues[]
 209         netValues[0] = (u32)((u8)PadStatus.stickY);
 210         netValues[0] |= (u32)((u8)PadStatus.stickX << 8);
 211         netValues[0] |= (u32)((u16)PadStatus.button << 16);
 212         netValues[0] |= 0x00800000;
 213         netValues[1] = (u8)PadStatus.triggerRight;
 214         netValues[1] |= (u32)((u8)PadStatus.triggerLeft << 8);
 215         netValues[1] |= (u32)((u8)PadStatus.substickY << 16);
 216         netValues[1] |= (u32)((u8)PadStatus.substickX << 24);
 217
 218         if (m_NetModel == 0) // Use 2 players Model
 219         {
 220                 if (padnb == 0)
 221                 {
 222                         // Update the timer and increment total frame number
 223                         m_frame++;
 224
 225                         if (m_frame == 1)
 226                         {
 227                                 // We make sure everyone's pad is enabled
 228                                 for (int i = 0; i < m_numClients+1; i++)
 229                                         SerialInterface::ChangeDevice(SI_GC_CONTROLLER, i);
 230
 231                                 // Better disable unused ports
 232                                 for (int i = m_numClients+1; i < 4; i++)
 233                                         SerialInterface::ChangeDevice(SI_NONE, i);
 234                         }
 235
 236                         if (m_timer.GetTimeDifference() > 1000)
 237                                 m_timer.Update();
 238
 239 #ifdef NET_DEBUG
 240                         char sent[64];
 241                         sprintf(sent, "Sent Values: 0x%08x : 0x%08x \n", netValues[0], netValues[1]);
 242                         m_Logging->AppendText(wxString::FromAscii(sent));
 243 #endif
 244                         unsigned char player = 0;
 245
 246 #ifdef USE_TCP
 247                         unsigned char init_value = 0xA1;
 248
 249                         if (m_isHosting == 1) {
 250                                 // Send pads values
 251                                 m_sock_server->Write(0, (const char*)&init_value, 1);
 252                                 m_sock_server->Write(0, (const char*)netValues, 8);
 253                         }
 254                         else {
 255                                 // Send pads values
 256                                 m_sock_client->Write((const char*)&init_value, 1);
 257                                 m_sock_client->Write((const char*)netValues, 8);
 258                                 player = 1;
 259                         }
 260 #else // UDP
 261                         u32 padsValues[3];
 262
 263                         padsValues[0] = m_frame;
 264                         padsValues[1] = netValues[0];
 265                         padsValues[2] = netValues[1];
 266
 267                         if (m_isHosting == 1) {
 268                                 // Send pads values
 269                                 m_sock_server->WriteUDP(0, (const char*)padsValues, 12);
 270                         }
 271                         else {
 272                                 // Send pads values
 273                                 m_sock_client->WriteUDP((const char*)padsValues, 12);
 274                                 player = 1;
 275                         }
 276 #endif
 277
 278                         if (!m_data_received)
 279                         {
 280                                 // Save pad values
 281                                 m_pads[player].nHi[m_loopframe] = netValues[0];
 282                                 m_pads[player].nLow[m_loopframe] = netValues[1];
 283
 284                                 // Try to read from peer...
 285                                 if (m_isHosting == 1)
 286                                         m_data_received = m_sock_server->isNewPadData(0, false);
 287                                 else
 288                                         m_data_received = m_sock_client->isNewPadData(0, false);
 289
 290                                 if (m_data_received)
 291                                 {
 292                                         // Set our practical frame delay
 293                                         m_frameDelay = m_loopframe;
 294                                         m_loopframe = 0;
 295
 296                                         // First Data has been received !
 297                                         m_Logging->AppendText(_("** Data received from Peer. Starting Sync !"));
 298                                         m_Logging->AppendText(wxString::Format(wxT(" Frame Delay : %d **\n"), m_frameDelay));
 299                                 }
 300                                 else {
 301                                         if (m_loopframe > 126)
 302                                         {
 303                                                 m_Logging->AppendText(_("** WARNING : Ping too high (>2000ms) or connection lost ! \n** WARNING : Stopping Netplay... \n"));
 304                                                 NetClass_ptr = NULL;
 305                                         }
 306
 307                                         m_loopframe++;
 308                                         return false;
 309                                 }
 310                         }
 311
 312                         if (m_data_received)
 313                         {
 314                                 // We have successfully received the data, now use it...
 315                                 // If we received data, we can update our pads on each frame, here's the behaviour :
 316                                 // we received our init number, so we should receive our pad values on each frames
 317                                 // with a frame delay of 'm_frameDelay' frames from the peer. So here, we just wait
 318                                 // for the pad status. note : if the peer can't keep up, sending the values
 319                                 // (i.e : framerate is too low) we have to wait for it thus slowing down emulation
 320
 321                                 // Save current pad values, it will be used in 'm_frameDelay' frames :D
 322                                 int saveslot = (m_loopframe - 1 < 0 ? m_frameDelay : m_loopframe - 1);
 323                                 u32 recvedValues[2];
 324
 325                                 m_pads[player].nHi[saveslot]  = netValues[0];
 326                                 m_pads[player].nLow[saveslot] = netValues[1];
 327
 328                                 // Read the socket for pad values
 329                                 if (m_isHosting == 1)
 330                                         m_sock_server->isNewPadData(recvedValues, true);
 331                                 else
 332                                         m_sock_client->isNewPadData(recvedValues, true);
 333
 334                                 if (player == 0)
 335                                 {
 336                                         // Store received peer values
 337                                         m_pads[1].nHi[m_loopframe]  = recvedValues[0];
 338                                         m_pads[1].nLow[m_loopframe] = recvedValues[1];
 339
 340                                         // Apply synced pad values
 341                                         netValues[0] = m_pads[0].nHi[m_loopframe];
 342                                         netValues[1] = m_pads[0].nLow[m_loopframe];
 343                                 }
 344                                 else
 345                                 {
 346                                         // Apply received pad values
 347                                         netValues[0] = recvedValues[0];
 348                                         netValues[1] = recvedValues[1];
 349                                 }
 350                         }
 351
 352 #ifdef NET_DEBUG
 353                         char usedval[64];
 354                         sprintf(usedval, "Player 1 Values: 0x%08x : 0x%08x \n", netValues[0], netValues[1]);
 355                         m_Logging->AppendText(wxString::FromAscii(usedval));
 356 #endif
 357                         return true;
 358                 }
 359                 else if (padnb == 1)
 360                 {
 361                         if (m_data_received)
 362                         {
 363                                 netValues[0] = m_pads[1].nHi[m_loopframe];
 364                                 netValues[1] = m_pads[1].nLow[m_loopframe];
 365
 366                                 // Reset the loop to avoid reading unused values
 367                                 if (m_loopframe == m_frameDelay)
 368                                         m_loopframe = 0;
 369                                 else
 370                                         m_loopframe++;
 371                         }
 372                         else
 373                                 return false;
 374 #ifdef NET_DEBUG
 375                         char usedval[64];
 376                         sprintf(usedval, "Player 2 Values: 0x%08x : 0x%08x \n", netValues[0], netValues[1]);
 377                         m_Logging->AppendText(wxString::FromAscii(usedval));
 378 #endif
 379
 380                         return true;
 381                 }
 382         }
 383         else
 384         {
 385                 // TODO : :D
 386                 return false;
 387         }
 388
 389         return false;
 390 }
 391
 392 void NetPlay::ChangeSelectedGame(std::string game)
 393 {
 394         wxCriticalSectionLocker lock(m_critical);
 395         if (m_isHosting == 0)
 396         {
 397                 m_selectedGame = game;
 398                 return;
 399         }
 400
 401         if (game != m_selectedGame)
 402         {
 403                 unsigned char value = 0x35;
 404                 int game_size = (int)game.size();
 405
 406                 // Send command then Game String
 407                 for (int i=0; i < m_numClients ; i++)
 408                 {
 409                         m_sock_server->Write(i, (const char*)&value, 1); // 0x35 -> Change game
 410
 411                         m_sock_server->Write(i, (const char*)&game_size, 4);
 412                         m_sock_server->Write(i, game.c_str(), game_size + 1);
 413                 }
 414
 415                 m_selectedGame = game;
 416                 UpdateNetWindow(false);
 417                 m_Logging->AppendText(wxString::Format( wxT(" *Game has been changed to : %s \r\n "),  wxString(game.c_str(), wxConvUTF8).c_str()));
 418                 NOTICE_LOG(NETPLAY,"Game has been changed to : %s \n",game.c_str());
 419         }
 420 }
 421
 422 void NetPlay::OnQuit(wxCloseEvent& WXUNUSED(event))
 423 {
 424         // Disable netplay
 425         NetClass_ptr = NULL;
 426
 427         // Destroy the Window
 428         Destroy();
 429
 430         // Then Kill the threads
 431         if (m_isHosting == 0)
 432                 m_sock_client->Delete();
 433         else if (m_isHosting == 1) {
 434                 m_sock_server->Delete();
 435         }
 436
 437 }
 438
 439 void NetPlay::OnDisconnect(wxCommandEvent& WXUNUSED(event))
 440 {
 441         wxCloseEvent close;
 442         OnQuit(close);
 443 }
 444
 445 bool ClientSide::isNewPadData(u32 *netValues, bool current, bool isVersus)
 446 {
 447 #ifdef USE_TCP
 448         if (current)
 449         {
 450                 while (1)
 451                 {
 452                         m_CriticalSection.Enter();
 453                         if (m_data_received && isVersus)
 454                         {
 455                                 netValues[0] = m_netvalues[0][0];
 456                                 netValues[1] = m_netvalues[0][1];
 457                                 m_data_received = false;
 458
 459                                 m_CriticalSection.Leave();
 460                                 break;
 461                         }
 462                         m_CriticalSection.Leave();
 463
 464                         if (TestDestroy())
 465                                 break;
 466                 }
 467
 468                 return true;
 469         }
 470         else
 471                 wxCriticalSectionLocker lock(m_CriticalSection);
 472
 473         return m_data_received;
 474 #else
 475         size_t recv_size;
 476
 477         if (current)
 478         {
 479                 m_CriticalSection.Enter();
 480
 481                 if (isVersus)
 482                 {
 483                         if (m_netvalues[0][1] != 0)
 484                         {
 485                                 netValues[0] = m_netvalues[0][1];
 486                                 netValues[1] = m_netvalues[0][2];
 487                         }
 488                         else
 489                         {
 490                                 while (true)
 491                                 {
 492                                         u32 frame_saved = m_netvalues[0][0];
 493                                         bool pass = RecvT(m_socketUDP, (char*)&m_netvalues[0], 12, recv_size, 5);
 494
 495                                         if (m_netvalues[0][0] < frame_saved+1)
 496                                                 continue;
 497                                         if (m_netvalues[0][0] > frame_saved+1 || !pass)
 498                                                 PanicAlert("Network ERROR !");
 499
 500                                         netValues[0] = m_netvalues[0][1];
 501                                         netValues[1] = m_netvalues[0][2];
 502                                         break;
 503                                 }
 504                         }
 505                 }
 506
 507                 m_netvalues[0][1] = 0;
 508                 m_CriticalSection.Leave();
 509
 510                 return true;
 511         }
 512         else
 513                 return RecvT(m_socketUDP, (char*)&m_netvalues[0], 12, recv_size, 1/1000);
 514
 515 #endif
 516
 517 }
 518
 519 bool ServerSide::isNewPadData(u32 *netValues, bool current, int client)
 520 {
 521 #ifdef USE_TCP
 522         if (current)
 523         {
 524                 while (1)
 525                 {
 526                         m_CriticalSection.Enter();
 527                         if (m_data_received)
 528                         {
 529                                 netValues[0] = m_netvalues[client][0];
 530                                 netValues[1] = m_netvalues[client][1];
 531                                 m_data_received = false;
 532
 533                                 m_CriticalSection.Leave();
 534                                 break;
 535                         }
 536                         m_CriticalSection.Leave();
 537
 538                         if (TestDestroy())
 539                                 break;
 540                 }
 541
 542                 return true;
 543         }
 544         else
 545                 wxCriticalSectionLocker lock(m_CriticalSection);
 546
 547         return m_data_received;
 548 #else
 549         size_t recv_size;
 550
 551         if (current)
 552         {
 553                 m_CriticalSection.Enter();
 554
 555                 if (m_netvalues[0][1] != 0)
 556                 {
 557                         netValues[0] = m_netvalues[client][1];
 558                         netValues[1] = m_netvalues[client][2];
 559                 }
 560                 else
 561                 {
 562                         while (true)
 563                         {
 564                                 u32 frame_saved = m_netvalues[client][0];
 565                                 bool pass = RecvT(m_socketUDP, (char*)&m_netvalues[client], 12, recv_size, 5);
 566
 567                                 if (m_netvalues[client][0] < frame_saved+1)
 568                                         continue;
 569                                 if (m_netvalues[client][0] > frame_saved+1 || !pass)
 570                                         PanicAlert("Network ERROR !");
 571
 572                                 netValues[0] = m_netvalues[client][1];
 573                                 netValues[1] = m_netvalues[client][2];
 574                                 break;
 575                         }
 576                 }
 577
 578                 m_netvalues[client][1] = 0;
 579                 m_CriticalSection.Leave();
 580
 581                 return true;
 582         }
 583         else
 584                 return RecvT(m_socketUDP, (char*)&m_netvalues[client], 12, recv_size, 1/1000);
 585
 586 #endif
 587 }
 588