console.cpp

this keik game source

      { &EV_ConsoleManager_ConPrint,			   ( Response )ConsoleManager::ConsolePrint },
      { &EV_ConsoleManager_ConPrint,			   ( Response )ConsoleManager::ConsolePrint },
      { &EV_ConsoleManager_ConNewline,			   ( Response )ConsoleManager::ConsoleNewline },
      { &EV_ConsoleManager_ConLayout,			   ( Response )ConsoleManager::ConsoleLayout },
      { &EV_ConsoleManager_ConLayoutFile, 	   ( Response )ConsoleManager::ConsoleLayoutFile },
      { &EV_ConsoleManager_ConAppLayout,			( Response )ConsoleManager::ConsoleAppLayout },
      { &EV_ConsoleManager_ConClearLayout,		( Response )ConsoleManager::ConsoleClearLayout },
      { &EV_ConsoleManager_ConVirtualWidth,	   ( Response )ConsoleManager::ConsoleVirtualWidth },
      { &EV_ConsoleManager_ConVirtualHeight,	   ( Response )ConsoleManager::ConsoleVirtualHeight },
      { &EV_ConsoleManager_ConFraction,   	   ( Response )ConsoleManager::ConsoleFraction },
      { &EV_ConsoleManager_ConDeactivate, 	   ( Response )ConsoleManager::ConsoleDeactivate },
      { &EV_ConsoleManager_ConActivate, 	      ( Response )ConsoleManager::ConsoleActivate },
      { &EV_ConsoleManager_ConRows,       	   ( Response )ConsoleManager::ConsoleRows },
      { &EV_ConsoleManager_ConColumns, 	      ( Response )ConsoleManager::ConsoleColumns },
      { &EV_ConsoleManager_ConClear,    	      ( Response )ConsoleManager::ConsoleClear },
      { &EV_ConsoleManager_ConLoadMenuFile,     ( Response )ConsoleManager::ConsoleLoadMenuFile },
      { &EV_ConsoleManager_ConFocus,            ( Response )ConsoleManager::ConsoleFocus },
      { &EV_ConsoleManager_ConForeground,       ( Response )ConsoleManager::ConsoleForeground },
      { &EV_ConsoleManager_MenuActive,          ( Response )ConsoleManager::ConsoleMenuActive },
      { &EV_ConsoleManager_MenuInactive,        ( Response )ConsoleManager::ConsoleMenuInactive },
      { &EV_ConsoleManager_ConStatusBar,        ( Response )ConsoleManager::ConsoleStatusBar },
      { &EV_ConsoleManager_ConStatusBarValue,   ( Response )ConsoleManager::ConsoleStatusBarValue },
      { &EV_ConsoleManager_ConKickUsers,        ( Response )ConsoleManager::ConsoleKickUsers },
		{ NULL, NULL }
	};

//=============
//ConsoleExists - returns the number of the console, 0 if not found.
//=============
int ConsoleManager::ConsoleExists
   (
   str con_name
   )

   {
   int num,i;
   Console *p;

   // Check for mission computer
   if ( con_name == "missioncon" )
      return mission_console_number;

	num = consoleList.NumObjects();
	for( i = 1; i <= num; i++ )
		{
		p = ( Console * )consoleList.ObjectAt( i );
      if ( con_name == p->ConsoleName() ) 
			{
         return p->ConsoleNumber();
			}
		}

   gi.dprintf( "Console %s does not exist\n", con_name.c_str() );

   return 0;
   }

//=============
//ConsoleExists 
//=============
qboolean ConsoleManager::ConsoleExists
   (
   int con_number
   )

   {
   int num,i;
   Console *p;
   
   // Check for mission computer
   if ( con_number == mission_console_number )
      return true;

	num = consoleList.NumObjects();
	for( i = 1; i <= num; i++ )
		{
		p = ( Console * )consoleList.ObjectAt( i );
      if (p->ConsoleNumber() == con_number)
         return true;
		}
   return false;
   }

//==========
//ProcessCmd - Send this command to the script director.
//==========
void ConsoleManager::ProcessCmd
	(
   Event *ev
	)
	{
   Director.ConsoleInput(ev->GetToken(1),ev->GetToken(2));
   }

//==========
//ProcessVar - Send this variable to the script director.
//==========
void ConsoleManager::ProcessVar
	(
   Event *ev
	)
	{
   Director.ConsoleVariable(ev->GetToken(1),ev->GetToken(2));
   }

