• Skip to content
• Skip to link menu

KDE 4.2 API Reference

• KDE API Reference
• API Reference

• Sitemap
• Contact Us

 

libkdegames/kggzmod

module.cpp

Go to the documentation of this file.

/*
    This file is part of the kggzmod library.
    Copyright (c) 2005 - 2007 Josef Spillner <josef@ggzgamingzone.org>

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

    This library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#include "module.h"
#include "module_private.h"

#include <kggzmod/statistics.h>
#include "player_private.h"
#include "statistics_private.h"
#include "misc_private.h"

#include <kggznet/kggzraw.h>

#include <kdebug.h>

#include <stdlib.h> // for getenv()

using namespace KGGZMod;

// Implementation notes:
// 1) all classes have private counterparts to keep the API clean
//  this is a bit clumsy in the source but also offers ABI compatibility
// 2) classes always take ownership of their private objects
//  i.e. after calling obj->init(opriv) the caller mustn't delete opriv
//  and certainly not do anything else including calling init() again

static Module *s_module = NULL;

Module::Module(const QString &name)
: QObject()
{
    s_module = this;

    d = new ModulePrivate();

    d->m_name = name;

    d->m_fd = -1;

    d->m_net = 0;
    d->m_notifier = 0;
    d->m_gnotifier = 0;

    d->m_state = created;

    d->m_playerseats = 0;
    d->m_spectatorseats = 0;

    d->m_myseat = -1;

    connect(d, SIGNAL(signalEvent(const KGGZMod::Event&)), this, SIGNAL(signalEvent(const KGGZMod::Event&)));
    connect(d, SIGNAL(signalError()), this, SIGNAL(signalError()));
    connect(d, SIGNAL(signalNetwork(int)), this, SIGNAL(signalNetwork(int)));

    d->connect();
}

Module::~Module()
{
    d->disconnect();
    delete d;

    s_module = NULL;
}

void Module::sendRequest(Request request)
{
    d->sendRequest(request);
}

QList<Player*> Module::players() const
{
    return d->m_players;
}

QList<Player*> Module::spectators() const
{
    return d->m_spectators;
}

Module::State Module::state() const
{
    return d->m_state;
}

void ModulePrivate::sendRequest(Request request)
{
    if(!m_net)
    {
        kDebug(11003) << "[kggzmod] error: not connected";
        return;
    }

    kDebug(11003) << "[kggzmod] debug: send a request";
    kDebug(11003) << "[kggzmod] info: send request" << requestString(request.type());

    Request::Type opcode = request.type();
    // FIXME: in networking we always assume sizeof(opcode) = 4!

    if(opcode == Request::state)
    {
        *m_net << opcode;
        *m_net << (qint8)request.data["state"].toInt();
    }
    if(opcode == Request::stand)
    {
        *m_net << opcode;
    }
    if(opcode == Request::sit)
    {
        *m_net << opcode;
        *m_net << request.data["seat"].toInt();
    }
    if(opcode == Request::boot)
    {
        *m_net << opcode;
        *m_net << request.data["player"];
    }
    if(opcode == Request::bot)
    {
        *m_net << opcode;
        *m_net << request.data["seat"].toInt();
    }
    if(opcode == Request::open)
    {
        *m_net << opcode;
        *m_net << request.data["seat"].toInt();
    }
    if(opcode == Request::chat)
    {
        *m_net << opcode;
        *m_net << request.data["message"];
    }
    if(opcode == Request::info)
    {
        *m_net << opcode;
        *m_net << request.data["seat"].toInt();
    }
    if(opcode == Request::rankings)
    {
        *m_net << opcode;
    }
}

QString ModulePrivate::requestString(Request::Type requestcode)
{
    QString str;
    QMap<Request::Type, QString> requestcodes;

    requestcodes[Request::state] = "Request::state";
    requestcodes[Request::stand] = "Request::stand";
    requestcodes[Request::sit] = "Request::sit";
    requestcodes[Request::boot] = "Request::boot";
    requestcodes[Request::bot] = "Request::bot";
    requestcodes[Request::open] = "Request::open";
    requestcodes[Request::chat] = "Request::chat";
    requestcodes[Request::info] = "Request::info";
    requestcodes[Request::rankings] = "Request::rankings";

    if(requestcodes.contains(requestcode))
    {
        str = requestcodes[requestcode];
    }
    else
    {
        str = "??unknown??";
    }

    str += " (" + QString::number(requestcode) + ')';

    return str;
}

QString ModulePrivate::opcodeString(GGZEvents opcode)
{
    QString str;
    QMap<GGZEvents, QString> opcodes;

    opcodes[msglaunch] = "msglaunch";
    opcodes[msgserver] = "msgserver";
    opcodes[msgserverfd] = "msgserverfd";
    opcodes[msgplayer] = "msgplayer";
    opcodes[msgseat] = "msgseat";
    opcodes[msgspectatorseat] = "msgspectatorseat";
    opcodes[msgchat] = "msgchat";
    opcodes[msgstats] = "msgstats";
    opcodes[msginfo] = "msginfo";
    opcodes[msgrankings] = "msgrankings";

    if(opcodes.contains(opcode))
    {
        str = opcodes[opcode];
    }
    else
    {
        str = "??unknown??";
    }

    str += " (" + QString::number(opcode) + ')';

    return str;
}

void ModulePrivate::slotGGZError()
{
    kDebug(11003) << "[kggzmod] error: disconnection from GGZ core client";
    disconnect();
    emit signalError();
}

void ModulePrivate::slotGGZEvent()
{
    int opcodetmp, ret;
    GGZEvents opcode;
    QString _host;
    int _port;
    QString _player, _message;
    int _fd;
    int _isspectator, _seat;
    int _seattype;
    int _hasrecord, _hasrating, _hasranking, _hashighscore;
    int _wins, _losses, _ties, _forfeits, _rating, _ranking, _highscore;
    int _num;
    QString _realname, _photo;
    QList<Player*>::Iterator it;

    kDebug(11003) << "[kggzmod] debug: input from GGZ has arrived";
    *m_net >> opcodetmp;
    opcode = (GGZEvents)opcodetmp;

    kDebug(11003) << "[kggzmod] info: got GGZ input" << opcodeString(opcode);

    if((opcode < msglaunch) || (opcode > msgrankings))
    {
        kDebug(11003) << "[kggzmod] error: unknown opcode";
        disconnect();
        emit signalError();
        return;
    }

    // FIXME: also treat ggzmod 'error' events as signalError()!

    if(opcode == msglaunch)
    {
        Event e(Event::launch);
        emit signalEvent(e);

        // FIXME: ggzmod doesn't provide a "launch" event

        sendRequest(StateRequest(Module::connected));
    }
    if(opcode == msgserver)
    {
        //Event e(Event::server);
        *m_net >> _host;
        *m_net >> _port;
        *m_net >> _player;
        //e.data["host"] = _host;
        //e.data["player"] = _player;
        //e.data["port"] = QString::number(_port);
        //emit signalEvent(e);

        // FIXME: we don't handle this variant

        kDebug(11003) << "[kggzmod] error: we don't handle msgserver";
        disconnect();
        emit signalError();
    }
    if(opcode == msgserverfd)
    {
        sendRequest(StateRequest(Module::waiting));

        Event e(Event::server);
        // FIXME: this is a send_fd operation, might not be portable!
        kDebug(11003) << "[kggzmod] debug: go read fd with ancillary data";
        ret = readfiledescriptor(m_fd, &_fd);
        if(!ret)
        {
            kDebug(11003) << "[kggzmod] error: socket reading failed";
            disconnect();
            emit signalError();
            return;
        }

        kDebug(11003) << "[kggzmod] debug: server fd =" << _fd;
        e.data["fd"] = QString::number(_fd);
        emit signalEvent(e);

        m_gnotifier = new QSocketNotifier(_fd, QSocketNotifier::Read, this);
        QObject::connect(m_gnotifier, SIGNAL(activated(int)), SIGNAL(signalNetwork(int)));
    }
    if(opcode == msgplayer)
    {
        Event e(Event::self);
        *m_net >> _player;
        *m_net >> _isspectator;
        *m_net >> _seat;
        e.data["player"] = _player;

        m_myseat = _seat;
        m_myspectator = (_isspectator != 0);

        insertPlayer((_isspectator ? Player::spectator : Player::player),
            e.data["player"], _seat);
        e.m_player = findPlayer((_isspectator ? Player::spectator : Player::player),
            e.data["player"]);

        emit signalEvent(e);
    }
    if(opcode == msgseat)
    {
        Event e(Event::seat);
        *m_net >> _seat;
        *m_net >> _seattype;
        *m_net >> _player;
        e.data["player"] = _player;

        insertPlayer((Player::Type)_seattype, e.data["player"], _seat);
        e.m_player = findPlayer((Player::Type)_seattype, e.data["player"]);

        if(_seat >= m_playerseats) m_playerseats = _seat + 1;

        emit signalEvent(e);
    }
    if(opcode == msgspectatorseat)
    {
        Event e(Event::seat);
        *m_net >> _seat;
        *m_net >> _player;
        e.data["player"] = _player;

        insertPlayer(Player::spectator, e.data["player"], _seat);
        e.m_player = findPlayer(Player::spectator, e.data["player"]);

        if(_seat >= m_spectatorseats) m_spectatorseats = _seat + 1;

        emit signalEvent(e);
    }
    if(opcode == msgchat)
    {
        Event e(Event::chat);
        *m_net >> _player;
        *m_net >> _message;
        e.data["player"] = _player;
        e.data["message"] = _message;

        e.m_player = findPlayer(Player::player, e.data["player"]);

        emit signalEvent(e);
    }
    if(opcode == msgstats)
    {
        Event e(Event::stats);

        for(int i = 0; i < m_playerseats + m_spectatorseats; i++)
        {
            *m_net >> _hasrecord;
            *m_net >> _hasrating;
            *m_net >> _hasranking;
            *m_net >> _hashighscore;
            *m_net >> _wins;
            *m_net >> _losses;
            *m_net >> _ties;
            *m_net >> _forfeits;
            *m_net >> _rating;
            *m_net >> _ranking;
            *m_net >> _highscore;

            Statistics *stat = new Statistics();
            StatisticsPrivate *statpriv = new StatisticsPrivate();
            statpriv->hasrecord = false;
            statpriv->hasrating = false;
            statpriv->hasranking = false;
            statpriv->hashighscore = false;

            if(_hasrecord)
            {
                statpriv->wins = _wins;
                statpriv->losses = _wins;
                statpriv->ties = _ties;
                statpriv->forfeits = _forfeits;
                statpriv->hasrecord = true;
            }
            if(_hasrating)
            {
                statpriv->rating = _rating;
                statpriv->hasrating = true;
            }
            if(_hasranking)
            {
                statpriv->ranking = _ranking;
                statpriv->hasranking = true;
            }
            if(_hashighscore)
            {
                statpriv->highscore = _highscore;
                statpriv->hashighscore = true;
            }
            stat->init(statpriv);

            Player *p;
            if(i < m_playerseats) p = m_players.at(i);
            else p = m_spectators.at(i);
            p->d->m_stats = stat;
        }

        emit signalEvent(e);
    }
    if(opcode == msginfo)
    {
        Event e(Event::info);

        *m_net >> _num;

        for(int i = 0; i < _num; i++)
        {
            *m_net >> _seat;
            *m_net >> _realname;
            *m_net >> _photo;
            *m_net >> _host;
            //e.data["realname"] = QString(_realname);
            //e.data["photo"] = QString(_photo);
            //e.data["host"] = QString(_host);

            for(it = m_players.begin(); it != m_players.end(); it++)
            {
                if((*it)->seat() == _seat)
                {
                    Player *p = (*it);
                    p->d->m_realname = _realname;
                    p->d->m_hostname = _host;
                    p->d->m_photo = _photo;
                    break;
                }
            }
        }

        emit signalEvent(e);
    }
    if(opcode == msgrankings)
    {
        Event e(Event::rankings);
        kDebug(11003) << "[kggzmod] debug: rankings message";

        *m_net >> _num;
        e.data["num"] = QString::number(_num);

        for(int i = 0; i < _num; i++)
        {
            kDebug(11003) << " ~~rankings: iterate~~ " << i;
            *m_net >> _realname;
            *m_net >> _ranking;
            *m_net >> _highscore;
            e.data["name" + QString::number(i)] = _realname;
            e.data["position" + QString::number(i)] = QString::number(_ranking);
            e.data["score" + QString::number(i)] = QString::number(_highscore);
        }

        emit signalEvent(e);
    }
}

void ModulePrivate::connect()
{
    kDebug(11003) << "[kggzmod] debug: connect() to GGZ";

    if(!Module::isGGZ())
    {
        kDebug(11003) << "[kggzmod] info: GGZMODE not set, ignore";
        // FIXME: alternatively throw error as well?
        return;
    }

    QString ggzsocket = getenv("GGZSOCKET");
    if(ggzsocket.isNull())
    {
        kDebug(11003) << "[kggzmod] error: GGZSOCKET not set";
        emit signalError();
        return;
    }

    m_fd = ggzsocket.toInt();
    kDebug(11003) << "[kggzmod] debug: use socket" << ggzsocket;
    kDebug(11003) << "[kggzmod] debug: numeric socket" << m_fd;

    m_net = new KGGZRaw();
    m_net->setNetwork(m_fd);

    QObject::connect(m_net, SIGNAL(signalError()), SLOT(slotGGZError()));

    m_notifier = new QSocketNotifier(m_fd, QSocketNotifier::Read, this);
    QObject::connect(m_notifier, SIGNAL(activated(int)), SLOT(slotGGZEvent()));

    kDebug(11003) << "[kggzmod] debug: connect() is finished";
}

void ModulePrivate::disconnect()
{
    delete m_gnotifier;
    delete m_notifier;

    m_net->deleteLater();
    m_net->disconnect();

    m_net = 0;
    m_notifier = 0;
    m_gnotifier = 0;
}

Player *ModulePrivate::self() const
{
    if(m_myseat == -1)
    {
        return 0;
    }

    if(m_myspectator)
    {
        return m_spectators.at(m_myseat);
    }
    else
    {
        return m_players.at(m_myseat);
    }

    return 0;
}

Player* ModulePrivate::findPlayer(Player::Type seattype, const QString &name)
{
    QList<Player*>::Iterator it;

    if(seattype == Player::spectator)
    {
        for(it = m_spectators.begin(); it != m_spectators.end(); it++)
        {
            if((*it)->name() == name)
            {
                return (*it);
            }
        }
    }
    else
    {
        for(it = m_players.begin(); it != m_players.end(); it++)
        {
            if((*it)->name() == name)
            {
                return (*it);
            }
        }
    }

    return 0;
}

void ModulePrivate::insertPlayer(Player::Type seattype, const QString &name, int seat)
{
    QList<Player*>::Iterator it;

    if(seat == -1)
    {
        return;
    }

    Player *p = new Player();
    PlayerPrivate *ppriv = new PlayerPrivate();
    ppriv->m_type = seattype;
    ppriv->m_name = name;
    ppriv->m_seat = seat;
    ppriv->m_stats = 0;
    p->init(ppriv);

    if(seattype == Player::spectator)
    {
        if(seat < m_spectators.count())
        {
            m_spectators.replace(seat, p);
        }
        else
        {
            m_spectators.append(p);
        }
    }
    else
    {
        if(seat < m_players.count())
        {
            m_players.replace(seat, p);
        }
        else
        {
            m_players.append(p);
        }
    }
}

bool Module::isGGZ()
{
    if(getenv("GGZMODE")) return true;
    else return false;
}

Player *Module::self() const
{
    return d->self();
}

Module *Module::instance()
{
    return s_module;
}

#include "module.moc"
#include "module_private.moc"

libkdegames/kggzmod

Skip menu "libkdegames/kggzmod"

• Main Page
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Namespace Members
• Class Members

API Reference

Skip menu "API Reference"

• kblackbox
• kgoldrunner
• kmahjongg
• ksquares
• libkdegames
•   highscore
•   kgame
•   kggzgames
•   kggzmod
•   kggznet
• libkmahjongg

Generated for API Reference by doxygen 1.5.4
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal