27 #include "game.h"

    27 #include "game.h"

    28 

    28 

    29 char delimeter='\n';

    29 char delimeter='\n';

    30 

    30 

    31 HWNewNet::HWNewNet() :

    31 HWNewNet::HWNewNet() :

    36 {

    36 {

    37 // socket stuff

    37 // socket stuff

    38     connect(&NetSocket, SIGNAL(readyRead()), this, SLOT(ClientRead()));

    38     connect(&NetSocket, SIGNAL(readyRead()), this, SLOT(ClientRead()));

    39     connect(&NetSocket, SIGNAL(connected()), this, SLOT(OnConnect()));

    39     connect(&NetSocket, SIGNAL(connected()), this, SLOT(OnConnect()));

    40     connect(&NetSocket, SIGNAL(disconnected()), this, SLOT(OnDisconnect()));

    40     connect(&NetSocket, SIGNAL(disconnected()), this, SLOT(OnDisconnect()));

   101 }

   101 }

   102 

   102 

   103 void HWNewNet::AddTeam(const HWTeam & team)

   103 void HWNewNet::AddTeam(const HWTeam & team)

   104 {

   104 {

   105     QString cmd = QString("ADD_TEAM") + delimeter +

   105     QString cmd = QString("ADD_TEAM") + delimeter +

   113 

   113 

   114     for(int i = 0; i < HEDGEHOGS_PER_TEAM; ++i)

   114     for(int i = 0; i < HEDGEHOGS_PER_TEAM; ++i)

   115     {

   115     {

   116         cmd.append(delimeter);

   116         cmd.append(delimeter);

   117         cmd.append(team.hedgehog(i).Name);

   117         cmd.append(team.hedgehog(i).Name);

   131     RawSendNet(QString("NICK%1%2").arg(delimeter).arg(nick));

   131     RawSendNet(QString("NICK%1%2").arg(delimeter).arg(nick));

   132 }

   132 }

   133 

   133 

   134 void HWNewNet::ToggleReady()

   134 void HWNewNet::ToggleReady()

   135 {

   135 {

   137 }

   137 }

   138 

   138 

   139 void HWNewNet::SendNet(const QByteArray & buf)

   139 void HWNewNet::SendNet(const QByteArray & buf)

   140 {

   140 {

   144 }

   144 }

   145 

   145 

   146 void HWNewNet::RawSendNet(const QString & str)

   146 void HWNewNet::RawSendNet(const QString & str)

   147 {

   147 {

   149 }

   149 }

   150 

   150 

   151 void HWNewNet::RawSendNet(const QByteArray & buf)

   151 void HWNewNet::RawSendNet(const QByteArray & buf)

   152 {

   152 {

   153     qDebug() << "Client: " << QString(buf).split("\n");

   153     qDebug() << "Client: " << QString(buf).split("\n");

   155     NetSocket.write("\n\n", 2);

   155     NetSocket.write("\n\n", 2);

   156 }

   156 }

   157 

   157 

   158 void HWNewNet::ClientRead()

   158 void HWNewNet::ClientRead()

   159 {

   159 {

   161         QString s = QString::fromUtf8(NetSocket.readLine());

   162         QString s = QString::fromUtf8(NetSocket.readLine());

   162         if (s.endsWith('\n')) s.chop(1);

   163         if (s.endsWith('\n')) s.chop(1);

   163 

   164 

   165             ParseCmd(cmdbuf);

   167             ParseCmd(cmdbuf);

   166             cmdbuf.clear();

   168             cmdbuf.clear();

   168             cmdbuf << s;

   171             cmdbuf << s;

   169     }

   172     }

   170 }

   173 }

   171 

   174 

   172 void HWNewNet::OnConnect()

   175 void HWNewNet::OnConnect()

   174     netClientState = Connected;

   177     netClientState = Connected;

   175 }

   178 }

   176 

   179 

   177 void HWNewNet::OnDisconnect()

   180 void HWNewNet::OnDisconnect()

   178 {

   181 {

   183 

   186 

   184 void HWNewNet::displayError(QAbstractSocket::SocketError socketError)

   187 void HWNewNet::displayError(QAbstractSocket::SocketError socketError)

   185 {

   188 {

   186     m_game_connected = false;

   189     m_game_connected = false;

   187 

   190 

   189         case QAbstractSocket::RemoteHostClosedError:

   193         case QAbstractSocket::RemoteHostClosedError:

   190             break;

   194             break;

   191         case QAbstractSocket::HostNotFoundError:

   195         case QAbstractSocket::HostNotFoundError:

   192             emit disconnected(tr("The host was not found. Please check the host name and port settings."));

   196             emit disconnected(tr("The host was not found. Please check the host name and port settings."));

   193             break;

   197             break;

   194         case QAbstractSocket::ConnectionRefusedError:

   198         case QAbstractSocket::ConnectionRefusedError:

   195             emit disconnected(tr("Connection refused"));

   199             emit disconnected(tr("Connection refused"));

   196             break;

   200             break;

   197         default:

   201         default:

   198             emit disconnected(NetSocket.errorString());

   202             emit disconnected(NetSocket.errorString());

   200 }

   204 }

   201 

   205 

   202 void HWNewNet::SendPasswordHash(const QString & hash)

   206 void HWNewNet::SendPasswordHash(const QString & hash)

   203 {

   207 {

   204     RawSendNet(QString("PASSWORD%1%2").arg(delimeter).arg(hash));

   208     RawSendNet(QString("PASSWORD%1%2").arg(delimeter).arg(hash));

   205 }

   209 }

   206 

   210 

   207 void HWNewNet::ParseCmd(const QStringList & lst)

   211 void HWNewNet::ParseCmd(const QStringList & lst)

   208 {

   212 {

   210 

   214 

   211     if(!lst.size())

   215     if(!lst.size())

   212     {

   216     {

   213         qWarning("Net client: Bad message");

   217         qWarning("Net client: Bad message");

   214         return;

   218         return;

   221     }

   225     }

   222 

   226 

   223     if (lst[0] == "PROTO")

   227     if (lst[0] == "PROTO")

   224         return ;

   228         return ;

   225 

   229 

   227         if (lst.size() == 2)

   232         if (lst.size() == 2)

   228             emit Error(lst[1]);

   233             emit Error(lst[1]);

   229         else

   234         else

   230             emit Error("Unknown error");

   235             emit Error("Unknown error");

   231         return;

   236         return;

   232     }

   237     }

   233 

   238 

   235         if (lst.size() == 2)

   241         if (lst.size() == 2)

   236             emit Warning(lst[1]);

   242             emit Warning(lst[1]);

   237         else

   243         else

   238             emit Warning("Unknown warning");

   244             emit Warning("Unknown warning");

   239         return;

   245         return;

   240     }

   246     }

   241 

   247 

   243         if(lst.size() < 3 || lst[2].toInt() < cMinServerVersion)

   250         if(lst.size() < 3 || lst[2].toInt() < cMinServerVersion)

   244         {

   251         {

   245             // TODO: Warn user, disconnect

   252             // TODO: Warn user, disconnect

   246             qWarning() << "Server too old";

   253             qWarning() << "Server too old";

   247         }

   254         }

   252         m_game_connected = true;

   259         m_game_connected = true;

   253         emit adminAccess(false);

   260         emit adminAccess(false);

   254         return;

   261         return;

   255     }

   262     }

   256 

   263 

   258         if (lst.size() > 1)

   266         if (lst.size() > 1)

   259             RawSendNet(QString("PONG%1%2").arg(delimeter).arg(lst[1]));

   267             RawSendNet(QString("PONG%1%2").arg(delimeter).arg(lst[1]));

   260         else

   268         else

   261             RawSendNet(QString("PONG"));

   269             RawSendNet(QString("PONG"));

   262         return;

   270         return;

   263     }

   271     }

   264 

   272 

   266         QStringList tmp = lst;

   275         QStringList tmp = lst;

   267         tmp.removeFirst();

   276         tmp.removeFirst();

   268         emit roomsList(tmp);

   277         emit roomsList(tmp);

   269         return;

   278         return;

   270     }

   279     }

   271 

   280 

   273         if(lst.size() < 2)

   283         if(lst.size() < 2)

   274         {

   284         {

   275             qWarning("Net: Empty SERVERMESSAGE message");

   285             qWarning("Net: Empty SERVERMESSAGE message");

   276             return;

   286             return;

   277         }

   287         }

   278         emit serverMessage(lst[1]);

   288         emit serverMessage(lst[1]);

   279         return;

   289         return;

   280     }

   290     }

   281 

   291 

   283         if(lst.size() < 3)

   294         if(lst.size() < 3)

   284         {

   295         {

   285             qWarning("Net: Empty CHAT message");

   296             qWarning("Net: Empty CHAT message");

   286             return;

   297             return;

   287         }

   298         }

   290         else

   301         else

   291             emit chatStringFromNet(HWProto::formatChatMsg(lst[1], lst[2]));

   302             emit chatStringFromNet(HWProto::formatChatMsg(lst[1], lst[2]));

   292         return;

   303         return;

   293     }

   304     }

   294 

   305 

   296         if(lst.size() < 5)

   308         if(lst.size() < 5)

   297         {

   309         {

   298             qWarning("Net: Malformed INFO message");

   310             qWarning("Net: Malformed INFO message");

   299             return;

   311             return;

   300         }

   312         }

   305         else

   317         else

   306             emit chatStringFromNet(tmp.join("\n").prepend('\x01'));

   318             emit chatStringFromNet(tmp.join("\n").prepend('\x01'));

   307         return;

   319         return;

   308     }

   320     }

   309 

   321 

   311         QStringList tmp = lst;

   324         QStringList tmp = lst;

   312         tmp.removeFirst();

   325         tmp.removeFirst();

   313         while (tmp.size() >= 2)

   326         while (tmp.size() >= 2)

   314         {

   327         {

   315             if(tmp[0] == "MOTD_NEW") emit serverMessageNew(tmp[1]);

   328             if(tmp[0] == "MOTD_NEW") emit serverMessageNew(tmp[1]);

   338             flags.remove(0, 1);

   351             flags.remove(0, 1);

   339             char c = flags[0].toAscii();

   352             char c = flags[0].toAscii();

   340 

   353 

   341             switch(c)

   354             switch(c)

   342             {

   355             {

   344                 {

   357                 {

   345                     for(int i = 2; i < lst.size(); ++i)

   358                     for(int i = 2; i < lst.size(); ++i)

   346                     {

   359                     {

   348                             emit setMyReadyStatus(setFlag);

   362                             emit setMyReadyStatus(setFlag);

   349                         }

   363                         }

   350 

   364 

   351                         emit setReadyStatus(lst[i], setFlag);

   365                         emit setReadyStatus(lst[i], setFlag);

   352                     }

   366                     }

   355         }

   369         }

   356 

   370 

   357         return;

   371         return;

   358     }

   372     }

   359 

   373 

   361         if(lst.size() != 24)

   376         if(lst.size() != 24)

   362         {

   377         {

   363             qWarning("Net: Bad ADDTEAM message");

   378             qWarning("Net: Bad ADDTEAM message");

   364             return;

   379             return;

   365         }

   380         }

   367         tmp.removeFirst();

   382         tmp.removeFirst();

   368         emit AddNetTeam(tmp);

   383         emit AddNetTeam(tmp);

   369         return;

   384         return;

   370     }

   385     }

   371 

   386 

   373         if(lst.size() != 2)

   389         if(lst.size() != 2)

   374         {

   390         {

   375             qWarning("Net: Bad REMOVETEAM message");

   391             qWarning("Net: Bad REMOVETEAM message");

   376             return;

   392             return;

   377         }

   393         }

   378         emit RemoveNetTeam(HWTeam(lst[1]));

   394         emit RemoveNetTeam(HWTeam(lst[1]));

   379         return;

   395         return;

   380     }

   396     }

   381 

   397 

   383         netClientState = InLobby;

   400         netClientState = InLobby;

   384         askRoomsList();

   401         askRoomsList();

   385         emit LeftRoom(tr("Room destroyed"));

   402         emit LeftRoom(tr("Room destroyed"));

   386         return;

   403         return;

   387     }

   404     }

   388 

   405 

   390         netClientState = InLobby;

   408         netClientState = InLobby;

   391         askRoomsList();

   409         askRoomsList();

   392         emit LeftRoom(tr("You got kicked"));

   410         emit LeftRoom(tr("You got kicked"));

   393         return;

   411         return;

   394     }

   412     }

   395 

   413 

   397         if(lst.size() < 2)

   416         if(lst.size() < 2)

   398         {

   417         {

   399             qWarning("Net: Bad JOINED message");

   418             qWarning("Net: Bad JOINED message");

   400             return;

   419             return;

   401         }

   420         }

   415             emit chatStringFromNet(tr("%1 *** %2 has joined the room").arg('\x03').arg(lst[i]));

   434             emit chatStringFromNet(tr("%1 *** %2 has joined the room").arg('\x03').arg(lst[i]));

   416         }

   435         }

   417         return;

   436         return;

   418     }

   437     }

   419 

   438 

   421         if(lst.size() < 2)

   441         if(lst.size() < 2)

   422         {

   442         {

   423             qWarning("Net: Bad JOINED message");

   443             qWarning("Net: Bad JOINED message");

   424             return;

   444             return;

   425         }

   445         }

   437             emit chatStringLobby(lst[i], tr("%1 *** %2 has joined").arg('\x03').arg("|nick|"));

   457             emit chatStringLobby(lst[i], tr("%1 *** %2 has joined").arg('\x03').arg("|nick|"));

   438         }

   458         }

   439         return;

   459         return;

   440     }

   460     }

   441 

   461 

   443         if(lst.size() < 2)

   464         if(lst.size() < 2)

   444         {

   465         {

   445             qWarning("Net: Bad LEFT message");

   466             qWarning("Net: Bad LEFT message");

   446             return;

   467             return;

   447         }

   468         }

   451         else

   472         else

   452             emit chatStringFromNet(tr("%1 *** %2 has left (%3)").arg('\x03').arg(lst[1], lst[2]));

   473             emit chatStringFromNet(tr("%1 *** %2 has left (%3)").arg('\x03').arg(lst[1], lst[2]));

   453         return;

   474         return;

   454     }

   475     }

   455 

   476 

   457         if(lst.size() < 2)

   479         if(lst.size() < 2)

   458         {

   480         {

   459             qWarning("Net: Bad ROOM message");

   481             qWarning("Net: Bad ROOM message");

   460             return;

   482             return;

   461         }

   483         }

   462         RawSendNet(QString("LIST"));

   484         RawSendNet(QString("LIST"));

   463         return;

   485         return;

   464     }

   486     }

   465 

   487 

   467         if(lst.size() < 2)

   490         if(lst.size() < 2)

   468         {

   491         {

   469             qWarning("Net: Bad LOBBY:LEFT message");

   492             qWarning("Net: Bad LOBBY:LEFT message");

   470             return;

   493             return;

   471         }

   494         }

   475         else

   498         else

   476             emit chatStringLobby(lst[1], tr("%1 *** %2 has left (%3)").arg('\x03').arg("|nick|", lst[2]));

   499             emit chatStringLobby(lst[1], tr("%1 *** %2 has left (%3)").arg('\x03').arg("|nick|", lst[2]));

   477         return;

   500         return;

   478     }

   501     }

   479 

   502 

   481         netClientState = InGame;

   505         netClientState = InGame;

   482         emit AskForRunGame();

   506         emit AskForRunGame();

   483         return;

   507         return;

   484     }

   508     }

   485 

   509 

   487         emit AskForPassword(mynick);

   512         emit AskForPassword(mynick);

   488         return;

   513         return;

   489     }

   514     }

   490 

   515 

   492         if(lst.size() < 2)

   518         if(lst.size() < 2)

   493         {

   519         {

   494             qWarning("Net: Bad NOTICE message");

   520             qWarning("Net: Bad NOTICE message");

   495             return;

   521             return;

   496         }

   522         }

   506         handleNotice(n);

   532         handleNotice(n);

   507 

   533 

   508         return;

   534         return;

   509     }

   535     }

   510 

   536 

   512         if (lst.size() != 2)

   539         if (lst.size() != 2)

   513         {

   540         {

   514             qWarning("Net: Bad TEAM_ACCEPTED message");

   541             qWarning("Net: Bad TEAM_ACCEPTED message");

   515             return;

   542             return;

   516         }

   543         }

   517         emit TeamAccepted(lst[1]);

   544         emit TeamAccepted(lst[1]);

   518         return;

   545         return;

   519     }

   546     }

   520 

   547 

   521 

   548 

   523         if(lst.size() < 3)

   551         if(lst.size() < 3)

   524         {

   552         {

   525             qWarning("Net: Bad CFG message");

   553             qWarning("Net: Bad CFG message");

   526             return;

   554             return;

   527         }

   555         }

   533         else

   561         else

   534             emit paramChanged(lst[1], tmp);

   562             emit paramChanged(lst[1], tmp);

   535         return;

   563         return;

   536     }

   564     }

   537 

   565 

   539         if (lst.size() != 3)

   568         if (lst.size() != 3)

   540         {

   569         {

   541             qWarning("Net: Bad TEAM_ACCEPTED message");

   570             qWarning("Net: Bad TEAM_ACCEPTED message");

   542             return;

   571             return;

   543         }

   572         }

   545         tmptm.setNumHedgehogs(lst[2].toUInt());

   574         tmptm.setNumHedgehogs(lst[2].toUInt());

   546         emit hhnumChanged(tmptm);

   575         emit hhnumChanged(tmptm);

   547         return;

   576         return;

   548     }

   577     }

   549 

   578 

   551         if (lst.size() != 3)

   581         if (lst.size() != 3)

   552         {

   582         {

   553             qWarning("Net: Bad TEAM_COLOR message");

   583             qWarning("Net: Bad TEAM_COLOR message");

   554             return;

   584             return;

   555         }

   585         }

   557         tmptm.setColor(QColor(lst[2]));

   587         tmptm.setColor(QColor(lst[2]));

   558         emit teamColorChanged(tmptm);

   588         emit teamColorChanged(tmptm);

   559         return;

   589         return;

   560     }

   590     }

   561 

   591 

   563         if(lst.size() < 2)

   594         if(lst.size() < 2)

   564         {

   595         {

   565             qWarning("Net: Bad EM message");

   596             qWarning("Net: Bad EM message");

   566             return;

   597             return;

   567         }

   598         }

   571             emit FromNet(em);

   602             emit FromNet(em);

   572         }

   603         }

   573         return;

   604         return;

   574     }

   605     }

   575 

   606 

   577         if (lst.size() < 2)

   609         if (lst.size() < 2)

   578         {

   610         {

   579             qWarning("Net: Bad BYE message");

   611             qWarning("Net: Bad BYE message");

   580             return;

   612             return;

   581         }

   613         }

   588         emit disconnected(lst[1]);

   620         emit disconnected(lst[1]);

   589         return;

   621         return;

   590     }

   622     }

   591 

   623 

   592 

   624 

   594         emit adminAccess(true);

   627         emit adminAccess(true);

   595         return;

   628         return;

   596     }

   629     }

   597 

   630 

   599         if (lst.size() < 2)

   633         if (lst.size() < 2)

   600         {

   634         {

   601             qWarning("Net: Bad ROOM_CONTROL_ACCESS message");

   635             qWarning("Net: Bad ROOM_CONTROL_ACCESS message");

   602             return;

   636             return;

   603         }

   637         }

   610 }

   644 }

   611 

   645 

   612 void HWNewNet::onHedgehogsNumChanged(const HWTeam& team)

   646 void HWNewNet::onHedgehogsNumChanged(const HWTeam& team)

   613 {

   647 {

   614     if (isChief)

   648     if (isChief)

   619 }

   653 }

   620 

   654 

   621 void HWNewNet::onTeamColorChanged(const HWTeam& team)

   655 void HWNewNet::onTeamColorChanged(const HWTeam& team)

   622 {

   656 {

   623     if (isChief)

   657     if (isChief)

   628 }

   662 }

   629 

   663 

   630 void HWNewNet::onParamChanged(const QString & param, const QStringList & value)

   664 void HWNewNet::onParamChanged(const QString & param, const QStringList & value)

   631 {

   665 {

   632     if (isChief)

   666     if (isChief)

   633         RawSendNet(

   667         RawSendNet(

   639 }

   673 }

   640 

   674 

   641 void HWNewNet::chatLineToNet(const QString& str)

   675 void HWNewNet::chatLineToNet(const QString& str)

   642 {

   676 {

   644         RawSendNet(QString("CHAT") + delimeter + str);

   679         RawSendNet(QString("CHAT") + delimeter + str);

   645         emit(chatStringFromMe(HWProto::formatChatMsg(mynick, str)));

   680         emit(chatStringFromMe(HWProto::formatChatMsg(mynick, str)));

   646     }

   681     }

   647 }

   682 }

   648 

   683 

   649 void HWNewNet::chatLineToLobby(const QString& str)

   684 void HWNewNet::chatLineToLobby(const QString& str)

   650 {

   685 {

   652         RawSendNet(QString("CHAT") + delimeter + str);

   688         RawSendNet(QString("CHAT") + delimeter + str);

   653         emit chatStringLobby(mynick, HWProto::formatChatMsgForFrontend(str));

   689         emit chatStringLobby(mynick, HWProto::formatChatMsgForFrontend(str));

   654     }

   690     }

   655 }

   691 }

   656 

   692 

   715     RawSendNet(QString("INFO%1%2").arg(delimeter).arg(nick));

   751     RawSendNet(QString("INFO%1%2").arg(delimeter).arg(nick));

   716 }

   752 }

   717 

   753 

   718 void HWNewNet::followPlayer(const QString & nick)

   754 void HWNewNet::followPlayer(const QString & nick)

   719 {

   755 {

   721         RawSendNet(QString("FOLLOW%1%2").arg(delimeter).arg(nick));

   758         RawSendNet(QString("FOLLOW%1%2").arg(delimeter).arg(nick));

   722         isChief = false;

   759         isChief = false;

   723     }

   760     }

   724 }

   761 }

   725 

   762