qwbot/Client.cpp

#include "Client.h"
#include <QString>
#include <stdio.h>
#include <QTcpSocket>
#include <QStringList>
#include <QTime>
#include <QTimer>
#include "App.h"
#include "Settings.h"

Client::Client(App *app, ActiveClient* ac):
  QWClient(),
  myActiveClient(ac),
  myApp(app),
  myConnectionRetries(0),
  myOnServerFlag(false),
  mySpamMutedFlag(false),
  myQWMutedFlag(false),
  myJoinMessageTimer(new QTimer()),
  myJoinMessagePrinted(false),
  myJoinMessageScheduled(false)
{
  myQWBroadcastFloodTime = myEndFloodTime;
  mySpamBroadcastFloodTime = myEndFloodTime;
  myJoinMessageTimer->setSingleShot(true);
}

Client::~Client()
{
  delete myJoinMessageTimer;
}

void Client::connect(const char *host, quint16 port)
{
  myJoinMessageScheduled = true; //Hi message only scheduled at bot connection
  myEndFloodTime = QTime::currentTime();

  QWClient::connect(host, port);
}

void Client::say(const QString &msg)
{
	QString cmd = "say " + msg;
	sendCmd(cmd.toAscii().data());
}

void Client::sayTeam(const QString &msg)
{
	QString cmd = "say_team " + msg;
	sendCmd(cmd.toAscii().data());
}

void Client::setTeam(const QString &msg)
{
	sendCmd(QString("setinfo \"team\" \"" + msg + "\"").toAscii().data());
}

void Client::disconnect()
{
  QWClient::disconnect();
  myOnServerFlag = false;
}

void Client::print(const QString &msg)
{
	QString str;

  str = "[" + QTime::currentTime().toString(Qt::ISODate) + "] " + QString(host()) + ":" + QString::number(port()) + "> " + msg;
	QByteArray b = str.toAscii();
	Client::stripColor(b.data());
	str = QString::fromAscii(b.data());

  myApp->print(str);
}

void Client::setPlayerList(PlayerList &playerList)
{
  myPlayerList = playerList;
}

void Client::onDisconnect()
{
	print("Disconnected..\n");
  myOnServerFlag = false;
}

void Client::retryConnection()
{
	if(myConnectionRetries == ConnectionRetries)
	{
		print("Giving up!\n");
		disconnect();
    myOnServerFlag = false;
		return;
	}

	print("Reconnecting...\n");
	reconnect();
	myConnectionRetries++;
}

bool Client::isQWMuted() const
{
  return myQWMutedFlag;
}

bool Client::isSpamMuted() const
{
  return mySpamMutedFlag;
}

void Client::parsePrintedLine()
{
  Player  player;
  bool    parsed = false;
  quint16 lastMatchSize = 0;

  QByteArray playerName;
  QByteArray printLine(myPrintLine.toAscii());

  QWClient::stripColor(printLine.data());

  foreach(player, myPlayerList)
  {
    playerName = player.name.toAscii();
    QWClient::stripColor(playerName.data());
    if(printLine.startsWith(playerName) || (player.spectator && printLine.startsWith(QString("[SPEC] " + player.name).toAscii())))
    {
      if(player.spectator && printLine.startsWith("[SPEC] "))
      {
        if(lastMatchSize < (playerName.size() + 7))
          lastMatchSize = (playerName.size() + 7);
      }
      else if(lastMatchSize < playerName.size())
      {
        lastMatchSize = playerName.size();
      }
      parsed = true;
    }
  }
  if(!parsed)
		return;

  QString nick(myPrintLine.left(lastMatchSize));
  QString message(myPrintLine.right(myPrintLine.size() - lastMatchSize));

  QRegExp regex("^:\\s+\\.(spam|qw|help|qw_mute|qw_unmute|spam_mute|spam_unmute)\\s*(.+)$");
  if(regex.indexIn(message) == -1)
    return;

	/* Flood prot */
  QTime currentTime = QTime::currentTime();

  int timeLeft = currentTime.secsTo(myEndFloodTime);
  if(timeLeft > 0)
	{
		if(!myFloodMsgPrinted)
		{
      say("> FloodProt: Not so fast, wait " + QString::number(timeLeft) + " sec(s).");
			myFloodMsgPrinted = true;
		}
		return;
	}
  myEndFloodTime = currentTime.addSecs(Settings::globalInstance()->floodProtTime());
  myFloodMsgPrinted = false;

  QString command = regex.capturedTexts().at(1);
  QString args = regex.capturedTexts().at(2);

	if(command == "help")
	{
    //say("> Commands:");
    say("> Broadcast a message: .qw <message> and .spam <message>");
    //, beware of the floodprot limits 600s for .qw and 300s for .spam");
    say("> (Un)Mute: .qw_mute .qw_unmute or .spam_mute .spam_unmute");
		return;
	}

  if(command == "qw" || command == "spam")
	{
    if(!args.trimmed().size())
    {
      say("> The format is ." + command + " <message>.");
      return;
    }

    if(command == "qw")
    {
      timeLeft = currentTime.secsTo(myQWBroadcastFloodTime);
      if(timeLeft > 0)
      {
        say("> FloodProt: Wait " + QString::number(timeLeft) + " secs before new .qw");
        return;
      }
      myQWBroadcastFloodTime = currentTime.addSecs(Settings::globalInstance()->qwFloodProtTime());
    }
    else if(command == "spam")
    {
      timeLeft = currentTime.secsTo(mySpamBroadcastFloodTime);
      if(timeLeft > 0)
      {
        say("> FloodProt: Wait " + QString::number(timeLeft) + " secs before new .spam");
        return;
      }
      mySpamBroadcastFloodTime = currentTime.addSecs(Settings::globalInstance()->spamFloodProtTime());
    }

    QString server(QString(host()) + ":" + QString::number(port()));
    QString message("-" + command + "- " + nick + " - " + server + " : " + args.trimmed());

    /* Broadcast within QW servers */
    myApp->broadcast(message, myActiveClient);

    /* Broadcast outside QW */
    nick = parseNameFun(nick); //for the irc message namefun must be removed.
    QString parsedMsg = parseNameFun(args.trimmed());
    //    myApp->requestBroadcast("dev", nick, server, parsedMsg);
    myApp->requestBroadcast(command, nick, server, args.trimmed());

		return;
	}

  if(command == "qw_mute")
  {
    say("> .qw Frequency Muted.");
    myQWMutedFlag = true;
    return;
  }

  if(command == "qw_unmute")
  {
    say("> .qw Frequency Unmuted.");
    myQWMutedFlag = false;
    return;
  }

  if(command == "spam_mute")
  {
    say("> .spam Frequency Muted.");
    mySpamMutedFlag = true;
    return;
  }

  if(command == "spam_unmute")
  {
    say("> .spam Frequency Unmuted.");
    mySpamMutedFlag = false;
    return;
  }
}

