Google
Web alhem.net
Main Page | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members

ConnectThread Class Reference

#include <ConnectThread.h>

Collaboration diagram for ConnectThread:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 ConnectThread ()
 ConnectThread (char *host, int port=DEFAULT_PORT)
 ~ConnectThread ()
void Run ()
unsigned long get_ip (char *)
IOMessage * GetClass (IO_IDTYPE)
Player * AddPlayer (long)
Player * AddPlayer (long, const string &)
Player * GetPlayer (long)
void SetSelf (long num, const string &)
Player * GetSelf (void)
Map * AddMap (long x, long y, Event::Map *=NULL)
Map * GetMap (long x, long y)

Private Attributes

short m_connected
char m_host [256]
int m_port
unsigned long m_ip
EventThread * m_pclEventThread
Player * m_self
players_t m_players
maps_t m_maps

Constructor & Destructor Documentation

ConnectThread::ConnectThread (   ) 
 

Definition at line 40 of file ConnectThread.cpp.

References m_host, m_ip, and m_port. 

00040                              : IOThread()
00041 ,m_connected(0) 
00042 ,m_port(0)
00043 ,m_pclEventThread(NULL)
00044 ,m_self(NULL)
00045 {
00046         *m_host = 0;
00047         m_port = 0;
00048         m_ip = 0L;
00049 }

ConnectThread::ConnectThread (  char *  host,
int  port = DEFAULT_PORT
) 
 

Definition at line 51 of file ConnectThread.cpp.

References m_host. 

00051                                                  : IOThread(false)
00052 ,m_connected(0) 
00053 ,m_port(port)
00054 ,m_pclEventThread(NULL)
00055 ,m_self(NULL)
00056 {
00057 printf("Connect thread constructor (%s, %d)\n",host,port);
00058 fflush(stdout);
00059         strcpy(m_host, host);
00060 printf("SetRelease(true)\n");
00061         SetRelease(true);
00062 }

ConnectThread::~ConnectThread (   ) 
 

Definition at line 65 of file ConnectThread.cpp.

References DEB, m_maps, m_pclEventThread, and m_players. 

00066 {
00067         DEB(printf("~ConnectThread()\n");)
00068         if (m_pclEventThread)
00069         {
00070                 delete m_pclEventThread;
00071         }
00072         for (players_t::iterator it = m_players.begin(); it != m_players.end(); it++)
00073         {
00074                 Player *p = it -> second;
00075                 delete p;
00076         }
00077         {
00078                 for (maps_t::iterator it = m_maps.begin(); it != m_maps.end(); it++)
00079                 {
00080                         Map *t = it -> second;
00081                         delete t;
00082                 }
00083         }
00084 }

Member Function Documentation

Map * ConnectThread::AddMap (  long  x,
long  y,
Event::Map *  = NULL
) 
 

Definition at line 289 of file ConnectThread.cpp.

References AddMap(), and m_maps.

Referenced by AddMap(). 

00290 {
00291         Map *map;
00292         long key = ((x / MAPSIZE) << 16) + (y / MAPSIZE);
00293 
00294         map = m_maps[key];
00295         if (!map)
00296         {
00297                 map = new Map;
00298                 m_maps[key] = map;
00299         }
00300         if (e)
00301         {
00302                 map -> Populate(e);
00303         }
00304         return map;
00305 }

Player * ConnectThread::AddPlayer (  long  ,
const string & 
) 
 

Definition at line 263 of file ConnectThread.cpp.

References AddPlayer(). 

00264 {
00265         Player *p = AddPlayer(num);
00266         p -> SetName(name);
00267         return p;
00268 }

Player * ConnectThread::AddPlayer (  long   ) 
 

Definition at line 250 of file ConnectThread.cpp.

References AddPlayer(), and m_players.

Referenced by AddPlayer(). 

00251 {
00252         Player *p;
00253         p = m_players[num];
00254         if (!p)
00255         {
00256                 p = new Player(num);
00257                 m_players[num] = p;
00258         }
00259         return p;
00260 }

unsigned long ConnectThread::get_ip (  char *   ) 
 

Definition at line 87 of file ConnectThread.cpp.

