main.cpp

Go to the documentation of this file.

/*
* WorldServer Entry
*
* @Author Michael <Tharbas> Matzen
*
* 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 2 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, write to the Free Software Foundation, Inc., 51
* Franklin St, Fifth Floor, Boston, MA 02110, USA
* 
*/

//#include <iostream>
//#include <sstream>
//#include <memory>
//#include <string>
//#include <stdexcept>
//
// SQL includes:
//#include <mysql_driver.h>
//#include <cppconn/driver.h>
//#include <cppconn/exception.h>
//#include <cppconn/resultset.h>
//#include <cppconn/statement.h>
//#include "mysql.h"
//using namespace std;
//#include "DbConnectionFactory.h"
//#include "DbProcedures.h";
//#include "boost\bind.hpp";
//#include "SraPacket.h"
//#include "SraNetworkShared.h"
//#include "NetworkHelper.h"

// Debugging / Testing
//#include "GetServerListPacket.h"
//#include "ConnectToServerPacket.h"
//#include "GetClientCharactersPacket.h"
#include "WindowsIncludes.h"
#include "WorldServer.h"
#include "MessagePump.h"

int main() 
{
    /* Get client characters: 
    SraNetwork::GetClientCharactersPacket packet;
    packet.charId = 1234;
    packet.charLevel = 5;
    packet.charName = "Tharbas";
    packet.charRace = "Human";

    char* buffer = new char[SraNetwork::ConnectToServerPacket::PACKAGE_SIZE];   
    ZeroMemory( buffer, sizeof(buffer));

    packet.Serialize(buffer);

    SraNetwork::GetClientCharactersPacket clientPacket;
    clientPacket.Deserialize(buffer);
    */

    /* Connect to server flow:
    SraNetwork::ConnectToServerPacket pack;
    char* buffer = new char[SraNetwork::ConnectToServerPacket::PACKAGE_SIZE];
    pack.zoneID = 15;
    ZeroMemory( &pack.info, sizeof(SraNetwork::SraServerInfo));
    pack.Serialize(buffer);

    SraNetwork::ConnectToServerPacket rec;
    rec.Deserialize(buffer);

    rec.info.currentNumberOfPlayers = 15;
    rec.info.ip = "127.0.0.1:4821";
    rec.info.name = "Debug Server Instance";
    char* buffer2 = new char[SraNetwork::ConnectToServerPacket::PACKAGE_SIZE];
    rec.Serialize(buffer2);

    pack.Deserialize(buffer2);

    delete buffer;
    delete buffer2;
    */

    //pack.Deserialize(buffer);
    //wchar_t* user = L"Test";
    //wchar_t* pw = L"Password";

    //char* dat = new char[SraNetwork::PACKAGE_DATA_SIZE];

    //memset(dat, 0, SraNetwork::PACKAGE_DATA_SIZE);


    //dat[0] = SraNetwork::ID_LOGIN_REQ;
    //dat[1] = wcslen(user);
    //dat[2] = wcslen(pw);

    //size_t sizeofUser = wcslen(user) * sizeof(wchar_t*);
    //size_t sizeofPw = wcslen(pw) * sizeof(wchar_t*);
    //
    //memcpy_s( dat + 3 + sizeofUser, sizeofPw, pw, sizeofPw);*/

    //SraNetwork::Helpers::StoreWStringInBuffer( user, dat+3);
    //SraNetwork::Helpers::StoreWStringInBuffer( pw, dat+3+wcslen(user));


    //SraNetwork::SraPacket::GetPacketFromData(dat);
    
    //delete dat;
    /*SraNetwork::WorldServer server;
    if (!server.Initialize()) 
    {
        printf("World failed to initialize correctly ... terminating\n");
        return -1;
    }
    */
    tbb::tbb_thread clientThread( &SraNetwork::WorldServer::ClientConnectionThread );
    tbb::tbb_thread zoneThread( &SraNetwork::WorldServer::ZoneServerConnectionThread );
    tbb::tbb_thread chatThread( &SraNetwork::WorldServer::ChatServerConnectionThread );
    tbb::tbb_thread messageThread( &SraNetwork::MessagePump::Run );
    zoneThread.join();
    clientThread.join();
    chatThread.join();
    messageThread.join();

    //boost::thread workerThread ( boost::bind(&SraNetwork::WorldServer::Work,server) );
    //boost::thread clientConnectionThread ( boost::bind(&SraNetwork::WorldServer::ClientConnectionThread,server) );

    //workerThread.join();
    //clientConnectionThread.join();
    //return 0;
}

#pragma region DB-Test Code

    //SraData::DbConnectionFactory factory("tcp://127.0.0.1:3306", "root", "SRA_Dev", "sra_dev");
    //int pID;
    //const std::string& name = "abc";
    //const std::string& pw = "def";
    //int zid;
    //int pd;
    //try
    //{
    //SraData::DbProcedures::createPlayer(name, pw, &pID);
    //SraData::DbProcedures::getPcZone(1, &zid, &pd);

    //}
    //catch (sql::SQLException e)
    //{
    //  cout << "Error message: " << e.what() << endl;
    //  system("pause");
    //  exit(1);
    //}
    //
    //cout << "PC zone : " << zid << " query : " << pd << endl;
    //system("Pause");
    //exit(1);
    /*const std::string dbname = "tcp://127.0.0.1";
        const std::string user = "root";
        const std::string pw = "SRA_Dev";
    
    MYSQL sql;
    mysql_init(&sql);
    if (!mysql_real_connect(&sql, "127.0.0.1", "root", "SRA_Dev", "sra_dev", 3306, NULL, 0))
    {
        cout << "Connection failed";
    }
    else 
    {
        cout << "Connected !!";
    }*/
    /*sql::mysql::MySQL_Driver* driver;
    driver = (sql::mysql::MySQL_Driver*)malloc( sizeof(sql::mysql::MySQL_Driver));
    sql::Connection *con;
    con = (sql::Connection*)malloc(sizeof(sql::Connection));
    driver = sql::mysql::get_mysql_driver_instance();
        
    con = driver->connect(dbname, user, pw);*/
        //auto_ptr<sql::Connection>  con (driver -> connect(dbname, user, pw));
//delete con;
    
//  try
//  {
//      //_driver = sql::mysql::MySQL_Driver::Instance();
//  }
//  catch (sql::SQLException e)
//  {
//      cout << "Could not get a database driver. Error message: " << e.what() << endl;
//      system("pause");
//      exit(1);
//  }
//
//  //SraData::DbProcedures::createPlayer("lala", "lili", &pID);
//  try
//  {
//      const std::string dbname = "localhost";
//      const std::string user = "root";
//      const std::string pw = "SRA_Dev";
//      
//      //sql::Connection *con = _driver->connect("localhost", "root", "SRA_Dev");
//      //con->setSchema("sra_dev");
//  }
//  catch (sql::SQLException e)
//  {
//      cout << "Could not get a database driver. Error message: " << e.what() << endl;
//      system("pause");
//      exit(1);
//  }
#pragma endregion