//=====================
//ConsolePositionReturn
//=====================
void ConsoleManager::ConsolePositionReturn
	(
   Event *ev
	)
	{
   netconsole_t *svcon;
   int num = ev->GetInteger(1);
   
   if (!ConsoleExists(num))
      {
      // ConsoleExists will give a warning about this console not existing
      return;
      }
   
   svcon  = &g_consoles[num];
   svcon->s.linepos = 1;
   svcon->s.cmdline[svcon->s.linepos] = 0;
   svcon->s.console_return_time = level.time;
   }

//=======================
//ConsolePositionPositive
//=======================
void ConsoleManager::ConsolePositionPositive
	(
   Event *ev
	)
	{
   netconsole_t *svcon;
   int num = ev->GetInteger(1);
   
   if (!ConsoleExists(num))
      {
      // ConsoleExists will give a warning about this console not existing
      return;
      }
   
   svcon  = &g_consoles[num];

   if (svcon->s.linepos < MAXCMDLINE-1)
      {
      svcon->s.cmdline[svcon->s.linepos] = ev->GetInteger(2);
      svcon->s.linepos++;
      svcon->s.cmdline[svcon->s.linepos] = 0;
      }
   }


//=======================
//ConsolePositionNegative
//=======================
void ConsoleManager::ConsolePositionNegative
	(
   Event *ev
	)
	{
   netconsole_t *svcon;
   int num = ev->GetInteger(1);
   
   if (!ConsoleExists(num))
      {
      // ConsoleExists will give a warning about this console not existing
      return;
      }
   
   svcon  = &g_consoles[num];
   
   if (svcon->s.linepos > 1)
      {
      svcon->s.linepos--;
      svcon->s.cmdline[svcon->s.linepos] = 0;
      }
   }


//===============
//ConsoleMenuInfo
//===============
void ConsoleManager::ConsoleMenuInfo
	(
   Event *ev
	)
	{
   netconsole_t *svcon;
   int num = ev->GetInteger(1);
   
   if (!ConsoleExists(num))
      {
      // ConsoleExists will give a warning about this console not existing
      return;
      }
   
   svcon  = &g_consoles[num];
   svcon->s.menu_level = ev->GetInteger(2);
   svcon->s.sel_menu_item = ev->GetInteger(3);
   }

void ConsoleManager::CreateMissionComputer
   (
   void
   )

   {
   netconsole_t   *con;

   // Check for a free console on the server
   if (globals.num_consoles >= globals.max_consoles)
      gi.error("Console::CreateMissionComputer", "No free consoles\n" );

   // Increment the global number of consoles.
   globals.num_consoles++;
   mission_console_number  = globals.num_consoles;
   con                     = &g_consoles[globals.num_consoles];   
   con->inuse              = true;
   con->s.spawnflags       = 2|8;
   con->s.consoleactive    = true;
   con->s.create_time      = -1;
   con->s.number           = globals.num_consoles;
   con->s.virtual_width    = 320;
   con->s.virtual_height   = 240;
   con->s.fraction         = 1.0f;
   con->s.rows             = 30;
   con->s.cols             = 40;
   con->s.menu_file[0]     = 0;
   con->s.linepos          = 1;
   con->s.menufile_update_time = 0;
   strcpy( con->s.console_name, MISSION_CONSOLE );
   con->s.name_update_time = -1;
   con->s.console_return_time = 0;
   }

void ConsoleManager::Reset 
   (
   void
   )

   {
   globals.num_consoles = 0;
   mission_console_number = 0;
   consoleList.ClearObjectList();
   }

//==========
//AddConsole - Add a console to the manager
//==========
int ConsoleManager::AddConsole
	(
	Console *console
	)

	{
   int num;
	num = consoleList.AddObject( console );
   return num;
	}

//=============
//RemoveConsole - Remove a console from the manager
//=============
void ConsoleManager::RemoveConsole
	(
	Console *console
	)
	{
   // Make sure that this exists in the manager
   if ( consoleList.IndexOfObject( console ) )
   	consoleList.RemoveObject( console );
	}