References DEB, and get_ip().

Referenced by get_ip(), and Run(). 

00088 {
00089         Parse *pa;
00090         struct hostent *he;
00091         unsigned long l = 0L;
00092         int i,x = 1;
00093 
00094         for (i = 0; i < (int)strlen(ip); i++)
00095                 if ( (ip[i] < '0' || ip[i] > '9') && ip[i] != '.')
00096                         x = 0;
00097         if (x) // ipaddr
00098         {
00099                 pa = new Parse(ip,".");
00100                 l = pa -> getvalue();
00101                 l = (l << 8) + pa -> getvalue();
00102                 l = (l << 8) + pa -> getvalue();
00103                 l = (l << 8) + pa -> getvalue();
00104                 delete pa;
00105                 l = htonl(l);
00106         }
00107         else // hostname
00108         {
00109                 he = gethostbyname(ip);
00110                 if (he)
00111                         memmove(&l, he -> h_addr, 4);
00112         }
00113         DEB(printf(" ip %08lx\n", l);)
00114         return l;
00115 }

IOMessage * ConnectThread::GetClass (  IO_IDTYPE   ) 
 

Definition at line 244 of file ConnectThread.cpp.

References GetClass(), and m_pclEventThread.

Referenced by GetClass(). 

00245 {
00246         return m_pclEventThread ? m_pclEventThread -> GetClass(id) : NULL;
00247 }

Map * ConnectThread::GetMap (  long  x,
long  y
) 
 

Definition at line 308 of file ConnectThread.cpp.

References GetMap(), and m_maps.

Referenced by GetMap(). 

00309 {
00310         long key = ((x / MAPSIZE) << 16) + (y / MAPSIZE);
00311 
00312         return m_maps[key];
00313 }

Player * ConnectThread::GetPlayer (  long   ) 
 

Definition at line 277 of file ConnectThread.cpp.

References GetPlayer(), and m_players.

Referenced by GetPlayer(), and SetSelf(). 

00278 {
00279         return m_players[num];
00280 }

Player * ConnectThread::GetSelf (  void   ) 
 

Definition at line 283 of file ConnectThread.cpp.

References m_self. 

00284 {
00285         return m_self;
00286 }

void ConnectThread::Run (   ) 
 

Definition at line 118 of file ConnectThread.cpp.

References DEB, get_ip(), m_host, m_ip, m_pclEventThread, m_port, pprintf(), and SDL_USEREVENT_DISCONNECT. 

