qwbot/ActiveClient.cpp

/*
GNU General Public License version 3 notice

Copyright (C) 2012 Mihawk <luiz@netdome.biz>. All rights reserved.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see < http://www.gnu.org/licenses/ >.
*/

#include <QTimer>
#include <QTime>
#include "ServerQuery.h"
#include "ActiveClient.h"
#include "Client.h"
#include "App.h"
#include "Settings.h"

ActiveClient::ActiveClient(App *app, QObject *parent):
  QObject(parent),
  myApp(app),
  myClient(new Client(app)),
  myQuery(new ServerQuery(this)),
  myDisconnectTime(new QTime()),
  myBroadcastReplyTimer(new QTimer(this)),
  myQueryTimer(new QTimer(this)),
  myQueryInterval(Settings::globalInstance()->queryInterval()),
  myUniqueUserCount(0),
  myUniqueChannelCount(0),
  myUniqueServerCount(0),
  myUniquePlayerCount(0),
  myReplyTimerWasActive(false)
{
  connect(myQuery, SIGNAL(finished()), SLOT(queryFinished()));
  connect(myQuery, SIGNAL(error(ServerQuery::Error)), SLOT(queryError(ServerQuery::Error)));

  myQueryTimer->setSingleShot(true);
}

ActiveClient::~ActiveClient()
{
  delete myClient;
  delete myDisconnectTime;
}

Client* ActiveClient::client()
{
  return myClient;
}

quint8 ActiveClient::playerCount() const
{
  return myQuery->playerList().size();
}

void ActiveClient::setAddress(const QHostAddress &address, quint16 port)
{
  myQuery->setAddress(address, port);
  return;
}

void ActiveClient::queryError(ServerQuery::Error)
{
  myQueryTimer->start(myQueryInterval);
}

void ActiveClient::queryFinished()
{
  int playerCount = myQuery->playerList().size();

  myQueryTimer->start(myQueryInterval);

  /* If the client is disconnect check if there is at least one player connected to the server */
  if(myClient->state() == Client::DisconnectedState)
  {
    if(playerCount > 0 && myDisconnectTime->elapsed() > 10000)
    {
      myApp->print("Players online on server " + serverAddressString() + ". Joining...\n");
      myClient->connect(myQuery->address().toString().toAscii(), myQuery->port());
    }
    return;
  }

  /* If the client is connected and left alone on the server, disconnect yourself */
  if(myClient->state() == Client::ConnectedState)
  {
    if(playerCount == 1 && myClient->isOnServer())
    {
      myApp->print("I was left alone on " + serverAddressString() + ". Leaving...\n");
      myClient->disconnect();
      myDisconnectTime->restart();
      return;
    }
  }
}

void ActiveClient::run()
{
  /* Say the broadcast count */
  if(!myBroadcastReplyTimer->isActive() && myReplyTimerWasActive)
  {
    myApp->activeClientsReplyCounters(&myUniqueServerCount, &myUniquePlayerCount); //add my internal counter to the list
    myClient->say("::cims:: Sent to " + QString::number(myUniqueChannelCount) + " channels, " + QString::number(myUniqueUserCount) + " unique users.");
    myClient->say("::cims:: Sent to " + QString::number(myUniqueServerCount) + " servers, " + QString::number(myUniquePlayerCount) + " unique players.");
    myUniqueServerCount = myUniquePlayerCount = myUniqueChannelCount = myUniqueUserCount = 0;
  }
  myReplyTimerWasActive = myBroadcastReplyTimer->isActive();

  /* Query the serverinfo for player count if not already querying */
  if(!myQuery->isActive() && !myQueryTimer->isActive())
    myQuery->query();
  else
    myQuery->run();

  /* Run the client */
  if(myClient->state() != Client::DisconnectedState)
    myClient->run();
}

const QString ActiveClient::serverAddressString()
{
  return QString(myQuery->address().toString() + ':' + QString::number(myQuery->port()));
}

void ActiveClient::setReplyHash(const QString &hash)
{
  myReplyHash = hash;

  /* Wait for 5 seconds */
  myBroadcastReplyTimer->setSingleShot(true);
  myBroadcastReplyTimer->start(5000);
}

const QString& ActiveClient::replyHash() const
{
  return myReplyHash;
}

bool ActiveClient::isWaitingReply() const
{
  return myBroadcastReplyTimer->isActive();
}

void ActiveClient::incrementReplyCounters(int userCount, int channelCount, int playerCount, int serverCount)
{
  if(!myBroadcastReplyTimer->isActive())
    return;

  myUniqueUserCount += userCount;
  myUniqueChannelCount += channelCount;
  myUniqueServerCount += serverCount;
  myUniquePlayerCount += playerCount;
}