//============
//ConsolePrint - Print a string to the buffer of the console
//============
void ConsoleManager::ConsolePrint
   (
   Event *ev
   )
   {
   char					*bufptr;
	const char			*str;
   netconbuffer_t    *svbuff;
   netconsole_t      *svcon;
   int               *start;
	int					*end;
   int					num;
	
	num = ConsoleExists( ev->GetString( 1 ) );
   if ( !num )
      {
      // ConsoleExists will give a warning about this console not existing
      return;
      }
   
   svcon  = &g_consoles[num];
   svbuff = &g_conbuffers[num];
   bufptr = &svbuff->s.buffer[0];
   start  = &svbuff->s.start;
   end    = &svbuff->s.end;
   str = ev->GetString(2);
   svbuff->s.end_index += strlen(str);

   while (*str)
      {
      if ( (*end+1)%MAX_BUFFER_LENGTH == (*start) )
         {
         svbuff->s.start_index += 1;
         *start = (*start + 1)%MAX_BUFFER_LENGTH;
         }

      bufptr[*end]=*str;
      *end = (*end+1) % MAX_BUFFER_LENGTH;
      str++;
      }
   }

//==============
//ConsoleNewline - Prints a newline to the buffer of the console
//==============
void ConsoleManager::ConsoleNewline
   (
   Event *ev
   )
   {
   ev->AddString("\n");
   ConsolePrint(ev);
   }

//=================
//ConsoleLayoutFile - Orders the console to load a client side layout file
//=================
void ConsoleManager::ConsoleLayoutFile
   (
   Event *ev
   )
   {
   netconsole_t   *svcon;
   int            num;
   const char		*layout_filename;

   num = ConsoleExists(ev->GetString( 1 ));

   if (!num)
      {
      // ConsoleExists will give a warning about this console not existing
      return;
      }

   svcon = &g_consoles[num];
   layout_filename = ev->GetString(2);
   strcpy(svcon->s.layout_file, layout_filename);
   svcon->s.layoutfile_update_time = level.time;
   }

//=============
//ConsoleLayout - Set the layout string 
//=============
void ConsoleManager::ConsoleLayout
   (
   Event *ev
   )
   {
   str                  console_name;
   netconsole_t         *svcon;
   int                  num;
   char		            *layout;
   char                 *token;
   char                 newlayout[ MAX_LAYOUT_LENGTH ];
  	static const char    *seps = " ";

   console_name = ev->GetString( 1 );
   num = ConsoleExists( console_name );

   if ( !num )
      {
      // ConsoleExists will give a warning about this console not existing
      return;
      }

   svcon = &g_consoles[ num ];
   layout = strdup( ev->GetString( 2 ) );

   if ( strlen( layout ) > MAX_LAYOUT_LENGTH )
      error( "ConsoleManager::ConsoleLayout", "Max layout length exceeded for %s\n", ev->GetString( 1 ) );

   strcpy( newlayout, layout );

   if ( coop->value && ( console_name == "missioncon" ) )
      {
      newlayout[ 0 ] = 0;

      token = strtok( layout, seps );
      while ( token )
         {
         // Skip over "fc" console commands in coop
         if ( !strcmp( token, "fc" ) )
            {
            strtok( NULL, seps );
            strtok( NULL, seps );
            strtok( NULL, seps );
            strtok( NULL, seps );
            }
         else if ( strstr( token, "---" ) )
            {
            strcat( newlayout, " " );
            strcat( newlayout, "\"\"" );
            // Skip over extraneous lines of characters
            }
         else
            {
            strcat( newlayout, " " );
            strcat( newlayout, token );
            }
         token = strtok( NULL, seps );
         }
      }

   free( layout );
   strcpy( svcon->s.layout, newlayout );
   svcon->s.layout_update_time = level.time;
   }

//================
//ConsoleAppLayout - Append to the layout string
//================
void ConsoleManager::ConsoleAppLayout
   (
   Event *ev
   )
   {
   netconsole_t         *svcon;
   int                  layout_length, num;
   char		            *layout;
   const char		      *token;
   char                 newlayout[ MAX_LAYOUT_LENGTH ];
  	static const char    *seps = " ";
   str                  consolename;

   consolename = ev->GetString( 1 );
   num = ConsoleExists( consolename );

   if (!num)
      {
      // ConsoleExists will give a warning about this console not existing
      return;
      }

   svcon  = &g_consoles[num];

   layout    = strdup( ev->GetString( 2 ) );
   layout_length = strlen(layout) + strlen(svcon->s.layout) + 1;

   if ( layout_length > MAX_LAYOUT_LENGTH )
      error("ConsoleManager::ConsoleAppLayout", "Max layout length exceeded for %s\n", ev->GetString(1) );

   strcpy( newlayout, layout );

   if ( coop->value && ( consolename == "missioncon" ) )
      {