00119 {
00120         struct sockaddr_in sa;
00121         struct timeval tv;
00122         fd_set rfds;
00123         fd_set wfds;
00124         socket_t s;
00125         int n;
00126         int i;
00127 
00128 printf("Parsing host name '%s'\n",m_host);
00129         m_ip = get_ip(m_host);
00130 
00131         s = ::socket(AF_INET, SOCK_STREAM, 0);
00132         if (s == INVALID_SOCKET)
00133         {
00134                 perror("connect_thread: socket() failed");
00135                 goto off0;
00136         }
00137 
00138         sa.sin_family = AF_INET;
00139         sa.sin_port = htons(m_port);
00140         memmove(&sa.sin_addr,&m_ip,4);
00141 
00142         if (connect(s, (struct sockaddr *)&sa, sizeof(sa)) == -1)
00143         {
00144                 perror("connect() failed");
00145                 goto off;
00146         }
00147 
00148         m_pclEventThread = new EventThread(); //event_thread);
00149         m_pclEventThread -> SetConnectThread( this );
00150 
00151         SetFileDescriptor(s);
00152         DEB(printf("Socket#%d\n", s);)
00153         while (IsRunning())
00154         {
00155                 tv.tv_sec = 1;
00156                 tv.tv_usec = 0; //250000; // 0.05
00157                 FD_ZERO(&rfds);
00158                 FD_ZERO(&wfds);
00159                 FD_SET(s, &rfds);
00160                 if (get_oq() > 0)
00161                 {
00162                         FD_SET(s, &wfds);
00163                 }
00164 #ifdef WIN32
00165                 n = select(0, &rfds, &wfds, NULL, &tv);
00166 #else
00167                 n = select(s + 1, &rfds, &wfds, NULL, &tv);
00168 #endif
00169                 if (n == -1)
00170                 {
00171                         DEB(printf("select() failed\n");)
00172                         perror("select() failed");
00173                         SetRunning(false);
00174                 }
00175                 if (n > 0 && FD_ISSET(s, &rfds))
00176                 {
00177                         DEB(printf("rfds event\n");)
00178                         i = fd_read(); // read(s, slask, 200);
00179                         if (i == -1)
00180                         {
00181 #ifdef WIN32
00182                                 int err;
00183                                 int errlen = sizeof(err);
00184                                 getsockopt(s, SOL_SOCKET, SO_ERROR, (char*)&err, &errlen);
00185                                 if (err != WSAEWOULDBLOCK)
00186 #endif
00187                                 {
00188                                         DEB(printf("read() failed (-1)\n");)
00189                                         perror("read() failed");
00190                                         SetRunning(false);
00191                                 }
00192                         }
00193                         else
00194                         if (!i)
00195                         {
00196                                 pprintf("You have been disconnected from the server.\n");
00197                                 fprintf(stderr,"disconnected (read() returns 0)\n");
00198                                 SetRunning(false);
00199                         }
00200                         else
00201                         {
00202                                 DEB(printf(" %d chars read\n",i);)
00203                         }
00204                         n--;
00205                 }
00206                 if (n > 0 && FD_ISSET(s, &wfds))
00207                 {
00208                         DEB(printf("wfds event\n");)
00209                         i = fd_write();
00210                         if (i == -1)
00211                         {
00212                                 perror("write() failed");
00213                                 SetRunning(false);
00214                         }
00215                         n--;
00216                 }
00217         }
00218         if (m_pclEventThread)
00219         {
00220                 m_pclEventThread -> SetRunning(false);
00221         }
00222 
00223         // All done.
00224         pprintf("Disconnected from server.\n");
00225 off:
00226         shutdown(s, 1);
00227 #pragma warning( "send an sdl event about the disconnect to clean up cache's")
00228 #ifdef WIN32
00229         closesocket(s);
00230 #else
00231         close(s);
00232 #endif
00233         SDL_Event e;
00234         e.type = SDL_USEREVENT;
00235         e.user.code = SDL_USEREVENT_DISCONNECT;
00236         e.user.data1 = NULL;
00237         e.user.data2 = NULL;
00238         SDL_PushEvent(&e);
00239 off0:
00240         SetRunning(false);
00241 }

void ConnectThread::SetSelf (  long  num,
const string & 
) 
 

Definition at line 271 of file ConnectThread.cpp.

References GetPlayer(), m_self, and SetSelf().

Referenced by SetSelf(). 

00272 {
00273         m_self = GetPlayer(num);
00274 }

Member Data Documentation

short ConnectThread::m_connected [private]
 

Definition at line 65 of file ConnectThread.h.

char ConnectThread::m_host[256] [private]
 

Definition at line 66 of file ConnectThread.h.

Referenced by ConnectThread(), and Run().

unsigned long ConnectThread::m_ip [private]
 

Definition at line 68 of file ConnectThread.h.

Referenced by ConnectThread(), and Run().

maps_t ConnectThread::m_maps [private]
 

Definition at line 73 of file ConnectThread.h.

Referenced by AddMap(), GetMap(), and ~ConnectThread().

EventThread* ConnectThread::m_pclEventThread [private]
 

Definition at line 69 of file ConnectThread.h.

Referenced by GetClass(), Run(), and ~ConnectThread().

players_t ConnectThread::m_players [private]
 

Definition at line 72 of file ConnectThread.h.

Referenced by AddPlayer(), GetPlayer(), and ~ConnectThread().

int ConnectThread::m_port [private]
 

Definition at line 67 of file ConnectThread.h.

Referenced by ConnectThread(), and Run().

Player* ConnectThread::m_self [private]
 

Definition at line 71 of file ConnectThread.h.

Referenced by GetSelf(), and SetSelf().

The documentation for this class was generated from the following files:
Generated for SDL C++ GUI by doxygen 1.3.6