1 /*

     2  * Hedgewars, a free turn based strategy game

     3  * Copyright (c) 2006-2008 Igor Ulyanov <iulyanov@gmail.com>

     4  * Copyright (c) 2008-2011 Andrey Korotaev <unC0Rr@gmail.com>

     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; version 2 of the License

     9  *

    10  * This program is distributed in the hope that it will be useful,

    11  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    13  * GNU General Public License for more details.

    14  *

    15  * You should have received a copy of the GNU General Public License

    16  * along with this program; if not, write to the Free Software

    17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

    18  */

    19 

    20 #include <QDebug>

    21 #include <QInputDialog>

    22 #include <QCryptographicHash>

    23 

    24 #include "hwconsts.h"

    25 #include "newnetclient.h"

    26 #include "proto.h"

    27 #include "game.h"

    28 #include "misc.h"

    29 /* only to get the ignoreList from the chat widget */

    30 #include "hwform.h"

    31 #include "pageroomslist.h"

    32 #include "chatwidget.h"

    33 

    34 char delimeter='\n';

    35 

    36 HWNewNet::HWNewNet() :

    37   isChief(false),

    38   m_game_connected(false),

    39   loginStep(0),

    40   netClientState(0)

    41 {

    42 // socket stuff

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

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

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

    46     connect(&NetSocket, SIGNAL(error(QAbstractSocket::SocketError)), this,

    47             SLOT(displayError(QAbstractSocket::SocketError)));

    48 }

    49 

    50 HWNewNet::~HWNewNet()

    51 {

    52     if (m_game_connected)

    53     {

    54         RawSendNet(QString("QUIT%1%2").arg(delimeter).arg("User quit"));

    55         emit Disconnected(tr("User quit"));

    56     }

    57     NetSocket.flush();

    58 }

    59 

    60 void HWNewNet::Connect(const QString & hostName, quint16 port, const QString & nick)

    61 {

    62     mynick = nick;

    63     myhost = hostName + QString(":%1").arg(port);

    64     NetSocket.connectToHost(hostName, port);

    65 }

    66 

    67 void HWNewNet::Disconnect()

    68 {

    69     if (m_game_connected)

    70         RawSendNet(QString("QUIT%1%2").arg(delimeter).arg("User quit"));

    71     m_game_connected = false;

    72 

    73     NetSocket.disconnectFromHost();

    74 }

    75 

    76 void HWNewNet::CreateRoom(const QString & room)

    77 {

    78     if(netClientState != 2)

    79     {

    80         qWarning("Illegal try to create room!");

    81         return;

    82     }

    83 

    84     myroom = room;

    85 

    86     RawSendNet(QString("CREATE_ROOM%1%2").arg(delimeter).arg(room));

    87     isChief = true;

    88 }

    89 

    90 void HWNewNet::JoinRoom(const QString & room)

    91 {

    92     if(netClientState != 2)

    93     {

    94         qWarning("Illegal try to join room!");

    95         return;

    96     }

    97 

    98     myroom = room;

    99 

   100     RawSendNet(QString("JOIN_ROOM%1%2").arg(delimeter).arg(room));

   101     isChief = false;

   102 }

   103 

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

   105 {

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

   107          team.name() + delimeter +

   108          team.color().name() + delimeter +

   109          team.grave() + delimeter +

   110          team.fort() + delimeter +

   111          team.voicepack() + delimeter +

   112          team.flag() + delimeter +

   113          QString::number(team.difficulty());

   114 

   115     for(unsigned int i = 0; i < HEDGEHOGS_PER_TEAM; ++i)

   116     {

   117         cmd.append(delimeter);

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

   119         cmd.append(delimeter);

   120         cmd.append(team.hedgehog(i).Hat);

   121     }

   122     RawSendNet(cmd);

   123 }

   124 

   125 void HWNewNet::RemoveTeam(const HWTeam & team)

   126 {

   127     RawSendNet(QString("REMOVE_TEAM") + delimeter + team.name());

   128 }

   129 

   130 void HWNewNet::NewNick(const QString & nick)

   131 {

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

   133 }

   134 

   135 void HWNewNet::ToggleReady()

   136 {

   137   RawSendNet(QString("TOGGLE_READY"));

   138 }

   139 

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

   141 {

   142   QString msg = QString(buf.toBase64());

   143 

   144   RawSendNet(QString("EM%1%2").arg(delimeter).arg(msg));

   145 }

   146 

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

   148 {

   149   RawSendNet(str.toUtf8());

   150 }

   151 

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

   153 {

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

   155     NetSocket.write(buf);

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

   157 }

   158 

   159 void HWNewNet::ClientRead()

   160 {

   161     while (NetSocket.canReadLine()) {

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

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

   164 

   165         if (s.size() == 0) {

   166             ParseCmd(cmdbuf);

   167             cmdbuf.clear();

   168         } else

   169             cmdbuf << s;

   170     }

   171 }

   172 

   173 void HWNewNet::OnConnect()

   174 {

   175 }

   176 

   177 void HWNewNet::OnDisconnect()

   178 {

   179     if(m_game_connected) emit Disconnected("");

   180     m_game_connected = false;

   181 }

   182 

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

   184 {

   185     m_game_connected = false;

   186 

   187     switch (socketError) {

   188         case QAbstractSocket::RemoteHostClosedError:

   189             break;

   190         case QAbstractSocket::HostNotFoundError:

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

   192             break;

   193         case QAbstractSocket::ConnectionRefusedError:

   194             emit Disconnected(tr("Connection refused"));

   195             break;

   196         default:

   197             emit Disconnected(NetSocket.errorString());

   198         }

   199 }

   200 

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

   202 {

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

   204 }

   205 

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

   207 {

   208   qDebug() << "Server: " << lst;

   209 

   210     if(!lst.size())

   211     {

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

   213         return;

   214     }

   215 

   216     if (lst[0] == "NICK")

   217     {

   218         mynick = lst[1];

   219         return ;

   220     }

   221 

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

   223         return ;

   224 

   225     if (lst[0] == "ERROR") {

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

   227             emit Error(lst[1]);

   228         else

   229             emit Error("Unknown error");

   230         return;

   231     }

   232 

   233     if (lst[0] == "WARNING") {

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

   235             emit Warning(lst[1]);

   236         else

   237             emit Warning("Unknown warning");

   238         return;

   239     }

   240 

   241     if (lst[0] == "CONNECTED") {

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

   243         {

   244             // TODO: Warn user, disconnect

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

   246         }

   247 

   248         RawSendNet(QString("NICK%1%2").arg(delimeter).arg(mynick));

   249         RawSendNet(QString("PROTO%1%2").arg(delimeter).arg(*cProtoVer));

   250         netClientState = 1;

   251         m_game_connected = true;

   252         emit adminAccess(false);

   253         return;

   254     }

   255 

   256     if (lst[0] == "PING") {

   257         if (lst.size() > 1)

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

   259         else

   260             RawSendNet(QString("PONG"));

   261         return;

   262     }

   263 

   264     if (lst[0] == "ROOMS") {

   265         QStringList tmp = lst;

   266         tmp.removeFirst();

   267         emit roomsList(tmp);

   268         return;

   269     }

   270 

   271     if (lst[0] == "SERVER_MESSAGE") {

   272         if(lst.size() < 2)

   273         {

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

   275             return;

   276         }

   277         emit serverMessage(lst[1]);

   278         return;

   279     }

   280 

   281     if (lst[0] == "CHAT") {

   282         if(lst.size() < 3)

   283         {

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

   285             return;

   286         }

   287         if (netClientState == 2)

   288             emit chatStringLobby(lst[1], HWProto::formatChatMsgForFrontend(lst[2]));

   289         else

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

   291         return;

   292     }

   293 

   294     if (lst[0] == "INFO") {

   295         if(lst.size() < 5)

   296         {

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

   298             return;

   299         }

   300         QStringList tmp = lst;

   301         tmp.removeFirst();

   302         if (netClientState == 2)

   303             emit chatStringLobby(tmp.join("\n").prepend('\x01'));

   304         else

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

   306         return;

   307     }

   308 

   309     if (lst[0] == "SERVER_VARS") {

   310         QStringList tmp = lst;

   311         tmp.removeFirst();

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

   313         {

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

   315             else if(tmp[0] == "MOTD_OLD") emit serverMessageOld(tmp[1]);

   316             else if(tmp[0] == "LATEST_PROTO") emit latestProtocolVar(tmp[1].toInt());

   317 

   318             tmp.removeFirst();

   319             tmp.removeFirst();

   320         }

   321         return;

   322     }

   323 

   324     if (lst[0] == "CLIENT_FLAGS")

   325     {

   326         if(lst.size() < 3 || lst[1].size() < 2)

   327         {

   328             qWarning("Net: Malformed CLIENT_FLAGS message");

   329             return;

   330         }

   331 

   332         QString flags = lst[1];

   333         bool setFlag = flags[0] == '+';

   334 

   335         while(flags.size() > 1)

   336         {

   337             flags.remove(0, 1);

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

   339 

   340             switch(c)

   341             {

   342             case 'r':

   343                 {

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

   345                     {

   346                         if (lst[i] == mynick)

   347                             emit setMyReadyStatus(setFlag);

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

   349                     }

   350                 }

   351             }

   352         }

   353 

   354         return;

   355     }

   356 

   357     if (lst[0] == "ADD_TEAM") {

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

   359         {

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

   361             return;

   362         }

   363         QStringList tmp = lst;

   364         tmp.removeFirst();

   365         emit AddNetTeam(tmp);

   366         return;

   367     }

   368 

   369     if (lst[0] == "REMOVE_TEAM") {

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

   371         {

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

   373             return;

   374         }

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

   376         return;

   377     }

   378 

   379     if(lst[0] == "ROOMABANDONED") {

   380         netClientState = 2;

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

   382         return;

   383     }

   384 

   385     if(lst[0] == "KICKED") {

   386         netClientState = 2;

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

   388         return;

   389     }

   390 

   391     if(lst[0] == "JOINED") {

   392         if(lst.size() < 2)

   393         {

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

   395             return;

   396         }

   397 

   398         for(int i = 1; i < lst.size(); ++i)

   399         {

   400             if (lst[i] == mynick)

   401             {

   402                 netClientState = 3;

   403                 emit EnteredGame();

   404                 emit roomMaster(isChief);

   405                 if (isChief)

   406                     emit configAsked();

   407             }

   408             // TODO reactivate

   409 /*

   410             if (lst[i] != mynick && isChief && config->Form->ui.pageRoomsList->chatWidget->ignoreList.contains(lst[i], Qt::CaseInsensitive) && !config->Form->ui.pageRoomsList->chatWidget->friendsList.contains(lst[i], Qt::CaseInsensitive))

   411             {

   412                 kickPlayer(lst[i]);

   413             }

   414             else

   415 */

   416             {

   417                 emit nickAdded(lst[i], isChief && (lst[i] != mynick));

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

   419             }

   420         }

   421         return;

   422     }

   423 

   424     if(lst[0] == "LOBBY:JOINED") {

   425         if(lst.size() < 2)

   426         {

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

   428             return;

   429         }

   430 

   431         for(int i = 1; i < lst.size(); ++i)

   432         {

   433             if (lst[i] == mynick)

   434             {

   435                 netClientState = 2;

   436                 RawSendNet(QString("LIST"));

   437                 emit Connected();

   438             }

   439 

   440             emit nickAddedLobby(lst[i], false);

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

   442         }

   443         return;

   444     }

   445 

   446     if(lst[0] == "LEFT") {

   447         if(lst.size() < 2)

   448         {

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

   450             return;

   451         }

   452         emit nickRemoved(lst[1]);

   453         if (lst.size() < 3)

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

   455         else

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

   457         return;

   458     }

   459 

   460     if(lst[0] == "ROOM") {

   461         if(lst.size() < 2)

   462         {

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

   464             return;

   465         }

   466         RawSendNet(QString("LIST"));

   467         return;

   468     }

   469 

   470     if(lst[0] == "LOBBY:LEFT") {

   471         if(lst.size() < 2)

   472         {

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

   474             return;

   475         }

   476         emit nickRemovedLobby(lst[1]);

   477         if (lst.size() < 3)

   478             emit chatStringLobby(tr("%1 *** %2 has left").arg('\x03').arg(lst[1]));

   479         else

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

   481         return;

   482     }

   483 

   484     if (lst[0] == "RUN_GAME") {

   485         netClientState = 5;

   486         emit AskForRunGame();

   487         return;

   488     }

   489 

   490     if (lst[0] == "ASKPASSWORD") {

   491         emit AskForPassword(mynick);

   492         return;

   493     }

   494 

   495     if (lst[0] == "NOTICE") {

   496         if(lst.size() < 2)

   497         {

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

   499             return;

   500         }

   501 

   502         bool ok;

   503         int n = lst[1].toInt(&ok);

   504         if(!ok)

   505         {

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

   507             return;

   508         }

   509 

   510         handleNotice(n);

   511 

   512         return;

   513     }

   514 

   515     if (lst[0] == "TEAM_ACCEPTED") {

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

   517         {

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

   519             return;

   520         }

   521         emit TeamAccepted(lst[1]);

   522         return;

   523     }

   524 

   525 

   526     if (lst[0] == "CFG") {

   527         if(lst.size() < 3)

   528         {

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

   530             return;

   531         }

   532         QStringList tmp = lst;

   533         tmp.removeFirst();

   534         tmp.removeFirst();

   535         if (lst[1] == "SCHEME")

   536             emit netSchemeConfig(tmp);

   537         else

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

   539         return;

   540     }

   541 

   542     if (lst[0] == "HH_NUM") {

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

   544         {

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

   546             return;

   547         }

   548         HWTeam tmptm(lst[1]);

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

   550         emit hhnumChanged(tmptm);

   551         return;

   552     }

   553 

   554     if (lst[0] == "TEAM_COLOR") {

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

   556         {

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

   558             return;

   559         }

   560         HWTeam tmptm(lst[1]);

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

   562         emit teamColorChanged(tmptm);

   563         return;

   564     }

   565 

   566     if (lst[0] == "EM") {

   567         if(lst.size() < 2)

   568         {

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

   570             return;

   571         }

   572         for(int i = 1; i < lst.size(); ++i)

   573         {

   574             QByteArray em = QByteArray::fromBase64(lst[i].toAscii());

   575             emit FromNet(em);

   576         }

   577         return;

   578     }

   579 

   580     if (lst[0] == "BYE") {

   581         if (lst.size() < 2)

   582         {

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

   584             return;

   585         }

   586         if (lst[1] == "Authentication failed")

   587         {

   588             emit AuthFailed();

   589         }

   590         m_game_connected = false;

   591         Disconnect();

   592         emit Disconnected(lst[1]);

   593         return;

   594     }

   595 

   596 

   597     if (lst[0] == "ADMIN_ACCESS") {

   598         emit adminAccess(true);

   599         return;

   600     }

   601 

   602     if (lst[0] == "ROOM_CONTROL_ACCESS") {

   603         if (lst.size() < 2)

   604         {

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

   606             return;

   607         }

   608         isChief = (lst[1] != "0");

   609         emit roomMaster(isChief);

   610         return;

   611     }

   612 

   613     qWarning() << "Net: Unknown message:" << lst;

   614 }

   615 

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

   617 {

   618     if (isChief)

   619     RawSendNet(QString("HH_NUM%1%2%1%3")

   620             .arg(delimeter)

   621             .arg(team.name())

   622             .arg(team.numHedgehogs()));

   623 }

   624 

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

   626 {

   627     if (isChief)

   628     RawSendNet(QString("TEAM_COLOR%1%2%1%3")

   629             .arg(delimeter)

   630             .arg(team.name())

   631             .arg(team.color().name()));

   632 }

   633 

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

   635 {

   636     if (isChief)

   637         RawSendNet(

   638                 QString("CFG%1%2%1%3")

   639                     .arg(delimeter)

   640                     .arg(param)

   641                     .arg(value.join(QString(delimeter)))

   642                 );

   643 }

   644 

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

   646 {

   647     if(str != "") {

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

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

   650     }

   651 }

   652 

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

   654 {

   655     if(str != "") {

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

   657         emit(chatStringFromMeLobby(HWProto::formatChatMsg(mynick, str)));

   658     }

   659 }

   660 

   661 void HWNewNet::SendTeamMessage(const QString& str)

   662 {

   663     RawSendNet(QString("TEAMCHAT") + delimeter + str);

   664 }

   665 

   666 void HWNewNet::askRoomsList()

   667 {

   668     if(netClientState != 2)

   669     {

   670         qWarning("Illegal try to get rooms list!");

   671         return;

   672     }

   673     RawSendNet(QString("LIST"));

   674 }

   675 

   676 int HWNewNet::getClientState()

   677 {

   678     return netClientState;

   679 }

   680 

   681 QString HWNewNet::getNick()

   682 {

   683     return mynick;

   684 }

   685 

   686 QString HWNewNet::getRoom()

   687 {

   688     return myroom;

   689 }

   690 

   691 QString HWNewNet::getHost()

   692 {

   693     return myhost;

   694 }

   695 

   696 bool HWNewNet::isRoomChief()

   697 {

   698     return isChief;

   699 }

   700 

   701 void HWNewNet::gameFinished(bool correctly)

   702 {

   703     if (netClientState == 5) netClientState = 3;

   704     RawSendNet(QString("ROUNDFINISHED%1%2").arg(delimeter).arg(correctly ? "1" : "0"));

   705 }

   706 

   707 void HWNewNet::banPlayer(const QString & nick)

   708 {

   709     RawSendNet(QString("BAN%1%2").arg(delimeter).arg(nick));

   710 }

   711 

   712 void HWNewNet::kickPlayer(const QString & nick)

   713 {

   714     RawSendNet(QString("KICK%1%2").arg(delimeter).arg(nick));

   715 }

   716 

   717 void HWNewNet::infoPlayer(const QString & nick)

   718 {

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

   720 }

   721 

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

   723 {

   724     if (!isInRoom()) {

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

   726         isChief = false;

   727     }

   728 }

   729 

   730 void HWNewNet::startGame()

   731 {

   732     RawSendNet(QString("START_GAME"));

   733 }

   734 

   735 void HWNewNet::updateRoomName(const QString & name)

   736 {

   737     RawSendNet(QString("ROOM_NAME%1%2").arg(delimeter).arg(name));

   738 }

   739 

   740 

   741 void HWNewNet::toggleRestrictJoins()

   742 {

   743     RawSendNet(QString("TOGGLE_RESTRICT_JOINS"));

   744 }

   745 

   746 void HWNewNet::toggleRestrictTeamAdds()

   747 {

   748     RawSendNet(QString("TOGGLE_RESTRICT_TEAMS"));

   749 }

   750 

   751 void HWNewNet::clearAccountsCache()

   752 {

   753     RawSendNet(QString("CLEAR_ACCOUNTS_CACHE"));

   754 }

   755 

   756 void HWNewNet::partRoom()

   757 {

   758     netClientState = 2;

   759     RawSendNet(QString("PART"));

   760 }

   761 

   762 bool HWNewNet::isInRoom()

   763 {

   764     return netClientState > 2;

   765 }

   766 

   767 void HWNewNet::setServerMessageNew(const QString & msg)

   768 {

   769     RawSendNet(QString("SET_SERVER_VAR%1MOTD_NEW%1%2").arg(delimeter).arg(msg));

   770 }

   771 

   772 void HWNewNet::setServerMessageOld(const QString & msg)

   773 {

   774     RawSendNet(QString("SET_SERVER_VAR%1MOTD_OLD%1%2").arg(delimeter).arg(msg));

   775 }

   776 

   777 void HWNewNet::setLatestProtocolVar(int proto)

   778 {

   779     RawSendNet(QString("SET_SERVER_VAR%1LATEST_PROTO%1%2").arg(delimeter).arg(proto));

   780 }

   781 

   782 void HWNewNet::askServerVars()

   783 {

   784     RawSendNet(QString("GET_SERVER_VAR"));

   785 }

   786 

   787 void HWNewNet::handleNotice(int n)

   788 {

   789     switch(n)

   790     {

   791         case 0:

   792         {

   793             emit NickTaken(mynick);

   794             break;

   795         }

   796     }

   797 }