Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 6016


Ignore:
Timestamp:
Nov 2, 2009, 6:06:25 PM (15 years ago)
Author:
rgrieder
Message:

Removed console from GSDedicated and GSDedicatedClient.

Location:
code/branches/console/src/orxonox/gamestates
Files:
4 edited

Legend:

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

    r5929 r6016  
    2929#include "GSDedicated.h"
    3030
    31 #include <iomanip>
    32 #include <iostream>
    33 #include <boost/bind.hpp>
    34 
    35 #include "util/Clock.h"
    3631#include "util/Debug.h"
    37 #include "util/Sleep.h"
    3832#include "core/CommandLine.h"
    39 #include "core/CommandExecutor.h"
    4033#include "core/Game.h"
    4134#include "core/GameMode.h"
    4235#include "network/Server.h"
    4336
    44 #ifdef ORXONOX_PLATFORM_UNIX
    45 #include <termios.h>
    46 #endif
    47 
    48 
    4937namespace orxonox
    5038{
    51     const unsigned int MAX_COMMAND_LENGTH = 255;
    52    
    5339    DeclareGameState(GSDedicated, "dedicated", false, false);
    5440   
    55     termios* GSDedicated::originalTerminalSettings_;
    56 
    5741    GSDedicated::GSDedicated(const GameStateInfo& info)
    5842        : GameState(info)
    5943        , server_(0)
    60         , closeThread_(false)
    61         , cleanLine_(true)
    62         , inputIterator_(0)
    63         , cursorX_(0)
    64         , cursorY_(0)
    6544    {
    6645    }
     
    7352    {
    7453        GameMode::setHasServer(true);
    75        
    76         this->inputThread_ = new boost::thread(boost::bind(&GSDedicated::inputThread, this));
    77        
    78 #ifndef ORXONOX_PLATFORM_WINDOWS
    79         this->originalTerminalSettings_ = new termios;
    80         this->setTerminalMode();
    81 #endif
    8254
    8355        this->server_ = new Server(CommandLine::getValue("port"));
     
    9163        this->server_->close();
    9264        delete this->server_;
    93        
    94         closeThread_ = true;
    95 #ifdef ORXONOX_PLATFORM_UNIX
    96         std::cout << "\033[0G\033[K";
    97         std::cout.flush();
    98         resetTerminalMode();
    99         delete this->originalTerminalSettings_;
    100 #else
    101         COUT(0) << "Press enter to end the game..." << std::endl;
    102 #endif
    103         inputThread_->join();
    104         delete this->inputThread_;
    10565
    10666        GameMode::setHasServer(false);
     
    11070    {
    11171        server_->update(time);
    112         processQueue();
    113         printLine();
    11472    }
    115    
    116     void GSDedicated::inputThread()
    117     {
    118         this->commandLine_ = new unsigned char[MAX_COMMAND_LENGTH];
    119 //         memset( this->commandLine_, 0, MAX_COMMAND_LENGTH );
    120         unsigned char c;
    121         unsigned int  escapeChar=0;
    122         while(!closeThread_)
    123         {
    124 #ifdef ORXONOX_PLATFORM_UNIX
    125             size_t count = read(STDIN_FILENO, &c, 1);
    126             if (count == 1)
    127 #else
    128             c = getchar();
    129 #endif
    130             {
    131 //                 boost::recursive_mutex::scoped_lock(this->inputLineMutex_);
    132                 if ( inputIterator_>=MAX_COMMAND_LENGTH-1 && c!='\n' )
    133                     continue;
    134                 if( escapeChar > 0 )
    135                 {
    136                     if( c == '[' )
    137                     {
    138                         escapeChar = 2;
    139                         continue;
    140                     }
    141                     else if ( escapeChar == 2 )
    142                     {
    143                         switch (c)
    144                         {
    145                             case 'A': //keyup
    146                                
    147                                 break;
    148                             case 'B': //keydown
    149                                
    150                                 break;
    151                             case 'C': //keyright
    152                                 if(cursorX_<inputIterator_)
    153                                     ++cursorX_;
    154                                 break;
    155                             case 'D': //keyleft
    156                                 if(cursorX_>0)
    157                                     --cursorX_;
    158                                 break;
    159                             default: //not supported...
    160 //                                 std::cout << endl << c << endl;
    161                                 break;
    162                         }
    163                         escapeChar = 0;
    164                     }
    165                 }
    166                 else // not in escape sequence mode
    167                 {
    168                     switch (c)
    169                     {
    170                         case '\n':
    171                             this->cleanLine_ = true;
    172                             {
    173                                 boost::recursive_mutex::scoped_lock(this->inputQueueMutex_);
    174                                 boost::recursive_mutex::scoped_lock(this->inputLineMutex_);
    175                                 this->commandQueue_.push( std::string((const char*)this->commandLine_,inputIterator_) );
    176                             }
    177                             memset( this->commandLine_, 0, inputIterator_ );
    178                             inputIterator_ = 0;
    179                             this->cursorX_ = 0;
    180                             this->cursorY_ = 0;
    181                             std::cout << endl;
    182                             break;
    183                         case 127: // backspace
    184                         case '\b':
    185                             deleteCharacter( this->cursorX_ );
    186                             break;
    187                         case '\t':
    188                         {
    189 //                             boost::recursive_mutex::scoped_lock(this->inputLineMutex_);
    190                             std::cout << endl << CommandExecutor::hint( std::string((const char*)this->commandLine_,inputIterator_) ) << endl;
    191                             strncpy(reinterpret_cast<char*>(this->commandLine_), CommandExecutor::complete( std::string(reinterpret_cast<char*>(this->commandLine_),inputIterator_) ).c_str(), MAX_COMMAND_LENGTH);
    192                             this->inputIterator_ = strlen((const char*)this->commandLine_);
    193                             this->cursorX_ = this->inputIterator_;
    194                             break;
    195                         }
    196                         case '\033': // 1. escape character
    197                             escapeChar = 1;
    198                             break;
    199                         default:
    200                             insertCharacter( this->cursorX_, c );
    201                             break;
    202                     }
    203                 }
    204             }
    205         }
    206 
    207         delete[] this->commandLine_;
    208     }
    209    
    210     void GSDedicated::printLine()
    211     {
    212 #ifdef ORXONOX_PLATFORM_UNIX
    213         // set cursor to the begining of the line and erase the line
    214         std::cout << "\033[0G\033[K";
    215 //         boost::recursive_mutex::scoped_lock(this->inputLineMutex_);
    216         // print status line
    217         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 # ";
    218         //save cursor position
    219         std::cout << "\033[s";
    220         //print commandLine buffer
    221         std::cout << std::string((const char*)this->commandLine_, inputIterator_);
    222         //restore cursor position and move it cursorX_ to the right
    223         std::cout << "\033[u";
    224         if( this->cursorX_ > 0 )
    225             std::cout << "\033[" << this->cursorX_ << "C";
    226         std::cout.flush();
    227 #endif
    228     }
    229    
    230     void GSDedicated::processQueue()
    231     {
    232         std::string tempstr;
    233         {
    234             boost::recursive_mutex::scoped_lock lock1(this->inputQueueMutex_);
    235             while(true)
    236             {
    237                 if ( !this->commandQueue_.empty() )
    238                 {
    239                     tempstr = this->commandQueue_.front();
    240                     this->commandQueue_.pop();
    241                     lock1.unlock();
    242                 }
    243                 else
    244                     break;
    245                 CommandExecutor::execute(tempstr, true);
    246             }
    247         }
    248     }
    249    
    250     void GSDedicated::setTerminalMode()
    251     {
    252 #ifdef ORXONOX_PLATFORM_UNIX
    253         termios new_settings;
    254      
    255         tcgetattr(0,this->originalTerminalSettings_);
    256         new_settings = *this->originalTerminalSettings_;
    257         new_settings.c_lflag &= ~( ICANON | ECHO );
    258 //         new_settings.c_lflag |= ( ISIG | IEXTEN );
    259         new_settings.c_cc[VTIME] = 1;
    260         new_settings.c_cc[VMIN] = 0;
    261         tcsetattr(0,TCSANOW,&new_settings);
    262         COUT(0) << endl;
    263 //       atexit(&GSDedicated::resetTerminalMode);
    264 #endif
    265     }
    266    
    267     void GSDedicated::resetTerminalMode()
    268     {
    269 #ifdef ORXONOX_PLATFORM_UNIX
    270         tcsetattr(0, TCSANOW, GSDedicated::originalTerminalSettings_);
    271 #endif
    272     }
    273    
    274     void GSDedicated::insertCharacter( unsigned int position, char c )
    275     {
    276 //         std::cout << endl << static_cast<unsigned int>(c) << endl;
    277         // check that we do not exceed MAX_COMMAND_LENGTH
    278         if( inputIterator_+1 < MAX_COMMAND_LENGTH )
    279         {
    280             // if cursor not at end of line then move the rest of the line
    281             if( position != this->inputIterator_ )
    282                     memmove( this->commandLine_+position+1, this->commandLine_+position, this->inputIterator_-position);
    283 //             boost::recursive_mutex::scoped_lock(this->inputLineMutex_);
    284             this->commandLine_[position] = c;
    285             ++this->cursorX_;
    286             ++this->inputIterator_;
    287         }
    288     }
    289     void GSDedicated::deleteCharacter( unsigned int position )
    290     {
    291 //         boost::recursive_mutex::scoped_lock(this->inputLineMutex_);
    292         if ( this->inputIterator_>0 && position>0 )
    293         {
    294             if ( position != this->inputIterator_ )
    295                 memmove( this->commandLine_+position-1, this->commandLine_+position, this->inputIterator_-position);
    296             --this->cursorX_;
    297             --this->inputIterator_;
    298         }
    299     }
    300    
    30173}
  • code/branches/console/src/orxonox/gamestates/GSDedicated.h

    r5929 r6016  
    3232#include "OrxonoxPrereqs.h"
    3333
    34 #include <cstring>
    35 #include <queue>
    36 #include <boost/thread/thread.hpp>
    37 #include <boost/thread/mutex.hpp>
    38 #include <boost/thread/recursive_mutex.hpp>
    39 
    4034#include "core/GameState.h"
    4135#include "network/NetworkPrereqs.h"
    4236
    43 struct termios;
    44 
    4537namespace orxonox
    4638{
    47 
    4839    class _OrxonoxExport GSDedicated : public GameState
    4940    {
     
    5748
    5849    private:
    59         void inputThread();
    60         void printLine();
    61         void processQueue();
    62         void setTerminalMode();
    63         static void resetTerminalMode();
    64 
    65         void insertCharacter( unsigned int position, char c );
    66         void deleteCharacter( unsigned int position );
    67 
    6850        Server*                 server_;
    69 
    70         boost::thread           *inputThread_;
    71         boost::recursive_mutex  inputLineMutex_;
    72         boost::recursive_mutex  inputQueueMutex_;
    73         bool                    closeThread_;
    74         bool                    cleanLine_;
    75         unsigned char*          commandLine_;
    76         unsigned int            inputIterator_;
    77         std::queue<std::string> commandQueue_;
    78         static termios*         originalTerminalSettings_;
    79 
    80         unsigned int            cursorX_;
    81         unsigned int            cursorY_;
    8251    };
    8352}
  • code/branches/console/src/orxonox/gamestates/GSDedicatedClient.cc

    r5929 r6016  
    2929#include "GSDedicatedClient.h"
    3030
    31 #include <iomanip>
    32 #include <iostream>
    33 #include <boost/bind.hpp>
    34 
    35 #include "util/Clock.h"
    3631#include "util/Debug.h"
    3732#include "util/Exception.h"
    38 #include "util/Sleep.h"
    3933#include "core/CommandLine.h"
    40 #include "core/CommandExecutor.h"
    4134#include "core/Game.h"
    4235#include "core/GameMode.h"
    4336#include "network/Client.h"
    4437
    45 #ifdef ORXONOX_PLATFORM_UNIX
    46 #include <termios.h>
    47 #endif
    48 
    49 
    5038namespace orxonox
    5139{
    52     const unsigned int MAX_COMMAND_LENGTH = 255;
    53    
    5440    DeclareGameState(GSDedicatedClient, "dedicatedClient", false, false);
    5541   
    56     termios* GSDedicatedClient::originalTerminalSettings_;
    57 
    5842    GSDedicatedClient::GSDedicatedClient(const GameStateInfo& info)
    5943        : GameState(info)
    6044        , client_(0)
    61         , closeThread_(false)
    62         , cleanLine_(true)
    63         , inputIterator_(0)
    64         , cursorX_(0)
    65         , cursorY_(0)
    6645    {
    6746    }
     
    7352    void GSDedicatedClient::activate()
    7453    {
    75         this->inputThread_ = new boost::thread(boost::bind(&GSDedicatedClient::inputThread, this));
    76        
    77 #ifndef ORXONOX_PLATFORM_WINDOWS
    78         this->originalTerminalSettings_ = new termios;
    79         this->setTerminalMode();
    80 #endif
     54        GameMode::setIsClient(true);
    8155
    8256        this->client_ = new Client(CommandLine::getValue("ip").getString(), CommandLine::getValue("port"));
     
    8761           
    8862        client_->update(Game::getInstance().getGameClock());
    89 
    90 
    9163    }
    9264
    9365    void GSDedicatedClient::deactivate()
    9466    {
    95         if( this->client_ )
     67        if (this->client_)
    9668        {
    9769            this->client_->closeConnection();
    9870            delete this->client_;
    9971        }
    100        
    101         closeThread_ = true;
    102 #ifdef ORXONOX_PLATFORM_UNIX
    103         std::cout << "\033[0G\033[K";
    104         std::cout.flush();
    105         resetTerminalMode();
    106         delete this->originalTerminalSettings_;
    107 #else
    108         COUT(0) << "Press enter to end the game..." << std::endl;
    109 #endif
    110         inputThread_->join();
    111         delete this->inputThread_;
     72
     73        GameMode::setIsClient(false);
    11274    }
    11375
     
    11577    {
    11678        client_->update(time);
    117         processQueue();
    118         printLine();
    11979    }
    120    
    121     void GSDedicatedClient::inputThread()
    122     {
    123         this->commandLine_ = new unsigned char[MAX_COMMAND_LENGTH];
    124 //         memset( this->commandLine_, 0, MAX_COMMAND_LENGTH );
    125         unsigned char c;
    126         unsigned int  escapeChar=0;
    127         while(!closeThread_)
    128         {
    129 #ifdef ORXONOX_PLATFORM_UNIX
    130             size_t count = read(STDIN_FILENO, &c, 1);
    131             if (count == 1)
    132 #else
    133             c = getchar();
    134 #endif
    135             {
    136 //                 boost::recursive_mutex::scoped_lock(this->inputLineMutex_);
    137                 if ( inputIterator_>=MAX_COMMAND_LENGTH-1 && c!='\n' )
    138                     continue;
    139                 if( escapeChar > 0 )
    140                 {
    141                     if( c == '[' )
    142                     {
    143                         escapeChar = 2;
    144                         continue;
    145                     }
    146                     else if ( escapeChar == 2 )
    147                     {
    148                         switch (c)
    149                         {
    150                             case 'A': //keyup
    151                                
    152                                 break;
    153                             case 'B': //keydown
    154                                
    155                                 break;
    156                             case 'C': //keyright
    157                                 if(cursorX_<inputIterator_)
    158                                     ++cursorX_;
    159                                 break;
    160                             case 'D': //keyleft
    161                                 if(cursorX_>0)
    162                                     --cursorX_;
    163                                 break;
    164                             default: //not supported...
    165 //                                 std::cout << endl << c << endl;
    166                                 break;
    167                         }
    168                         escapeChar = 0;
    169                     }
    170                 }
    171                 else // not in escape sequence mode
    172                 {
    173                     switch (c)
    174                     {
    175                         case '\n':
    176                             this->cleanLine_ = true;
    177                             {
    178                                 boost::recursive_mutex::scoped_lock(this->inputQueueMutex_);
    179                                 boost::recursive_mutex::scoped_lock(this->inputLineMutex_);
    180                                 this->commandQueue_.push( std::string((const char*)this->commandLine_,inputIterator_) );
    181                             }
    182                             memset( this->commandLine_, 0, inputIterator_ );
    183                             inputIterator_ = 0;
    184                             this->cursorX_ = 0;
    185                             this->cursorY_ = 0;
    186                             std::cout << endl;
    187                             break;
    188                         case 127: // backspace
    189                         case '\b':
    190                             deleteCharacter( this->cursorX_ );
    191                             break;
    192                         case '\t':
    193                         {
    194 //                             boost::recursive_mutex::scoped_lock(this->inputLineMutex_);
    195                             std::cout << endl << CommandExecutor::hint( std::string((const char*)this->commandLine_,inputIterator_) ) << endl;
    196                             strncpy(reinterpret_cast<char*>(this->commandLine_), CommandExecutor::complete( std::string(reinterpret_cast<char*>(this->commandLine_),inputIterator_) ).c_str(), MAX_COMMAND_LENGTH);
    197                             this->inputIterator_ = strlen((const char*)this->commandLine_);
    198                             this->cursorX_ = this->inputIterator_;
    199                             break;
    200                         }
    201                         case '\033': // 1. escape character
    202                             escapeChar = 1;
    203                             break;
    204                         default:
    205                             insertCharacter( this->cursorX_, c );
    206                             break;
    207                     }
    208                 }
    209             }
    210         }
    211 
    212         delete[] this->commandLine_;
    213     }
    214    
    215     void GSDedicatedClient::printLine()
    216     {
    217 #ifdef ORXONOX_PLATFORM_UNIX
    218         // set cursor to the begining of the line and erase the line
    219         std::cout << "\033[0G\033[K";
    220 //         boost::recursive_mutex::scoped_lock(this->inputLineMutex_);
    221         // print status line
    222         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 # ";
    223         //save cursor position
    224         std::cout << "\033[s";
    225         //print commandLine buffer
    226         std::cout << std::string((const char*)this->commandLine_, inputIterator_);
    227         //restore cursor position and move it cursorX_ to the right
    228         std::cout << "\033[u";
    229         if( this->cursorX_ > 0 )
    230             std::cout << "\033[" << this->cursorX_ << "C";
    231         std::cout.flush();
    232 #endif
    233     }
    234    
    235     void GSDedicatedClient::processQueue()
    236     {
    237         std::string tempstr;
    238         {
    239             boost::recursive_mutex::scoped_lock lock1(this->inputQueueMutex_);
    240             while(true)
    241             {
    242                 if ( !this->commandQueue_.empty() )
    243                 {
    244                     tempstr = this->commandQueue_.front();
    245                     this->commandQueue_.pop();
    246                     lock1.unlock();
    247                 }
    248                 else
    249                     break;
    250                 CommandExecutor::execute(tempstr, true);
    251             }
    252         }
    253     }
    254    
    255     void GSDedicatedClient::setTerminalMode()
    256     {
    257 #ifdef ORXONOX_PLATFORM_UNIX
    258         termios new_settings;
    259      
    260         tcgetattr(0,this->originalTerminalSettings_);
    261         new_settings = *this->originalTerminalSettings_;
    262         new_settings.c_lflag &= ~( ICANON | ECHO );
    263 //         new_settings.c_lflag |= ( ISIG | IEXTEN );
    264         new_settings.c_cc[VTIME] = 1;
    265         new_settings.c_cc[VMIN] = 0;
    266         tcsetattr(0,TCSANOW,&new_settings);
    267         COUT(0) << endl;
    268 //       atexit(&GSDedicatedClient::resetTerminalMode);
    269 #endif
    270     }
    271    
    272     void GSDedicatedClient::resetTerminalMode()
    273     {
    274 #ifdef ORXONOX_PLATFORM_UNIX
    275         tcsetattr(0, TCSANOW, GSDedicatedClient::originalTerminalSettings_);
    276 #endif
    277     }
    278    
    279     void GSDedicatedClient::insertCharacter( unsigned int position, char c )
    280     {
    281 //         std::cout << endl << static_cast<unsigned int>(c) << endl;
    282         // check that we do not exceed MAX_COMMAND_LENGTH
    283         if( inputIterator_+1 < MAX_COMMAND_LENGTH )
    284         {
    285             // if cursor not at end of line then move the rest of the line
    286             if( position != this->inputIterator_ )
    287                     memmove( this->commandLine_+position+1, this->commandLine_+position, this->inputIterator_-position);
    288 //             boost::recursive_mutex::scoped_lock(this->inputLineMutex_);
    289             this->commandLine_[position] = c;
    290             ++this->cursorX_;
    291             ++this->inputIterator_;
    292         }
    293     }
    294     void GSDedicatedClient::deleteCharacter( unsigned int position )
    295     {
    296 //         boost::recursive_mutex::scoped_lock(this->inputLineMutex_);
    297         if ( this->inputIterator_>0 && position>0 )
    298         {
    299             if ( position != this->inputIterator_ )
    300                 memmove( this->commandLine_+position-1, this->commandLine_+position, this->inputIterator_-position);
    301             --this->cursorX_;
    302             --this->inputIterator_;
    303         }
    304     }
    305    
    30680}
  • code/branches/console/src/orxonox/gamestates/GSDedicatedClient.h

    r5929 r6016  
    3434#include "core/GameState.h"
    3535#include "network/NetworkPrereqs.h"
    36 #include <queue>
    37 #include <cstring>
    38 #include <boost/thread/thread.hpp>
    39 #include <boost/thread/mutex.hpp>
    40 #include <boost/thread/recursive_mutex.hpp>
    41 
    42 struct termios;
    4336
    4437namespace orxonox
     
    5649
    5750    private:
    58         void inputThread();
    59         void printLine();
    60         void processQueue();
    61         void setTerminalMode();
    62         static void resetTerminalMode();
    63 
    64         void insertCharacter( unsigned int position, char c );
    65         void deleteCharacter( unsigned int position );
    66 
    6751        Client*                 client_;
    68 
    69         boost::thread           *inputThread_;
    70         boost::recursive_mutex  inputLineMutex_;
    71         boost::recursive_mutex  inputQueueMutex_;
    72         bool                    closeThread_;
    73         bool                    cleanLine_;
    74         unsigned char*          commandLine_;
    75         unsigned int            inputIterator_;
    76         std::queue<std::string> commandQueue_;
    77         static termios*         originalTerminalSettings_;
    78 
    79         unsigned int            cursorX_;
    80         unsigned int            cursorY_;
    8152    };
    8253}
Note: See TracChangeset for help on using the changeset viewer.