void Client::onPrint(int, const char *msg)
{
	if(!strlen(msg))
		return;

	QString text(msg);
	if(text.endsWith('\n'))
	{
		myPrintLine.append(text);
		parsePrintedLine();
    print(myPrintLine);
		myPrintLine.clear();
	}
	else
	{
		myPrintLine.append(text);
	}
}

bool Client::isOnServer() const
{
  return myOnServerFlag;
}

void Client::onError(const char *description)
{
	QString desc(description);
	if(desc == "Client Timed Out.")
	{
		print("Error (" + QString(description) + ")\n");
	}
	else
	{
		print("Error (" + QString(description) + ")\n");
	}
  myOnServerFlag = false;
}

void Client::onLevelChanged(int, const char *levelName, float, float, float, float, float, float, float, float, float, float)
{
	print(QString(levelName) + "\n");
	myDownloadProgressPrintedFlag = false;
  mySpamMutedFlag = false;
  myQWMutedFlag = false;
}

void Client::onChallenge()
{
	print("challenge\n");
}

void Client::onConnection()
{
	print("connection\n");
}

void Client::onConnected()
{
	print("connected\n");
}

void Client::onDownloadStarted(const char *fileName)
{
	print("Download started " + QString(fileName) + "\n");
}

void Client::run()
{
  if(!myJoinMessageTimer->isActive() && !myJoinMessagePrinted)
  {
    say("Hi, I am QWNET's bot, type .help to see my commands.");
    myJoinMessagePrinted = true;
  }

  /* Avoid wrap around */
  if(QTime::currentTime().secsTo(myEndFloodTime) < -16000)
    myEndFloodTime = QTime::currentTime();

  QWClient::run();
}

void Client::onOOBPrint(const char *msg)
{
	print(QString(msg));
}

void Client::onStuffedCmd(const char *cmd)
{
	QString strCmd(cmd);
	if(strCmd == "skins") //connection sequence complete
	{
		myConnectionRetries = 0;
    myOnServerFlag = true;

    /* Only say hi if hi is scheduled */
    if(myJoinMessageScheduled)
    {
      myJoinMessageTimer->start(Settings::globalInstance()->timeToSayHiAfterConnected()*1000);
      myJoinMessagePrinted = false;
      myJoinMessageScheduled = false;
    }
	}
}

void Client::onDownloadProgress(int percent)
{
	if(!(percent % 10))
	{
		if(!myDownloadProgressPrintedFlag)
		{
			print("Download " + QString::number(percent) + "%\n");
			myDownloadProgressPrintedFlag = true;
		}
	}
	else
	{
		myDownloadProgressPrintedFlag = false;
	}
}

void Client::onDownloadFinished()
{
	print("Download 100% finished.\n");
}

QString Client::parseNameFun(const QString &string)
{
  QByteArray b(string.toAscii());
  QWClient::stripColor(b.data());

  return QString(b);
}