Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Jun 7, 2009, 1:54:02 PM (15 years ago)
Author:
scheusso
Message:

first version of the i/o-console for the dedicated server

Location:
code/branches/netp4/src/orxonox/gamestates
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • code/branches/netp4/src/orxonox/gamestates/GSDedicated.cc

    r3110 r3119  
    3131#include "core/Clock.h"
    3232#include "core/CommandLine.h"
     33#include "core/CommandExecutor.h"
    3334#include "core/Game.h"
    3435#include "core/GameMode.h"
     
    3839#include "util/Sleep.h"
    3940
     41#include <iostream>
     42#include <iomanip>
     43#include <boost/bind.hpp>
     44
     45
    4046namespace orxonox
    4147{
     48    const unsigned int MAX_COMMAND_LENGTH = 255;
     49   
    4250    AddGameState(GSDedicated, "dedicated");
    4351
     
    4654        , server_(0)
    4755        , timeSinceLastUpdate_(0)
     56        , closeThread_(false)
     57        , inputIterator_(0)
     58        , cleanLine_(true)
    4859    {
     60        this->inputThread_ = new boost::thread(boost::bind(&GSDedicated::inputThread, this));
     61        this->commandLine_ = new unsigned char[MAX_COMMAND_LENGTH];
     62//         memset( this->commandLine_, 0, MAX_COMMAND_LENGTH );
    4963    }
    5064
    5165    GSDedicated::~GSDedicated()
    5266    {
     67        closeThread_ = true;
     68#ifndef ORXONOX_PLATFORM_WINDOWS
     69        std::cout << "\033[0G\033[K";
     70        std::cout.flush();
     71#endif
     72        //inputThread_->join();
    5373    }
    5474
     
    7393    void GSDedicated::update(const Clock& time)
    7494    {
    75 //        static float startTime = time.getSecondsPrecise();
    76 //        static int nrOfTicks = 0;
    7795        timeSinceLastUpdate_ += time.getDeltaTime();
    7896        if (timeSinceLastUpdate_ >= NETWORK_PERIOD)
    7997        {
    80 //            ++nrOfTicks;
    81 //            COUT(0) << "estimated ticks/sec: " << nrOfTicks/(time.getSecondsPrecise()-startTime) << endl;
    8298            timeSinceLastUpdate_ -= static_cast<unsigned int>(timeSinceLastUpdate_ / NETWORK_PERIOD) * NETWORK_PERIOD;
    8399            server_->update(time);
     
    85101        else
    86102        {
    87             usleep((int)((NETWORK_PERIOD - timeSinceLastUpdate_) * 1000 * 1000));
     103            usleep((unsigned int)((NETWORK_PERIOD - timeSinceLastUpdate_)*1000*1000 ));
     104            usleep(NETWORK_PERIOD*1000*1000); // NOTE: this is to throttle the non-network framerate
    88105//            COUT(0) << "sleeping for " << (int)((NETWORK_PERIOD - timeSinceLastUpdate_) * 1000 * 1000) << " usec" << endl;
     106        }
     107        processQueue();
     108        printLine();
     109    }
     110   
     111    void GSDedicated::inputThread()
     112    {
     113        unsigned char c;
     114        while(!closeThread_)
     115        {
     116            c = getchar();
     117            {
     118//                 boost::recursive_mutex::scoped_lock(this->inputLineMutex_);
     119                if ( inputIterator_>=MAX_COMMAND_LENGTH-1 && c!='\n' )
     120                    continue;
     121                this->commandLine_[this->inputIterator_++] = c;
     122                if( c == '\n' )
     123                {
     124                    this->cleanLine_ = true;
     125                    boost::recursive_mutex::scoped_lock(this->inputQueueMutex_);
     126                    this->commandQueue_.push( std::string((const char*)this->commandLine_,inputIterator_) );
     127                    inputIterator_ = 0;
     128                }
     129            }
     130        }
     131    }
     132   
     133    void GSDedicated::printLine()
     134    {
     135#ifndef ORXONOX_PLATFORM_WINDOWS
     136        std::cout << "\033[s\033[0G";
     137//         boost::recursive_mutex::scoped_lock(this->inputLineMutex_);
     138        std::cout << std::fixed << std::setprecision(2) << std::setw(5) << Game::getInstance().getAvgFPS() << " fps, " << std::setprecision(2) << std::setw(5) << Game::getInstance().getAvgTickTime() << " ms avg ticktime # ";
     139        if ( this->cleanLine_ )
     140            this->cleanLine_ = false;
     141        else
     142            std::cout <<"\033[u";
     143        std::cout.flush();
     144#endif
     145    }
     146   
     147    void GSDedicated::processQueue()
     148    {
     149        std::string tempstr;
     150        {
     151            boost::recursive_mutex::scoped_lock lock1(this->inputQueueMutex_);
     152            while(true)
     153            {
     154                if ( !this->commandQueue_.empty() )
     155                {
     156                    tempstr = this->commandQueue_.front();
     157                    this->commandQueue_.pop();
     158                    lock1.unlock();
     159                }
     160                else
     161                    break;
     162                CommandExecutor::execute(tempstr, true);
     163            }
    89164        }
    90165    }
  • code/branches/netp4/src/orxonox/gamestates/GSDedicated.h

    r2896 r3119  
    3333#include "core/GameState.h"
    3434#include "network/NetworkPrereqs.h"
     35#include <queue>
     36#include <cstring>
     37#include <boost/thread/thread.hpp>
     38#include <boost/thread/mutex.hpp>
     39#include <boost/thread/recursive_mutex.hpp>
    3540
    3641namespace orxonox
     
    4752
    4853    private:
    49         Server* server_;
    50         float   timeSinceLastUpdate_;
     54        void inputThread();
     55        void printLine();
     56        void processQueue();
     57       
     58        Server*                 server_;
     59        float                   timeSinceLastUpdate_;
     60       
     61        boost::thread           *inputThread_;
     62//         boost::recursive_mutex  inputLineMutex_;
     63        boost::recursive_mutex  inputQueueMutex_;
     64        bool                    closeThread_;
     65        bool                    cleanLine_;
     66        unsigned char*          commandLine_;
     67        unsigned int            inputIterator_;
     68        std::queue<std::string> commandQueue_;
     69       
    5170    };
    5271}
Note: See TracChangeset for help on using the changeset viewer.