Gammon Forum

1) for every controlling descriptor (why are
there two created: port and port+1...?):
- create the descriptor sets (loop through
descriptors and add them - regardless of
whether or not a connection has output pending)
- select with a timeout of 0, so that it
returns immediately, modifying the sets
- accept any new connections on this controlling
descriptor
- idem for next controlling descriptor.

2) now that we have our sets made and rezeroed
and made and rezeroed and made (maybe you see
why this is becoming inefficient), we process
input on them. Nothing too bad there.

3) game logic

4) handle output

(NOTE: maybe 3 and 4 are in the other order-
I don't really remember)

5) sleep the amount of time required until next
clock tick. In other words, sit around doing
nothing until then.

            while (GameRunning)
            {
                long currentTime;

                currentTime = GetMillisecondsTime();

                struct timeval delayTime;
                long timeDifference = nextActionTime - currentTime;

                if (timeDifference > 0)
                {
                        delayTime.tv_sec = 0;
                        delayTime.tv_usec = 0;
                        while (timeDifference >= 1000)
                        {
                                delayTime.tv_sec += 1;
                                timeDifference -= 1000;
                        }
                        delayTime.tv_usec = timeDifference * 1000;
                }
                else
                {
                        delayTime.tv_sec = 0;
                        delayTime.tv_usec = 0;
                }

                // Only process sockets if the poll succeeded.
                if ( ConnectionManager->PollSockets( delayTime ) == false )
                {
                        TheWorld->LogBugString("There was an error polling the sockets!");
                }
                else
                {
                        if ( ConnectionManager->ProcessActiveSockets() == false )
                                TheWorld->LogBugString("There was an error processing the selected sockets!");
                }

                // need to handle waiting input lines here

                currentTime = GetMillisecondsTime();

                while ( currentTime >= nextActionTime )
                {
                        /*
                         * Run the game logic.
                         */
                        //printf("Pulse\n\r");
                        TheWorld->TimeUnit();

                        // Update next tick time.
                        nextActionTime += FRAME_TIME;

                        // Update current time.
                        currentTime = GetMillisecondsTime();
                        current_time = currentTime;
                }
            }

1) check how much time is left between now
and the next scheduled game_logic. This is delayTime.

2) poll sockets:
- construct FD set (once), select with delayTime.
- if any socket has input/output waiting, then
the poll sockets will immediately return control
to game_loop. Otherwise, it patiently waits until
the time expires.

3) process sockets:
- retrieve input if there is any
- send output if there is any
- if there was input, process it

4) now that we're done with network stuff, check
if it's time to run the game logic. If so, do so,
and schedule the next time. If not, start all over
again.

    accept_new( control  );
    accept_new( control2 );
    accept_new( conclient);
    accept_new( conjava  );

class CEvent
  {

  public:

  CEvent (const int iSecs, const string sMsg) 
    : m_iWhen (iSecs + time (NULL)), m_sMsg (sMsg) {};

  // copy constructor 
  CEvent (const CEvent & rhs) 
    : m_iWhen (rhs.m_iWhen), m_sMsg (rhs.m_sMsg) { };

  // operator=  (assign one event to another)
  const CEvent & operator= (const CEvent & rhs)
    {
    if (this != &rhs)
      {
      m_iWhen = rhs.m_iWhen;
      m_sMsg = rhs.m_sMsg;
      }
    return *this;
    };

  // operator< (for sorting)
  bool operator< (const CEvent & rhs) const
    {
    // we compare > because the sooner events have the
    // higher priority
    return  m_iWhen > rhs.m_iWhen;
    };

  void DoIt (void) { cout << m_sMsg << endl; };

  int GetTime (void) const { return m_iWhen; };

  private:

  int m_iWhen;    // when event fires
  string m_sMsg;    // what to say

  };  // end of class CEvent

  /* loop through all connections */
for ( iter = m_SocketList.begin (); iter != m_SocketList.end (); iter++)
  {

  time_t t = time (NULL);

  // pull out events that need doing
  while (!m_events.empty ())
    {
    CEvent e = m_events.top ();

    if (e.GetTime () > t)
      break;  // not yet

    m_events.pop ();  // remove from queue

    e.DoIt ();  // do the event
  
    }  // end of events loop

  
  CSocket * pSocket = *iter;


  // process a socket here

  } // end of loop

long GetMillisecondsTime()
{
#ifdef unix
        struct timeval resultTimeval;
        gettimeofday( &resultTimeval, NULL );
        // First off... tv_sec is seconds since the Epoch
        // this is generally Jan 1st 1970.
        // now we don't want to multiply this by 1000, since
        // it might overflow... so first, subtract the seconds
        // from jan-1-1970 to jan-1-2000

        resultTimeval.tv_sec -= 946080000; // 30 years

        // convert to milliseconds
        return resultTimeval.tv_sec * 1000 + resultTimeval.tv_usec / 1000;
#else
        #ifdef WIN32
        // Under Windows, the time is the time since system startup.
        // Knowing Billysoft, this'll never be more than 5 minutes *wink*
        // but seriously, we don't need to worry about overflow here
                return timeGetTime();
        #endif
#endif
}

bool cSocketConnection::InOutSet()
{
	/*
	 * Short-circuit if nothing to write.
	 */
	if ( OutputLength == 0 )
		return true;

	short bytesWritten = 0;

	while ( OutputLength > 0 )
	{
		// Write as much of buffer as possible, topping out at 512 bytes.
		#ifdef unix
			bytesWritten = write( FileDescriptor, OutputBuffer.c_str(), MIN(OutputLength, 512) );
		#else
			#ifdef WIN32
			bytesWritten = send( FileDescriptor, OutputBuffer.c_str(), MIN(OutputLength, 512), 0 );
			#endif
		#endif

		if (bytesWritten < 0)
		{
			if (errno == EWOULDBLOCK || errno == EAGAIN)
				break; // this is normal, and can happen,
				// so just stop for now

			return false; // Something went wrong!
		}

		if (bytesWritten == 0)
			continue;

		if (bytesWritten < OutputLength)
			OutputBuffer = OutputBuffer.substr( bytesWritten );
		else if (bytesWritten == OutputLength)
			OutputBuffer = "";

		OutputLength -= bytesWritten;
	}

	// All good!
	return true;
}

// Write as much of buffer as possible, topping out at 512 bytes.
#ifdef unix
    bytesWritten = write( FileDescriptor, OutputBuffer.c_str(), MIN(OutputLength, 512) );