main(int argc, char *argv[])
{
IPaddress serverIP;
int i;
/* Initialize SDL */
if ( SDL_Init(0) < 0 ) {
fprintf(stderr, "Couldn't initialize SDL: %s\n",SDL_GetError());
exit(1);
}
/* Initialize the network */
if ( SDLNet_Init() < 0 ) {
fprintf(stderr, "Couldn't initialize net: %s\n",
SDLNet_GetError());
SDL_Quit();
exit(1);
}
/* Initialize the channels */
for ( i=0; i<CHAT_MAXPEOPLE; ++i ) {
people[i].active = 0;
people[i].sock = NULL;
}
/* Allocate the socket set */
socketset = SDLNet_AllocSocketSet(CHAT_MAXPEOPLE+1);
if ( socketset == NULL ) {
fprintf(stderr, "Couldn't create socket set: %s\n",
SDLNet_GetError());
cleanup(2);
}
/* Create the server socket */
SDLNet_ResolveHost(&serverIP, NULL, CHAT_PORT);
printf("Server IP: %x, %d\n", serverIP.host, serverIP.port);
servsock = SDLNet_TCP_Open(&serverIP);
if ( servsock == NULL ) {
fprintf(stderr, "Couldn't create server socket: %s\n",
SDLNet_GetError());
cleanup(2);
}
SDLNet_TCP_AddSocket(socketset, servsock);
/* Loop, waiting for network events */
for ( ; ; ) {
/* Wait for events */
SDLNet_CheckSockets(socketset, ~0);
/* Check for new connections */
if ( SDLNet_SocketReady(servsock) ) {
HandleServer();
}
/* Check for events on existing clients */
for ( i=0; i<CHAT_MAXPEOPLE; ++i ) {
if ( SDLNet_SocketReady(people[i].sock) ) {
HandleClient(i);
}
}
}
cleanup(0);
/* Not reached, but fixes compiler warnings */
return 0;
}
//-----------------------------------------------------------------------------
int main(int argc, char *argv[]) {
libInit();
// NOTE: open socket file descriptor
serverFD = SDLNet_UDP_Open(3490);
if(!serverFD) {
fprintf(stderr, "SDLNet_UDP_Open: %s\n", SDLNet_GetError());
libQuit();
return -1;
}
// NOTE: setup a socket set
socketSet = SDLNet_AllocSocketSet(1);
SDLNet_UDP_AddSocket(socketSet, serverFD);
printf("\nServer open on port: %d\n\n", 3490);
// NOTE: initialize the player manager
plManager = initPlayerManager("diamond_collector.db");
/*
LISTEN FOR PACKETS
*/
for(;;) {
// NOTE: wait for a connection
int n = SDLNet_CheckSockets(socketSet, 0);
if(n==-1) {
fprintf(stderr, "SDLNet_CheckSockets: %s\n", SDLNet_GetError());
break;
} if(!n) {
// NOTE: if the server doesn't have anything to do then run through
// a few regular routines
switch(serverState) {
case 0x00: {
if((time(NULL)-lastTimePingsWentOut)>20) {
// NOTE: if the server is idle in its freetime then start sending out
// ping packets for the client to respond to
serverState = 0x01;
lastTimePingsWentOut = time(NULL);
}
} break;
case 0x01: {
if(waitingForPong) {
if(!plManager->pl_indMask[nodeToPing][playerToPing]) {
playerToPing++;
waitingForPong = SDL_FALSE;
} else if((time(NULL)-timeOfPing)>120) {
// NOTE: if we hear nothing back after 5 secs then disconnect the player
DB_Player *pl = &plManager->pl_dbInfo[nodeToPing][playerToPing];
printf("player %s didn't respond to ping logging them out.\n", pl->username);
// NOTE: set the player state and log the player out
pl->state = 0x00;
// NOTE: send a packet out to everyone on this node
// letting them know that the player is leaving.
UDPpacket _packet = {};
/*
- flag (1) 0x05
- id (4)
====== (5)
*/
_packet.maxlen = 0x05; // 5 bytes
_packet.data = (uint8_t *)malloc(0x05);
uint8_t offset = 0;
memset(_packet.data+offset, 0x05, 1);
offset += 1;
memcpy(_packet.data+offset, &pl->id, 4);
offset += 4;
// NOTE: set the packet length to the offset point
_packet.len = offset;
// NOTE: send the packet out to everyone but the player disconnecting
int i;
for(i=0; i<PLAYER_MAX; i++) {
if(!plManager->pl_indMask[pl->node][i])
continue;
_packet.address.host = plManager->pl_dbInfo[pl->node][i].host;
_packet.address.port = plManager->pl_dbInfo[pl->node][i].port;
if(!SDLNet_UDP_Send(serverFD, -1, &_packet))
fprintf(stderr, "SDLNet_UDP_Send: %s\n", SDLNet_GetError());
}
// NOTE: free the packet
free(_packet.data);
// NOTE: save the new player state
pl_save(plManager, pl);
if(pl_removePlayer(plManager, pl) != -1) {
printf("Logout success!\n");
} else {
// NOTE: player was never in the players array should
// probably log this sort of thing
}
playerToPing++;
waitingForPong = SDL_FALSE;
} else {
// TODO: keep sending the ping packet
}
} else {
// NOTE: make sure there are people on this node - else go to the
// next node
int n = pl_numOnNode(plManager, nodeToPing);
if(n <= 0) {
nodeToPing++;
playerToPing = 0;
if(nodeToPing==NODE_MAX) {
nodeToPing = 0;
serverState = 0x00;
}
break;
}
// NOTE: if there isn't a player at this point in the pool then
// go to the next point in the pool
if(!plManager->pl_indMask[nodeToPing][playerToPing]) {
playerToPing++;
if(playerToPing == PLAYER_MAX) {
nodeToPing++;
playerToPing = 0;
if(nodeToPing == NODE_MAX) {
nodeToPing = 0;
serverState = 0x00;
}
}
break;
}
// NOTE: get the player and send out the ping
DB_Player *pl = &plManager->pl_dbInfo[nodeToPing][playerToPing];
// NOTE: send a ping packet
uint8_t flag = 0x0A;
UDPpacket _packet = {};
_packet.data = &flag;
_packet.len = 1;
_packet.maxlen = 1;
_packet.address.host = pl->host;
_packet.address.port = pl->port;
if(!SDLNet_UDP_Send(serverFD, -1, &_packet))
fprintf(stderr, "SDLNet_UDP_Send: %s\n", SDLNet_GetError());
timeOfPing = time(NULL);
waitingForPong = SDL_TRUE;
}
} break;
}
continue;
}
// NOTE: does the server have packets waiting?
if(SDLNet_SocketReady(serverFD)) {
// NOTE: setup a packet which is big enough to store any client message
UDPpacket packet;
// NOTE: allocate space for packet
packet.maxlen = 0xAA; // 170 bytes
packet.data = (uint8_t *)malloc(0xAA);
// NOTE: get the packet
int recv = SDLNet_UDP_Recv(serverFD, &packet);
if(!recv) {
free(packet.data);
continue;
}
// NOTE: read the flag for packet identity
uint8_t flag = 0;
uint32_t offset = 0;
memcpy(&flag, packet.data, 1);
offset += 1;
// NOTE: process the packet
switch(flag) {
case 0x01: {
net_login(plManager, &packet, &offset);
} break;
case 0x02: {
net_logout(plManager, &packet, &offset);
} break;
case 0x07: {
net_moveUp(plManager, &packet, &offset);
} break;
case 0x08: {
net_moveDown(plManager, &packet, &offset);
} break;
case 0x09: {
net_moveLeft(plManager, &packet, &offset);
} break;
case 0x0A: {
net_moveRight(plManager, &packet, &offset);
} break;
case 0x0B: {
net_sendOutPlInfo(plManager, &packet, &offset);
} break;
case 0x0C: {
// NOTE: get the player which is logged in on the incoming address
DB_Player *pl = pl_getDBInfo(plManager, packet.address);
if(pl == NULL) break;
// NOTE: need to make sure the pong is from the right player
int ind = pl_getIndex(plManager, pl);
// NOTE: player responding with a pong packet
if(ind==playerToPing) {
playerToPing++;
waitingForPong = SDL_FALSE;
}
} break;
case 0x0D: {
net_sendOutNodeInfo(plManager, &packet, &offset);
} break;
}
// NOTE: free the packet when done processing
free(packet.data);
}
}
// NOTE: free the player manager
freePlayerManager(plManager);
// NOTE: free socketset
SDLNet_FreeSocketSet(socketSet);
// NOTE: close the socket file descriptor
SDLNet_UDP_Close(serverFD);
libQuit();
return 0;
}
int main(int argc, char *argv[])
{
UNUSED(argc);
UNUSED(argv);
if (SDL_Init(SDL_INIT_TIMER | SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) != 0)
{
fprintf(stderr, "Could not initialise SDL: %s\n", SDL_GetError());
return -1;
}
if (SDLNet_Init() == -1)
{
fprintf(stderr, "SDLNet_Init: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
if (!SDL_SetVideoMode(320, 200, 0, 0))
{
fprintf(stderr, "Could not set video mode: %s\n", SDL_GetError());
SDL_Quit();
exit(-1);
}
ConfigLoadDefault(&gConfig);
ConfigLoad(&gConfig, GetConfigFilePath(CONFIG_FILE));
EventInit(&gEventHandlers, NULL, false);
NetInputClient client;
NetInputClientInit(&client);
NetInputClientConnect(&client, 0x7F000001); // localhost
printf("Press esc to exit\n");
Uint32 ticksNow = SDL_GetTicks();
Uint32 ticksElapsed = 0;
for (;;)
{
Uint32 ticksThen = ticksNow;
ticksNow = SDL_GetTicks();
ticksElapsed += ticksNow - ticksThen;
if (ticksElapsed < 1000 / FPS_FRAMELIMIT)
{
SDL_Delay(1);
debug(D_VERBOSE, "Delaying 1 ticksNow %u elapsed %u\n", ticksNow, ticksElapsed);
continue;
}
EventPoll(&gEventHandlers, SDL_GetTicks());
int cmd = GetOnePlayerCmd(
&gEventHandlers,
&gConfig.Input.PlayerKeys[0],
false,
INPUT_DEVICE_KEYBOARD,
0);
if (cmd)
{
printf("Sending %s + %s\n",
CmdStr(cmd & (CMD_LEFT | CMD_RIGHT | CMD_UP | CMD_DOWN)),
CmdStr(cmd & (CMD_BUTTON1 | CMD_BUTTON2 | CMD_BUTTON3 | CMD_BUTTON4 | CMD_ESC)));
NetInputClientSend(&client, cmd);
}
// Check keyboard escape
if (KeyIsPressed(&gEventHandlers.keyboard, SDLK_ESCAPE))
{
break;
}
ticksElapsed -= 1000 / FPS_FRAMELIMIT;
}
NetInputClientTerminate(&client);
EventTerminate(&gEventHandlers);
SDLNet_Quit();
SDL_Quit();
return 0;
}
int main(int argc, char** argv)
{
try {
std::string port;
CommandLine argp;
argp.add_usage("[OPTIONS] PORT");
argp.add_group("General:");
argp.add_option('v', "version", "", "Print the netBrush server version");
argp.add_option('h', "help", "", "Print this help");
argp.parse_args(argc, argv);
while(argp.next())
{
switch(argp.get_key())
{
case 'h':
argp.print_help();
return 0;
break;
case 'v':
std::cout << "netBrush Server 0.1.0" << std::endl;
return 0;
break;
case CommandLine::REST_ARG:
if (!port.empty())
{
std::cout << "Invalid argument: " << argp.get_argument() << std::endl;
return 1;
}
else
{
port = argp.get_argument();
}
break;
}
}
if (port.empty())
{
argp.print_help();
return 1;
}
if(SDL_Init(0)==-1) {
printf("SDL_Init: %s\n", SDL_GetError());
exit(1);
}
if(SDLNet_Init()==-1) {
printf("SDLNet_Init: %s\n", SDLNet_GetError());
exit(2);
}
atexit(SDL_Quit);
atexit(SDLNet_Quit);
std::ostringstream filename;
filename << "sessions/session-" << time(NULL) << ".nbr";
std::cout << "# writing log to " << filename.str() << std::endl;
outfile = new std::ofstream(filename.str().c_str());
if (argc == 2)
{
std::cout << "# listening on: " << port << std::endl;
connect(atoi(port.c_str()));
}
else
{
std::cout << "Usage: " << argv[0] << " PORT" << std::endl;
}
outfile->close();
delete outfile;
} catch (std::exception& err) {
std::cout << "Exception: " << err.what() << std::endl;
}
return 0;
}
if( (client_socket = SDLNet_TCP_Accept(net_server->Socket)) )
{
ConnectedClient *connected_client = new ConnectedClient( client_socket, net_server->UseOutThreads, net_server->NetRate, net_server->Precision );
if( (remote_ip = SDLNet_TCP_GetPeerAddress(client_socket)) )
{
connected_client->IP = Endian::ReadBig32(&(remote_ip->host));
connected_client->Port = Endian::ReadBig16(&(remote_ip->port));
char cstr[ 1024 ] = "";
snprintf( cstr, 1024, "Client connected: %i.%i.%i.%i:%i", (connected_client->IP & 0xFF000000) >> 24, (connected_client->IP & 0x00FF0000) >> 16, (connected_client->IP & 0x0000FF00) >> 8, connected_client->IP & 0x000000FF, connected_client->Port );
Raptor::Server->ConsolePrint( cstr );
}
else
{
fprintf( stderr, "SDLNet_TCP_GetPeerAddress: %s\n", SDLNet_GetError() );
Raptor::Server->ConsolePrint( "Client connected from unknown IP!\n" );
}
if( ! net_server->Lock.Lock() )
fprintf( stderr, "NetServerThread: net_server->Lock.Lock: %s\n", SDL_GetError() );
net_server->Clients.push_back( connected_client );
if( ! net_server->Lock.Unlock() )
fprintf( stderr, "NetServerThread: net_server->Lock.Unlock: %s\n", SDL_GetError() );
}
// Let the thread rest a bit. This thread only handles new connections, so it can be a long delay.
SDL_Delay( 100 );
}
// Set the thread pointer to NULL so we can delete the NetServer object.
void Networking::Send(TCPsocket socket, char *msg, int len) {
if (SDLNet_TCP_Send(socket, (void*)msg, len) < len) {
printf("SDLNet_TCP_Send: %s\n", SDLNet_GetError());
}
}
int net_http_upload(const char* filename, char* fmt, ...) {
va_list args;
va_start(args, fmt);
vsnprintf(url_buffer, 500, fmt, args);
va_end(args);
int parts = sscanf(url_buffer, "http://%[^/]%s", host_buffer, path_buffer);
if (parts != 2) {
warning("Couldn't resolve parts of URL '%s'", url_buffer);
return HTTP_ERR_URL;
}
IPaddress ip;
if ( SDLNet_ResolveHost(&ip, host_buffer, 80) == -1) {
warning("Couldn't Resolve Host: %s", SDLNet_GetError());
return HTTP_ERR_HOST;
}
TCPsocket sock = SDLNet_TCP_Open(&ip);
if (!sock) {
warning("Couldn't open socket: %s", SDLNet_GetError());
return HTTP_ERR_SOCKET;
}
SDL_RWops* file = SDL_RWFromFile(filename, "r");
if (file == NULL) {
warning("Couldn't Open File '%s' to upload", filename);
return HTTP_ERR_NOFILE;
}
size_t size = SDL_RWseek(file,0,SEEK_END);
char* contents = malloc(size+1);
contents[size] = '\0';
SDL_RWseek(file, 0, SEEK_SET);
SDL_RWread(file, contents, size, 1);
SDL_RWclose(file);
char sockbody[size + 1024 * 4];
char sockheaders[1024*4];
snprintf(sockbody,((size + 1024 * 4) - 1),
"--CorangeUploadBoundary\r\n"
"content-disposition: form-data; name=\"corangeupload\"; filename=\"%s\"\r\n"
"Content-Type: text/plain\r\n"
"\r\n"
"%s\r\n"
"--CorangeUploadBoundary--\r\n"
"\r\n", filename, contents);
snprintf(sockheaders,((1024 * 4) - 1),
"POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Content-Length: %i\r\n"
"Content-Type: multipart/form-data; boundary=CorangeUploadBoundary\r\n"
"\r\n" , path_buffer, host_buffer, (int)strlen(sockbody));
int result = 0;
result = SDLNet_TCP_Send(sock, sockheaders, strlen(sockheaders));
if (result < strlen(sockheaders)) {
warning("Error sending http request: %s", SDLNet_GetError());
return HTTP_ERR_DATA;
}
result = SDLNet_TCP_Send(sock, sockbody, strlen(sockbody));
if (result < strlen(sockbody)) {
warning("Error sending http request: %s", SDLNet_GetError());
return HTTP_ERR_DATA;
}
char line[1024];
while (SDLNet_TCP_RecvLine(sock, line, 1023)) {
//debug("Recived: %s", line);
}
return HTTP_ERR_NONE;
}
int main(int argc, char* argv[]) {
bool running = true;
int i, j, xfrog, yfrog, xfly, yfly, leech[MAX_PLAYERS], tadswim = 0, swavenum[MAX_PLAYERS], swave_clk[MAX_PLAYERS], cls, kk;
float dist;
int nfrogs = 7; // Number of frogs
int sp = 1; // Speed (1-3)
int a_i = 3; // AI (1-3)
FILE *fp;
// Open hiscores.txt
if((fp = fopen("hiscores.txt","r")) == NULL) {
printf("Can't find file: hiscores.txt\n");
return 1;
}
for(kk = 0; kk < 32; kk++) {
hiscores[kk].name = (char*)malloc(MAX_NAME_LENGTH*sizeof(char));
hiscores[kk].time = 0;
}
int ret = 1;
kk = 0;
while(ret != EOF) {
ret = fscanf(fp,"%s %d", hiscores[kk].name, &hiscores[kk].time);
kk++;
}
// Close hiscores.txt
fclose(fp);
// Bubble sort
for(i=0; i<31; i++) {
for(j=31; j > i; j--) {
if(hiscores[j].time > hiscores[j-1].time) {
strcpy(buf,hiscores[j-1].name);
kk = hiscores[j-1].time;
strcpy(hiscores[j-1].name,hiscores[j].name);
hiscores[j-1].time = hiscores[j].time;
strcpy(hiscores[j].name,buf);
hiscores[j].time = kk;
}
}
}
#ifdef TADPOLE_COLLISIONS
int tempvel;
int collisions[MAX_PLAYERS][MAX_PLAYERS];
for(i=0;i<MAX_PLAYERS;i++) {
for(j=0;j<MAX_PLAYERS;j++) {
collisions[i][j] = 0;
}
}
#endif
for(i=0;i<MAX_PLAYERS;i++) {
leech[i] = 0;
swavenum[i] = 0;
swave_clk[i] = 0;
leaderboard_rank[i] = -1;
}
int bwavenum = 0, bwave_clk, mm_clk = 0, suwavenum = 0, suwave_clk = 0; // various wave clocks and wave counters (storing latest wave to be animated)
int nherd[10], nflychasers = 0; // nherd[i] counts number of close frogs to ith frog in jumpstate 0.
int tadflip = 0, mmtadx = SCREEN_WIDTH/2, mmtady = SCREEN_HEIGHT/2+BANNER_HEIGHT/2;
float ran; // random number storing
char Tadname[MAX_NAME_LENGTH];
strcpy(Tadname,"Player_0"); // Name of local player, no spaces
set_frogclips();
set_tadclips();
set_flyclips();
set_swaveclips();
set_bwaveclips();
set_suwaveclips();
Timer fps;
Timer gameclock;
Timer flyspan;
std::vector<Timer> warpspan(nfrogs);
// Setting wave flags to 'not animate / done animation'
for(j=0; j<NUMWAVES; j++) {
nherd[j] = 0;
for(kk=0; kk<MAX_PLAYERS; kk++) {
smallwaves[kk][j][0] = 6;
}
}
for(j=0; j<NUMWAVES; j++) {
bigwaves[j][0] = 24;
suwaves[j][0] = 24;
}
if (init() == false) return 1;
if (load_files() == false) return 1;
// Spawn Tadpole
// Tadpole myTad;
std::vector<Tadpole> myTad(MAX_PLAYERS);
// Spawn fly
xfly = 10+drand48()*(SCREEN_WIDTH-LEADER_WIDTH-HISCORE_WIDTH-20)+LEADER_WIDTH;
yfly = 10+drand48()*(SCREEN_HEIGHT-BANNER_HEIGHT-20) + BANNER_HEIGHT;
Fly myfly( xfly, yfly );
// Spawn Frogs
std::vector<Frog> myfrogs(nfrogs);
for(i = 0; i < nfrogs; i++ ) {
xfrog = drand48()*(SCREEN_WIDTH-LEADER_WIDTH-HISCORE_WIDTH-20)+LEADER_WIDTH;
yfrog = drand48()*(SCREEN_HEIGHT-BANNER_HEIGHT-20) + BANNER_HEIGHT;
if(distance(xfrog, yfrog, mmtadx, mmtady) < (SCREEN_HEIGHT-BANNER_HEIGHT)/4) {
i--;
}
myfrogs[i].Frog_set(xfrog, yfrog, sp, a_i);
}
for(i=0; i<nfrogs; i++)
myfrogs[i].show(sp);
myfly.show();
if(SDL_Flip(screen) == -1) return 1;
SDL_Delay(500);
gameclock.start();
#ifdef PRINT_MESSAGES
printf("Tadpole server is up!\n");
#endif
#ifdef WITH_SOUND
// if(Mix_PlayMusic(ambience, -1) == -1)
if(Mix_FadeInMusic(ambience, -1, 2000) == -1)
return 1;
#endif
// Game Server loop
while (running) {
fps.start();
// Listen for connections, argument 0 means no wait-time
int numActiveSockets = SDLNet_CheckSockets(socketSet, 0);
if(numActiveSockets > 0) {
// Check help socket. If activity detected, then open temporary socket and dump help text. Then close socket.
int helpSocketActivity = SDLNet_SocketReady(helpSocket);
if(helpSocketActivity != 0) {
TCPsocket tempSock = SDLNet_TCP_Accept(helpSocket);
SDLNet_TCP_Send(tempSock,(void*)reply,strlen(reply)+1);
// Close temporary connection
SDLNet_TCP_Close(tempSock);
}
// Check if our server socket has received any data
// Note: SocketReady can only be called on a socket which is part of a set and that has CheckSockets called on it (the set, that is)
// SDLNet_SocketRead returns non-zero for activity, and zero is returned for no activity.
int serverSocketActivity = SDLNet_SocketReady(serverSocket);
// All server activity interpreted as request for TCP connection
if(serverSocketActivity != 0) {
// If we have room for more clients...
if(ntads < MAX_PLAYERS) {
int freeSpot = -99;
for(int i = 0; i < MAX_PLAYERS; i++) {
if(!myTad[i].alive && !myTad[i].TCP_limbo) {
freeSpot = i;
break;
}
}
// Accept the client connection
myTad[freeSpot].socket = SDLNet_TCP_Accept(serverSocket);
// get clients IP
remoteip = SDLNet_TCP_GetPeerAddress(myTad[freeSpot].socket);
if(!remoteip) {
#ifdef SERVER_DEBUG
printf("SDLNet_TCP_GetPeerAddress: %s\n",SDLNet_GetError());
#endif
// No remote ip?! NO CONNECTION!
SDLNet_TCP_Close(myTad[freeSpot].socket);
} else {
#ifdef SERVER_DEBUG
ipaddr=SDL_SwapBE32(remoteip->host);
printf("Accepted a connection from %d.%d.%d.%d port %hu.",
ipaddr>>24,
(ipaddr>>16)&0xff,
(ipaddr>>8)&0xff,
ipaddr&0xff,
remoteip->port);
printf(" There are now %d client(s) online.\n",
ntads+1);
#endif
ntads++;
myTad[freeSpot].TCP_limbo = true;
// Add new client socket to socket set, to check activity
SDLNet_TCP_AddSocket(socketSet, myTad[freeSpot].socket);
// Send 'N' asking for name
strcpy(buf,"N");
SDLNet_TCP_Send(myTad[freeSpot].socket,(void*)buf,2);
}
} else { // No new room for clients
#ifdef SERVER_DEBUG
printf("No room. Rejecting client.\n");
#endif
// Accept client connection to clear it from incoming list
TCPsocket tempSock = SDLNet_TCP_Accept(serverSocket);
// Send 'X' telling that there is no room
strcpy(buf,"X");
SDLNet_TCP_Send(tempSock,(void*)buf,2);
// Close temporary connection
SDLNet_TCP_Close(tempSock);
}
}
connection accept_connection()
{
if(!server_socket) {
return 0;
}
// A connection isn't considered 'accepted' until it has sent its initial handshake.
// The initial handshake is a 4 byte value, which is 0 for a new connection,
// or the handle of the connection if it's trying to recover a lost connection.
/**
* A list of all the sockets which have connected,
* but haven't had their initial handshake received.
*/
static std::vector<TCPsocket> pending_sockets;
static SDLNet_SocketSet pending_socket_set = 0;
const TCPsocket sock = SDLNet_TCP_Accept(server_socket);
if(sock) {
#if !defined(_WIN32) && !defined(__WIN32__) && !defined (WIN32)
_TCPsocket* raw_sock = reinterpret_cast<_TCPsocket*>(sock);
int fd_flags = fcntl(raw_sock->channel, F_GETFD, 0);
fd_flags |= FD_CLOEXEC;
if (fcntl(raw_sock->channel, F_SETFD, fd_flags) == -1) {
WRN_NW << "could not make socket " << sock << " close-on-exec: " << strerror(errno);
} else {
DBG_NW << "made socket " << sock << " close-on-exec\n";
}
#endif
DBG_NW << "received connection. Pending handshake...\n";
if(pending_socket_set == 0) {
pending_socket_set = SDLNet_AllocSocketSet(32);
}
if(pending_socket_set != 0) {
int res = SDLNet_TCP_AddSocket(pending_socket_set,sock);
if (res != -1) {
pending_sockets.push_back(sock);
} else {
ERR_NW << "Pending socket set is full! Disconnecting " << sock << " connection" << std::endl;
ERR_NW << "SDLNet_GetError(): " << SDLNet_GetError() << std::endl;
SDLNet_TCP_Close(sock);
}
} else {
ERR_NW << "Error in SDLNet_AllocSocketSet" << std::endl;
}
}
if(pending_socket_set == 0) {
return 0;
}
const int set_res = SDLNet_CheckSockets(pending_socket_set,0);
if(set_res <= 0) {
return 0;
}
return accept_connection_pending(pending_sockets, pending_socket_set);
}
Server::Server(int width, int height){
windowWidth = width;
windowHeight = height;
// initialize SDL
if (SDL_Init(SDL_INIT_EVERYTHING) < 0){
printf("SDL could not initialize! SDL_Error %s\n", SDL_GetError());
} else {
// initialize SDLnet
if (SDLNet_Init() < 0){
printf("SDLNet could not initilaize! SDLNet_Error %s\n", SDLNet_GetError());
} else {
// create window
window = SDL_CreateWindow("Utz Stauder - Server", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, width, height, SDL_WINDOW_SHOWN);
if (window == NULL){
printf("Window could not be created! SDL_Error %s\n", SDL_GetError());
} else {
//Create renderer for window
renderer = SDL_CreateRenderer( window, -1, SDL_RENDERER_ACCELERATED );
if( renderer == NULL )
{
printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() );
}
// initialize network
SDLNet_ResolveHost(&ip, NULL, port);
server_socket = SDLNet_TCP_Open(&ip);
// allocate socket set
client_sockets = SDLNet_AllocSocketSet(MAX_PLAYERS);
// create ball object
ball = new BallObject(24);
ball->loadTexture(renderer, "ball.png");
ball->SetScale(*new Vector2(0.5, 0.5));
gameObjects.push_back(ball);
// create UI
TTF_Init();
ui_background = SDL_CreateRGBSurface(0, ui_background_width, ui_background_height, 32, 0, 0, 0, 0);
ui_background_rect.x = ui_background_x;
ui_background_rect.y = ui_background_y;
ui_background_rect.w = ui_background_width;
ui_background_rect.h = ui_background_height;
SDL_FillRect(ui_background, &ui_background_rect, SDL_MapRGB(ui_background->format, 255, 255, 255));
ui_background_texture = SDL_CreateTextureFromSurface(renderer, ui_background);
font = TTF_OpenFont("font.ttf", 24);
if (!font){
printf("TTF_OpenFont: %s\n", TTF_GetError());
}
ui_text = TTF_RenderText_Solid(font, ui_text_content, white);
ui_text_texture = SDL_CreateTextureFromSurface(renderer, ui_text);
ui_text_rect.x = ui_text_x;
ui_text_rect.y = ui_text_y;
ui_text_rect.w = ui_text_width;
ui_text_rect.h = ui_text_height;
}
}
}
}
int NetClient::Connect( const char *hostname, int port, const char *name, const char *password )
{
Host = hostname;
if( port > 0 )
Port = port;
else
Port = 7000;
if( ! Initialized )
return -1;
if( Connected )
DisconnectNice();
// Clean up old data and socket.
SDL_Delay( 1 );
Cleanup();
DisconnectMessage.clear();
// Show the wait screen.
char cstr[ 1024 ] = "";
snprintf( cstr, 1024, "Connecting to %s:%i...", hostname, Port );
Raptor::Game->Console.Print( cstr );
Raptor::Game->ChangeState( Raptor::State::CONNECTING );
// Resolve the host we are connecting to.
IPaddress ip;
if( SDLNet_ResolveHost( &ip, hostname, Port ) < 0 )
{
Raptor::Game->Console.Print( "Failed to resolve server hostname.", TextConsole::MSG_ERROR );
Raptor::Game->ChangeState( Raptor::State::DISCONNECTED );
return -1;
}
// Open a connection with the IP provided.
if( !( Socket = SDLNet_TCP_Open(&ip) ) )
{
Raptor::Game->Console.Print( "Failed to open socket to server.", TextConsole::MSG_ERROR );
Raptor::Game->ChangeState( Raptor::State::DISCONNECTED );
return -1;
}
BytesSent = 0;
BytesReceived = 0;
// Start the listener thread.
Connected = true;
if( !( Thread = SDL_CreateThread( NetClientThread, this ) ) )
{
fprintf( stderr, "SDL_CreateThread: %s\n", SDLNet_GetError() );
Connected = false;
SDLNet_TCP_Close( Socket );
Socket = NULL;
Raptor::Game->ChangeState( Raptor::State::DISCONNECTED );
return -1;
}
uint32_t ip_int = Endian::ReadBig32(&(ip.host));
uint16_t port_int = Endian::ReadBig16(&(ip.port));
snprintf( cstr, 1024, "Connected to: %i.%i.%i.%i:%i", (ip_int & 0xFF000000) >> 24, (ip_int & 0x00FF0000) >> 16, (ip_int & 0x0000FF00) >> 8, ip_int & 0x000000FF, port_int );
Raptor::Game->Console.Print( cstr );
// Send login information.
Packet packet( Raptor::Packet::LOGIN );
packet.AddString( Raptor::Game->Game );
packet.AddString( Raptor::Game->Version );
packet.AddString( name );
packet.AddString( password ); // FIXME: This assumes every game requires a password!
Send( &packet );
// If we connected successfully, don't try to reconnect.
ReconnectTime = 0;
ReconnectAttempts = 0;
return 0;
}
int main(int argc, char* argv[])
{
FILE *fp;
int archive_flag = 0;
int framecount = 0;
char filename[20];
int index = 0;
int i1, size;
int result, ready, timeout;
int imageReady = 0;
char imageBuf[MTU*10];
char buf[MTU], *cp;
char msg[2] = {'I', 0};
char msg1[5] = { 'M', 0x01, 0x01, 0x01, 0};
IPaddress ipaddress;
TCPsocket tcpsock;
SDLNet_SocketSet socSet;
unsigned int flags = SDL_DOUBLEBUF|SDL_HWSURFACE;
SDL_Surface *screen;
SDL_Surface *image;
unsigned int nrSocketsReady;
// initialize SDL and SDL_net
if((SDL_Init(SDL_INIT_VIDEO) == -1)) {
printf("Could not initialize SDL: %s.\n", SDL_GetError());
return 1;
}
if(SDLNet_Init() == -1) {
printf("SDLNet_Init: %s\n", SDLNet_GetError());
return 2;
}
if(TTF_Init() == -1) {
printf("TTF_Init: %s\n", TTF_GetError());
return 3;
}
// initialize the screen
screen = SDL_SetVideoMode(320, 260, 32, flags);
SDLNet_ResolveHost(&ipaddress, IP_ADDRESS, 10001);
tcpsock = SDLNet_TCP_Open(&ipaddress);
if(!tcpsock) {
printf("SDLNet_TCP_Open 1: %s\n", SDLNet_GetError());
return 2;
}
socSet = SDLNet_AllocSocketSet(1);
SDLNet_TCP_AddSocket(socSet, tcpsock);
msg1[0] = msg1[1] = msg1[2] = msg1[3] = 0;
SDL_Event event;
int quit = 0;
imageReady = 0;
timeout = 0;
// main loop
for (; !quit;) {
// check keyboard events
*msg1 = 0;
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_MOUSEBUTTONUP:
if(event.button.button == SDL_BUTTON_LEFT){
printf("X: %d Y: %d\n", event.button.x, event.button.y);
}
break;
case SDL_KEYDOWN:
switch( event.key.keysym.sym ) {
case SDLK_ESCAPE:
quit = 1;
break;
case SDLK_a:
archive_flag = 1;
framecount = 0;
printf(" archiving enabled - files saved in ./archives/ directory\n");
break;
case SDLK_RETURN:
printf("Entering input mode...\n");
sendCmd(tcpsock,socSet, screen);
break;
}
break;
}
}
index = 0;
imageBuf[0] = 0;
imageReady = 0;
// send 'I' command
result = SDLNet_TCP_Send(tcpsock, msg, 1);
if(result < 1)
printf("SDLNet_TCP_Send 1: %s\n", SDLNet_GetError());
// look for frames
while (!imageReady) {
if (!imageReady) {
nrSocketsReady = SDLNet_CheckSockets(socSet, TIMEOUT);
if (nrSocketsReady == -1) {
printf("SDLNet_CheckSockets: %s\n", SDLNet_GetError());
perror("SDLNet_CheckSockets");
}
else if (nrSocketsReady > 0) {
if (SDLNet_CheckSockets(socSet, TIMEOUT)) {
if (SDLNet_SocketReady(socSet)) {
result = SDLNet_TCP_Recv(tcpsock, buf, MTU);
memcpy(imageBuf+index, buf, result);
index += result;
if ((buf[result-2] == -1) && (buf[result-1] == -39))
imageReady = 1;
}
}
}
else {
printf("\n\rNo sockets ready.\n\r");
break;
}
}
}
// make certain that captured frames are valid
if (!imageReady || imageBuf[0]!='#' || imageBuf[1]!='#' || imageBuf[2]!='I') {
imageReady = 0;
printf("bad image, or Checksockets() timed out!\n");
continue;
}
size = (unsigned int)imageBuf[6] + (unsigned int)imageBuf[7]*256 + (unsigned int)imageBuf[8]*65536;
if (size > index-10) {
printf("bad image size: %d %d %d\n", size, index, framecount);
imageReady = 0;
continue;
}
imageReady = 0;
timeout = 0;
SDL_RWops *rwop;
rwop = SDL_RWFromMem(&(imageBuf[10]), index-10);
image = IMG_LoadJPG_RW(rwop);
cp = (char *)image->pixels;
if (archive_flag) {
sprintf(filename, "archives/%.4d.ppm", framecount);
fp = fopen(filename, "w");
fprintf(fp,"P6\n320\n240\n255\n", 15);
fwrite(cp, 1, 230400, fp);
fclose(fp);
}
framecount++;
SDL_BlitSurface(image, NULL, screen, NULL);
SDL_Flip(screen);
SDL_FreeRW(rwop);
SDL_FreeSurface(image);
}
TTF_Quit();
SDLNet_TCP_Close(tcpsock);
SDLNet_Quit();
SDL_Quit();
return 0;
}
void sendCmd(TCPsocket tcpsock, SDLNet_SocketSet socSet, SDL_Surface *screen)
{
int i, result;
unsigned char cmd[30]; // Buffer to hold the input string
unsigned char temp[31]; // temporary buffer used for printing (one extra char for the '_' -char)
unsigned char buffer[MTU];
SDL_Surface *text = NULL;
SDL_Color textColor = {0,255,0,0};
SDL_Color bgColor = {0,0,0,0};
unsigned char len = 0; // the length of the current command
unsigned char done = 0, exit = 0; // flags
TTF_Font *font = NULL;
SDL_Event event;
SDL_Rect cmdPos = {16,240,320,20};
SDL_Rect consolePos = {0,240,320,20};
signed int nrSocketsReady;
// prepare command buffers
for (i=0;i<30;i++) {
cmd[i] = '\0';
temp[i] = '\0';
}
temp[30] = '\0';
// console chars
temp[0] = '#';
temp[1] = '>';
temp[2] = '_';
//setup the text param's and render console chars to "screen"
SDL_EnableUNICODE(SDL_ENABLE);
font = TTF_OpenFont(FONT, FONT_SIZE);
if(!font) {
printf("TTF_OpenFont: %s\n", TTF_GetError());
}
text = TTF_RenderText_Shaded(font, temp, textColor, bgColor);
if (text == NULL) {
printf("TTF_OpenFont: %s\n", TTF_GetError());
}
if (SDL_BlitSurface(text,NULL, screen, &consolePos) != 0) {
printf("TTF_OpenFont: %s\n", TTF_GetError());
}
SDL_UpdateRect(screen, 0, 0, 0, 0);
SDL_FreeSurface(text);
strcpy(temp,cmd);
while((!done) && (!exit)) {
while(SDL_PollEvent(&event)) {
//If a key was pressed
if( event.type == SDL_KEYDOWN ) {
strcpy(temp,cmd); // reset temp
len = 0;
do { // Find the length of the current command
if (cmd[len] != '\0')
len++;
else
break;
} while(len < 29); // save the last '\0' char
if (event.key.keysym.sym == SDLK_RETURN) {
done = 1; // flag the command as complete, exit loop
}
//If backspace was pressed and the string isn't blank
else if((event.key.keysym.sym == SDLK_BACKSPACE ) && (len > 0)) {
cmd[len - 1] = '\0'; // Remove a character from the end
}
else if (event.key.keysym.sym == SDLK_ESCAPE) {
exit = 1; // exits loop
}
else if ((len < 29) && (event.key.keysym.unicode >= (unsigned short)' ') && (event.key.keysym.unicode <= (unsigned short)'}')) {
cmd[len] = (char)event.key.keysym.unicode; //Append the character to the command string
}
else if (len >= 29) {
printf("command too long!\n\r");
}
if (strcmp(cmd,temp) != 0) {
clrCmd(screen, CMD);
memset(temp,'\0',30);
strcpy(temp,cmd);
len = 0;
do {
if (cmd[len] != '\0')
len++;
else
break;
} while(len < 29); // save place for the '_' and '\0' char
temp[len] = '_'; // add an underscore (just because it looks good)
text = TTF_RenderText_Shaded(font, temp, textColor, bgColor); // Render a new text surface
SDL_BlitSurface(text,NULL, screen, &cmdPos); // put the text onto the "screen"
SDL_UpdateRect(screen, 0, 0, 0, 0); // update the text area
SDL_FreeSurface(text); // Free the surface in memory
}
}
}
}
if (!exit) {
printf("entered command: \"%s\"\n\r",cmd); // prints the command send to the SRV
len = 0;
do {
if ((cmd[len] != ' ') && (cmd[len] != '\0'))
len++;
else
break;
} while(len < 30);
if (len > 0) {
// Send command to SRV-1
result = SDLNet_TCP_Send(tcpsock, cmd, len);
if(result < 1)
printf("SDLNet_TCP_Send 1: %s\n", SDLNet_GetError());
for (i=0;i<5;i++) { // try to recieve an answer within 5 attempts
nrSocketsReady = SDLNet_CheckSockets(socSet, TIMEOUT);
if (nrSocketsReady > 0) {
if (SDLNet_SocketReady(socSet)) {
result = SDLNet_TCP_Recv(tcpsock, buffer, MTU);
if (result <= 0) {
printf("no reply, or reply reception failed\n\r");
}
break;
}
}
else if (nrSocketsReady == -1) {
printf("SDLNet_CheckSockets: %s\n", SDLNet_GetError());
perror("SDLNet_CheckSockets");
}
else
printf("reception attempt #%i failed\n\r",i+1);
}
if (result > 0) {
buffer[result] = '\0';
printf("Received reply: %s\n\r",buffer);
}
}
}
//erase command line
clrCmd(screen, DISPLAY);
// Clean up
SDL_EnableUNICODE(SDL_DISABLE);
TTF_CloseFont(font);
}
static void initialize_application(void)
{
#if defined(__WIN32__) && defined(__MINGW32__)
if (LoadLibrary("exchndl.dll")) option_debug = true;
#endif
// SDL_putenv(const_cast<char*>("SDL_VIDEO_ALLOW_SCREENSAVER=1"));
// Initialize SDL
int retval = SDL_Init(SDL_INIT_VIDEO |
(option_nosound ? 0 : SDL_INIT_AUDIO) |
(option_nojoystick ? 0 : SDL_INIT_JOYSTICK) |
(option_debug ? SDL_INIT_NOPARACHUTE : 0));
if (retval < 0)
{
const char *sdl_err = SDL_GetError();
if (sdl_err)
fprintf(stderr, "Couldn't initialize SDL (%s)\n", sdl_err);
else
fprintf(stderr, "Couldn't initialize SDL\n");
exit(1);
}
#if defined(HAVE_SDL_IMAGE)
IMG_Init(IMG_INIT_JPG | IMG_INIT_PNG);
#endif
// Find data directories, construct search path
InitDefaultStringSets();
#if defined(unix) || defined(__NetBSD__) || defined(__OpenBSD__) || (defined(__APPLE__) && defined(__MACH__) && !defined(HAVE_BUNDLE_NAME))
default_data_dir = PKGDATADIR;
const char *home = getenv("HOME");
if (home)
local_data_dir = home;
local_data_dir += ".alephone";
log_dir = local_data_dir;
#elif defined(__APPLE__) && defined(__MACH__)
bundle_data_dir = bundle_resource_path;
bundle_data_dir += "DataFiles";
data_search_path.push_back(bundle_data_dir);
#ifndef SCENARIO_IS_BUNDLED
{
char* buf = getcwd(0, 0);
default_data_dir = buf;
free(buf);
}
#endif
log_dir = app_log_directory;
preferences_dir = app_preferences_directory;
local_data_dir = app_support_directory;
#elif defined(__WIN32__)
char file_name[MAX_PATH];
GetModuleFileName(NULL, file_name, sizeof(file_name));
char *sep = strrchr(file_name, '\\');
*sep = '\0';
default_data_dir = file_name;
char login[17];
DWORD len = 17;
bool hasName = (GetUserName((LPSTR) login, &len) == TRUE);
if (!hasName || strpbrk(login, "\\/:*?\"<>|") != NULL)
strcpy(login, "Bob User");
DirectorySpecifier legacy_data_dir = file_name;
legacy_data_dir += "Prefs";
legacy_data_dir += login;
SHGetFolderPath(NULL,
CSIDL_PERSONAL | CSIDL_FLAG_CREATE,
NULL,
0,
file_name);
local_data_dir = file_name;
local_data_dir += "AlephOne";
log_dir = local_data_dir;
#else
default_data_dir = "";
local_data_dir = "";
//#error Data file paths must be set for this platform.
#endif
#if defined(__WIN32__)
#define LIST_SEP ';'
#else
#define LIST_SEP ':'
#endif
// in case we need to redo search path later:
size_t dsp_insert_pos = data_search_path.size();
size_t dsp_delete_pos = (size_t)-1;
if (arg_directory != "")
{
default_data_dir = arg_directory;
dsp_delete_pos = data_search_path.size();
data_search_path.push_back(arg_directory);
}
const char *data_env = getenv("ALEPHONE_DATA");
if (data_env) {
// Read colon-separated list of directories
string path = data_env;
string::size_type pos;
while ((pos = path.find(LIST_SEP)) != string::npos) {
if (pos) {
string element = path.substr(0, pos);
data_search_path.push_back(element);
}
path.erase(0, pos + 1);
}
if (!path.empty())
data_search_path.push_back(path);
} else {
if (arg_directory == "")
{
dsp_delete_pos = data_search_path.size();
data_search_path.push_back(default_data_dir);
}
#if defined(__WIN32__)
data_search_path.push_back(legacy_data_dir);
#endif
data_search_path.push_back(local_data_dir);
}
// Subdirectories
#if defined(__MACH__) && defined(__APPLE__)
DirectorySpecifier legacy_preferences_dir = local_data_dir;
#elif defined(__WIN32__)
DirectorySpecifier legacy_preferences_dir = legacy_data_dir;
SHGetFolderPath(NULL,
CSIDL_LOCAL_APPDATA | CSIDL_FLAG_CREATE,
NULL,
0,
file_name);
preferences_dir = file_name;
preferences_dir += "AlephOne";
#else
preferences_dir = local_data_dir;
#endif
saved_games_dir = local_data_dir + "Saved Games";
quick_saves_dir = local_data_dir + "Quick Saves";
image_cache_dir = local_data_dir + "Image Cache";
recordings_dir = local_data_dir + "Recordings";
screenshots_dir = local_data_dir + "Screenshots";
#if defined(__APPLE__) && defined(__MACH__)
if (app_screenshots_directory)
screenshots_dir = app_screenshots_directory;
#endif
DirectorySpecifier local_mml_dir = local_data_dir + "MML";
DirectorySpecifier local_themes_dir = local_data_dir + "Themes";
// Setup resource manager
initialize_resources();
init_physics_wad_data();
initialize_fonts(false);
load_film_profile(FILM_PROFILE_DEFAULT, false);
// Parse MML files
LoadBaseMMLScripts();
// Check for presence of strings
if (!TS_IsPresent(strERRORS) || !TS_IsPresent(strFILENAMES)) {
fprintf(stderr, "Can't find required text strings (missing MML?).\n");
exit(1);
}
// Check for presence of files (one last chance to change data_search_path)
if (!have_default_files()) {
char chosen_dir[256];
if (alert_choose_scenario(chosen_dir)) {
// remove original argument (or fallback) from search path
if (dsp_delete_pos < data_search_path.size())
data_search_path.erase(data_search_path.begin() + dsp_delete_pos);
// add selected directory where command-line argument would go
data_search_path.insert(data_search_path.begin() + dsp_insert_pos, chosen_dir);
default_data_dir = chosen_dir;
// Parse MML files again, now that we have a new dir to search
initialize_fonts(false);
LoadBaseMMLScripts();
}
}
initialize_fonts(true);
Plugins::instance()->enumerate();
#if defined(__WIN32__) || (defined(__MACH__) && defined(__APPLE__))
preferences_dir.CreateDirectory();
transition_preferences(legacy_preferences_dir);
#endif
// Load preferences
initialize_preferences();
local_data_dir.CreateDirectory();
saved_games_dir.CreateDirectory();
quick_saves_dir.CreateDirectory();
{
std::string scen = Scenario::instance()->GetName();
if (scen.length())
scen.erase(std::remove_if(scen.begin(), scen.end(), char_is_not_filesafe), scen.end());
if (!scen.length())
scen = "Unknown";
quick_saves_dir += scen;
quick_saves_dir.CreateDirectory();
}
image_cache_dir.CreateDirectory();
recordings_dir.CreateDirectory();
screenshots_dir.CreateDirectory();
local_mml_dir.CreateDirectory();
local_themes_dir.CreateDirectory();
WadImageCache::instance()->initialize_cache();
#ifndef HAVE_OPENGL
graphics_preferences->screen_mode.acceleration = _no_acceleration;
#endif
if (force_fullscreen)
graphics_preferences->screen_mode.fullscreen = true;
if (force_windowed) // takes precedence over fullscreen because windowed is safer
graphics_preferences->screen_mode.fullscreen = false;
write_preferences();
Plugins::instance()->load_mml();
// SDL_WM_SetCaption(application_name, application_name);
// #if defined(HAVE_SDL_IMAGE) && !(defined(__APPLE__) && defined(__MACH__))
// SDL_WM_SetIcon(IMG_ReadXPMFromArray(const_cast<char**>(alephone_xpm)), 0);
// #endif
atexit(shutdown_application);
#if !defined(DISABLE_NETWORKING)
// Initialize SDL_net
if (SDLNet_Init () < 0) {
fprintf (stderr, "Couldn't initialize SDL_net (%s)\n", SDLNet_GetError());
exit(1);
}
#endif
if (TTF_Init() < 0) {
fprintf (stderr, "Couldn't initialize SDL_ttf (%s)\n", TTF_GetError());
exit(1);
}
HTTPClient::Init();
// Initialize everything
mytm_initialize();
// initialize_fonts();
SoundManager::instance()->Initialize(*sound_preferences);
initialize_marathon_music_handler();
initialize_keyboard_controller();
initialize_gamma();
alephone::Screen::instance()->Initialize(&graphics_preferences->screen_mode);
initialize_marathon();
initialize_screen_drawing();
initialize_dialogs();
initialize_terminal_manager();
initialize_shape_handler();
initialize_fades();
initialize_images_manager();
load_environment_from_preferences();
initialize_game_state();
}
// =============================================================================
int main(int argc, char **argv){
// === INIT ===
/* Simple parameter checking */
if (argc < 3){
fprintf(stderr, "Usage: %s host port\n", argv[0]);
exit(EXIT_FAILURE);
}
if (SDLNet_Init() < 0){
fprintf(stderr, "SDLNet_Init: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
/* Resolve the host we are connecting to */
if (SDLNet_ResolveHost(&ip, argv[1], atoi(argv[2])) < 0){
fprintf(stderr, "SDLNet_ResolveHost: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
/* Open a connection with the IP provided (listen on the host's port) */
if (!(sd = SDLNet_TCP_Open(&ip))){
fprintf(stderr, "SDLNet_TCP_Open: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
tp=tbuff;
*tp = P_NEW_PLAYER;
tp++;
strncpy((char *) tp, (char *) nick, 31);
printf("tbuff[0]: 0x%X\n",tbuff[0]);
printf("tbuff+1: %s\n", tp);
len = tp - &tbuff[0] +32 ;
SEND;
bzero(tbuff, BUFF_SIZE);
/* Send messages */
// =============================================================================
quit = 2;
while (quit > 0){
//printf("Write something:\n>");
tp=tbuff;
*tp = P_SPEED_UP;
printf("tbuff: 0x%X\n",tbuff[0]);
SEND;
sleep(1);
quit--;
}
tp=rbuff;
RECV;
tp++;
f= *((float *) tp);
printf("rbuff+1: %f ", (double) f);
tp=tbuff;
*tp = P_LOGOUT;
SEND;
SDLNet_TCP_Close(sd);
SDLNet_Quit();
return EXIT_SUCCESS;
}
bool init() {
char* tempchar;
tempchar = (char*)malloc(16*sizeof(char));
GetIP(ETHERNET_INTERFACE,tempchar);
tempchar2 << "CONTROLLER HTTP:// " << tempchar << " : 3000";
tempchar3 << "HELP TEXT HTTP:// " << tempchar << " : " << HELPPORT;
free(tempchar);
if(SDL_Init(SDL_INIT_EVERYTHING) == -1) {
printf("error: SDL failed to intitialize.\n");
return false;
}
// Initialize SDL_net
if(SDLNet_Init()==-1) {
printf("SDLNet_Init: %s\n",SDLNet_GetError());
return false;
}
// Create socketset with enough space allocated for connections
socketSet = SDLNet_AllocSocketSet(MAX_PLAYERS+2);
if(socketSet == NULL) {
printf("Failed to allocate the socket set: %s\n",
SDLNet_GetError());
return false;
} else {
#ifdef PRINT_MESSAGES
printf("Allocated socket set size: %d\n", MAX_PLAYERS+1);
#endif
}
// Setup server
if(SDLNet_ResolveHost(&serverIP,NULL,PORT)==-1) {
printf("SDLNet_ResolveHost: %s\n",SDLNet_GetError());
return false;
}
clientSet = SDLNet_AllocSocketSet(1);
SDLNet_ResolveHost(&servIP, serverName, PORT);
// open the server socket
serverSocket=SDLNet_TCP_Open(&serverIP);
if(!serverSocket) {
printf("SDLNet_TCP_Open: %s\n",SDLNet_GetError());
return false;
}
#ifdef PRINT_MESSAGES
printf("Server socket listening on %d.\n",
SDLNet_Read16(&serverIP.port));
#endif
// Add server socket to socket set
SDLNet_TCP_AddSocket(socketSet, serverSocket);
// Setup help server
if(SDLNet_ResolveHost(&serverIP,NULL,HELPPORT)==-1) {
printf("SDLNet_ResolveHost: %s\n",SDLNet_GetError());
return false;
}
// open the help socket
helpSocket=SDLNet_TCP_Open(&serverIP);
if(!helpSocket) {
printf("SDLNet_TCP_Open: %s\n",SDLNet_GetError());
return false;
}
// Add help socket to socket set
SDLNet_TCP_AddSocket(socketSet, helpSocket);
reply = (char*)malloc(sizeof(char)*1600);
sprintf(reply,"HTTP/1.1 200 OK\n"
"\n"
"Welcome to Tadpole_SDL.\n"
"A game by Dileep V. Reddy.\n"
"Network controller written in collaboration with Wes Erickson.\n"
"The project and license details can be found at:\n"
"https://github.com/dileepvr/Tadpole_SDL\n"
"https://github.com/inflamedspirit/Tadpole_Controller\n\n"
"To join the game using our Javascript controller, simply visit %s:%d.\n\n"
"To write your own custom controller, follow the protocol below:\n\n"
"Tadpole server is listening for connections on port %d.\n"
"To spawn a controllable tadpole,\n\n"
"1. Open a TCP connection to %s:%d\n\n"
"2. If a spot is not available, server sends 'X' and disconnects.\n\n"
"3. If spot is available, server sends 'N'.\n\n"
"4. Respond with desired player name.\n\n"
"5. Server sends \"RGBXXYYZZ\", where \"XXYYZZ\" are the RGB color values in hex (as a string). The Tadpole should be visible on screen.\n\n"
"6. To control Tadpole, send the following characters:\n\n"
"'1' = Up-key-pressed\n"
"'2' = Up-key-released\n"
"'3' = Right-key-pressed\n"
"'4' = Right-key-released\n"
"'5' = Down-key-pressed\n"
"'6' = Down-key-released\n"
"'7' = Left-key-pressed\n"
"'8' = Left-key-released\n\n"
"7. To kill Tadpole, send 'K'. Server replies with 'D'.\n\n"
"8. Everytime Tadpole hitpoints change, server sends \"HXX\", where \"XX\" encodes current hitpoint count.\n\n"
"9. Server sends 'D' and closes connection when Tadpole dies.\n\n"
"10. Server sends 'C' and closes connection when shutting down.\n",tempchar,JAVAPORT,PORT,tempchar,PORT);
screen = SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_SWSURFACE);
hiscore_layer = SDL_CreateRGBSurface(SDL_HWSURFACE, HISCORE_WIDTH, SCREEN_HEIGHT - BANNER_HEIGHT, SCREEN_BPP, 0, 0, 0, 0);
if(screen == NULL) {
printf("error: SDL_SetVideoMode failed.\n");
return false;
}
if( TTF_Init() == -1) {
printf("error: TTF failed to initialize.\n");
return false;
}
#ifdef WITH_SOUND
if ( Mix_OpenAudio( 22050, MIX_DEFAULT_FORMAT, 2, 1024 ) == -1){
printf("error: OpenAudio failed to initialize.\n");
return false;
}
#endif
SDL_WM_SetCaption("Tadpole", NULL);
return true;
}
int sdl_init (void)
{
if (SDL_Init (SDL_INIT_VIDEO) != 0)
{
fprintf(stderr, "SDL_Init: %s\n", SDL_GetError());
return 1;
}
win = SDL_CreateWindow ("Pisound client", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 600, 50, SDL_WINDOW_SHOWN);
if (win == NULL)
{
fprintf (stderr, "Error creating window: %s\n", SDL_GetError());
return 1;
}
ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (ren == NULL)
{
fprintf (stderr, "Error creating renderer: %s\n", SDL_GetError());
return 1;
}
// Initilise networking
if (SDLNet_Init () != 0)
{
fprintf(stderr, "SDLNet_Init: %s\n", SDLNet_GetError());
return 1;
}
socket = SDLNet_UDP_Open (0);
if (!socket)
{
fprintf (stderr, "Error opening socket: %s\n", SDLNet_GetError());
return 1;
}
send_p = SDLNet_AllocPacket (UDP_BUFFLEN);
if (!send_p)
{
fprintf (stderr, "Error allocing send_packet: %s\n", SDLNet_GetError());
running = 0;
return 1;
}
if (SDLNet_ResolveHost (&srvaddr, IP, UDP_PORT))
{
fprintf (stderr, "Error resolving host: %s\n", SDLNet_GetError());
return 1;
}
if (TTF_Init () == -1)
{
fprintf (stderr, "Error initialising TTF library\n");
return 1;
}
font = TTF_OpenFont("data/fonts/Alfphabet-IV.ttf",28);
if (font == NULL)
{
fprintf (stderr, "Error loading font\n");
return 1;
}
return 0;
}
int main(int argsn, char** args) {
if(sizeof(onebyte)!=1) {
fprintf(stderr, "FATAL ERROR: sizeof(onebyte)!=1.\n");
exit(EXIT_FAILURE);
}
if(argsn!=1 && argsn!=3 && argsn!=2 && argsn!=4) {
fprintf(stderr, "usage: %s [server] [screen_width screen_height]\n", args[0]);
exit(EXIT_FAILURE);
}
char server_string[100];
if(argsn>=3) {
if(argsn==4) {
cyberspace_screen_width=atoi(args[2]);
cyberspace_screen_height=atoi(args[3]);
sprintf(server_string, args[1]);
}
else {
cyberspace_screen_width=atoi(args[1]);
cyberspace_screen_height=atoi(args[2]);
sprintf(server_string, CYBERSPACE_SERVER_NAME);
}
}
else {
cyberspace_screen_width=CYBERSPACE_GUI_WIDTH;
cyberspace_screen_height=CYBERSPACE_GUI_HEIGHT;
if(argsn==1) sprintf(server_string, CYBERSPACE_SERVER_NAME);
else sprintf(server_string, args[1]);
}
// printf("server_string=\"%s\"\n", server_string);
cyberspace_textures=new GLuint[CYBERSPACE_GUI_TEXTURES_MAX];
cyberspace_textures_raw=new void*[CYBERSPACE_GUI_TEXTURES_MAX];
FILE* rawfile;
int l;
for(int i=0;i<CYBERSPACE_GUI_TEXTURES_MAX;i++) {
switch(i) {
case CYBERSPACE_GUI_TEXTURE_TILE_32_CAN:
l=32;
rawfile=fopen("img/tile_32_can.raw", "rb");
break;
case CYBERSPACE_GUI_TEXTURE_TILE_32_RADIO:
l=32;
rawfile=fopen("img/tile_32_radio.raw", "rb");
break;
case CYBERSPACE_GUI_TEXTURE_TILE_32_CRYSTAL:
l=32;
rawfile=fopen("img/tile_32_crystal.raw", "rb");
break;
case CYBERSPACE_GUI_TEXTURE_TILE_32_START:
l=32;
rawfile=fopen("img/tile_32_start.raw", "rb");
break;
case CYBERSPACE_GUI_TEXTURE_TILE_32_END:
l=32;
rawfile=fopen("img/tile_32_end.raw", "rb");
break;
case CYBERSPACE_GUI_TEXTURE_TILE_32_FLOOR:
l=32;
rawfile=fopen("img/tile_32_floor.raw", "rb");
break;
case CYBERSPACE_GUI_TEXTURE_TILE_32_CULT_0:
l=32;
rawfile=fopen("img/tile_32_cult0.raw", "rb");
break;
case CYBERSPACE_GUI_TEXTURE_TILES_4X4_64_ICONS:
l=256;
rawfile=fopen("img/tiles_4x4_64_icons.raw", "rb");
break;
/*
case CYBERSPACE_GUI_TEXTURE_TILE_256_SELF:
l=256;
rawfile=fopen("img/self.raw", "rb");
break;
*/
default:
l=32;
rawfile=fopen("img/tile_32_can.raw", "rb");
break;
}
cyberspace_textures_raw[i]=new onebyte[l*l*4];
if(rawfile==NULL) {
fprintf(stderr, "ABORT: fopen raw fails\n");
exit(EXIT_FAILURE);
}
fread(cyberspace_textures_raw[i], l*l*4, 1, rawfile);
fclose(rawfile);
}
for(int x=0;x<4;x++) {
for(int y=0;y<4;y++) {
cyberspace_clips_4x4_64_x[y*4+x][0]=0.25*x;
cyberspace_clips_4x4_64_x[y*4+x][1]=0.25*(x+1);
cyberspace_clips_4x4_64_y[y*4+x][0]=0.25*y;
cyberspace_clips_4x4_64_y[y*4+x][1]=0.25*(y+1);
}
}
printf("neural_connector: init SDL\n");
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTTHREAD)!=0) {
fprintf(stderr, "neural_connector: FATAL ERROR: SDL_Init fails: %s\n", SDL_GetError());
exit(EXIT_FAILURE);
}
if(atexit(SDL_Quit)!=0) {
fprintf(stderr, "neural_connector: FATAL ERROR: couldn't set exit function.\n");
exit(EXIT_FAILURE);
}
if(SDLNet_Init()!=0) {
fprintf(stderr, "neural_connector: FATAL ERROR: SDLNet_Init fails: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
//non serve
/* printf("neural_connector: init SDL_Image\n");
if(IMG_Init(IMG_INIT_PNG)!=IMG_INIT_PNG) {
fprintf(stderr, "neural_connector: FATAL ERROR: IMG_Init fails: %s\n", IMG_GetError());
exit(EXIT_FAILURE);
}*/
//using X mutlithreading
//TODO se abilito SDL con multithread probabilmente non serve
/* if(XInitThreads()==0) {
fprintf(stderr, "FATAL ERROR: XInitThreads fails.\n");
exit(EXIT_FAILURE);
}*/
cyberspace_login_name=new char[100];
cyberspace_login_name[0]='\0';
cyberspace_login_password=new char[100];
cyberspace_login_password[0]='\0';
cyberspace_fps=new char[20];
cyberspace_fps[0]='\0';
cyberspace_chat=new char*[CYBERSPACE_GUI_CHAT_HISTORY];
for(int i=0;i<CYBERSPACE_GUI_CHAT_HISTORY;i++) {
cyberspace_chat[i]=new char[CYBERSPACE_GUI_CHAT_LINE_WIDTH+1+25];
cyberspace_chat[i][0]='\0';
}
cyberspace_chat_input=new char[CYBERSPACE_GUI_CHAT_LINE_WIDTH+1];
cyberspace_chat_input[0]='\0';
cyberspace_server_message=new char[1000];
cyberspace_server_message[0]='\0';
cyberspace_selection_message=new char[1000];
cyberspace_selection_message[0]='\0';
cyberspace_GUI_input_focus=CYBERSPACE_GUI_INPUT_FOCUS_NONE;
cyberspace_personal_data.id_static=-1;
/* pthread_mutexattr_t mutex_attr;
pthread_mutexattr_init(&mutex_attr);
pthread_mutex_init(&cyberspace_mutex_phase, &mutex_attr);
pthread_mutex_init(&cyberspace_mutex_world, &mutex_attr);*/
cyberspace_mutex_phase_sdl=SDL_CreateMutex();
cyberspace_mutex_world_sdl=SDL_CreateMutex();
// pthread_mutex_lock(&cyberspace_mutex_phase);
SDL_mutexP(cyberspace_mutex_phase_sdl);
cyberspace_phase=CYBERSPACE_PHASE_CONNECTING;
SDL_mutexV(cyberspace_mutex_phase_sdl);
// pthread_mutex_unlock(&cyberspace_mutex_phase);
/* pthread_attr_t thread_detached;
pthread_attr_init(&thread_detached);
pthread_attr_setdetachstate(&thread_detached, PTHREAD_CREATE_DETACHED);*/
/* if(pthread_create(&cyberspace_GUI_thread, &thread_detached, cyberspace_GUI_tf, NULL)!=0) {
fprintf(stderr, "FATAL ERROR: GUI thread creation fails.\n");
exit(EXIT_FAILURE);
}*/
cyberspace_GUI_thread_sdl=SDL_CreateThread(cyberspace_GUI_tf_sdl, NULL);
if(cyberspace_GUI_thread_sdl==NULL) {
fprintf(stderr, "FATAL ERROR: GUI thread creation fails: %s.\n", SDL_GetError());
exit(EXIT_FAILURE);
}
// struct timespec tosleep;
// struct timespec tosleepagain;
printf("neural_connector: STARTED\n");
IPaddress server_address;
printf("neural_connector: creating local input socket...\n");
/* if((cyberspace_input_socket_fd=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP))==-1) {
fprintf(stderr, "FATAL ERROR: local input socket creation fails.\n");
exit(EXIT_FAILURE);
}*/
if(SDLNet_ResolveHost(&server_address, server_string, CYBERSPACE_FRONTDOOR_SOCKET_PORT_S2C)!=0) {
fprintf(stderr, "FATAL ERROR: SDLNet_ResolveHost: %s.\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
if((cyberspace_input_socket=SDLNet_TCP_Open(&server_address))==NULL) {
fprintf(stderr, "FATAL ERROR: local input socket creation fails: %s.\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
printf("neural_connector: creating local input socket DONE\n");
int server_code;
printf("neural_connector: receiving server code...\n");
cyberspace_to_read=sizeof(server_code);
if(SDLNet_TCP_Recv(cyberspace_input_socket, cyberspace_read_buffer, cyberspace_to_read)<=0) {
fprintf(stderr, "FATAL ERROR: SDLNet_TCP_Recv: %s.\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
memcpy(&server_code, cyberspace_read_buffer, sizeof(server_code));
printf("neural_connector: server code=%d\n", server_code);
printf("neural_connector: creating local output socket...\n");
/* if((cyberspace_output_socket_fd=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP))==-1) {
fprintf(stderr, "FATAL ERROR: local output socket creation fails.\n");
exit(EXIT_FAILURE);
}*/
if(SDLNet_ResolveHost(&server_address, server_string, CYBERSPACE_FRONTDOOR_SOCKET_PORT_C2S)!=0) {
fprintf(stderr, "FATAL ERROR: SDLNet_ResolveHost: %s.\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
if((cyberspace_output_socket=SDLNet_TCP_Open(&server_address))==NULL) {
fprintf(stderr, "FATAL ERROR: local output socket creation fails: %s.\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
printf("neural_connector: creating local output socket DONE\n");
printf("neural_connector: sending input/output coordination code...\n");
cyberspace_to_write=sizeof(server_code);
memcpy(cyberspace_write_buffer, &server_code, sizeof(server_code));
if(SDLNet_TCP_Send(cyberspace_output_socket, cyberspace_write_buffer, cyberspace_to_write)<cyberspace_to_write) {
fprintf(stderr, "FATAL ERROR: SDLNet_TCP_Send: %s.\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
printf("neural_connector: sending input/output coordination code DONE\n");
/*
int output_remote_socket_fd;
int input_remote_socket_fd;
struct addrinfo sok_addr_info;
struct addrinfo* sok_addr_res;
memset(&sok_addr_info, 0, sizeof(sok_addr_info));
sok_addr_info.ai_family=AF_INET;
sok_addr_info.ai_socktype=SOCK_STREAM;
sok_addr_info.ai_protocol=IPPROTO_TCP;
printf("neural_connector: opening of input connection...\n");
if(getaddrinfo(server_string, CYBERSPACE_FRONTDOOR_SOCKET_PORT_STRING_S2C, &sok_addr_info, &sok_addr_res)) {
fprintf(stderr, "FATAL ERROR: getaddrinfo of server fails.\n");
exit(EXIT_FAILURE);
}
while((input_remote_socket_fd=connect(cyberspace_input_socket_fd, sok_addr_res->ai_addr, sok_addr_res->ai_addrlen))!=0) {
printf("neural_connector: connecting input... (%d)\n", input_remote_socket_fd);
tosleep.tv_sec=5;
tosleep.tv_nsec=0;
while(nanosleep(&tosleep, &tosleepagain)!=0) {
tosleep=tosleepagain;
}
}
printf("neural_connector: opening of input connection DONE\n");
int server_code;
printf("neural_connector: receiving server code...\n");
cyberspace_to_read=sizeof(server_code);
cyberspace_read_total=0;
while(cyberspace_read_total<cyberspace_to_read) {
cyberspace_read_partial=recv(cyberspace_input_socket_fd, cyberspace_read_buffer+cyberspace_read_total, CYBERSPACE_USER_CONNECTION_READ_BUFFER-1-cyberspace_read_total, 0);
if(cyberspace_read_partial==-1) {
perror("perror: ");
fprintf(stderr, "ERROR: (cyberspace_user_connection) recv failed.\n");
exit(EXIT_FAILURE);
}
cyberspace_read_total+=cyberspace_read_partial;
}
printf("neural_connector: receiving server code DONE \n");
memcpy(&server_code, cyberspace_read_buffer, sizeof(server_code));
printf("neural_connector: server code=%d\n", server_code);
memset(&sok_addr_info, 0, sizeof(sok_addr_info));
sok_addr_info.ai_family=AF_INET;
sok_addr_info.ai_socktype=SOCK_STREAM;
sok_addr_info.ai_protocol=IPPROTO_TCP;
printf("neural_connector: opening of output connection...\n");
if(getaddrinfo(server_string, CYBERSPACE_FRONTDOOR_SOCKET_PORT_STRING_C2S, &sok_addr_info, &sok_addr_res)) {
// if(getaddrinfo("127.1.1.1", CYBERSPACE_FRONTDOOR_SOCKET_PORT_STRING_C2S, &sok_addr_info, &sok_addr_res)) {
fprintf(stderr, "FATAL ERROR: getaddrinfo of server fails.\n");
exit(EXIT_FAILURE);
}
while((output_remote_socket_fd=connect(cyberspace_output_socket_fd, sok_addr_res->ai_addr, sok_addr_res->ai_addrlen))!=0) {
printf("neural_connector: connecting output... (%d)\n", output_remote_socket_fd);
tosleep.tv_sec=5;
tosleep.tv_nsec=0;
while(nanosleep(&tosleep, &tosleepagain)!=0) {
tosleep=tosleepagain;
}
}
printf("neural_connector: opening of output connection DONE\n");
printf("neural_connector: sending input/output coordination code...\n");
cyberspace_to_write=sizeof(server_code);
memcpy(cyberspace_write_buffer, &server_code, sizeof(server_code));
cyberspace_written_total=0;
while(cyberspace_to_write>cyberspace_written_total) {
cyberspace_written_partial=send(cyberspace_output_socket_fd, cyberspace_write_buffer+cyberspace_written_total, cyberspace_to_write-cyberspace_written_total, 0);
if(cyberspace_written_partial==-1) {
perror("perror: ");
fprintf(stderr, "ERROR: (in writing) communication with remote process failed.\n");
exit(EXIT_FAILURE);
}
cyberspace_written_total+=cyberspace_written_partial;
}
printf("neural_connector: sending input/output coordination code DONE\n");
*/
/* if(pthread_create(&cyberspace_input_thread, &thread_detached, cyberspace_neural_connector_input_tf, NULL)!=0) {
fprintf(stderr, "FATAL ERROR: input thread creation fails.\n");
exit(EXIT_FAILURE);
}*/
cyberspace_input_thread_sdl=SDL_CreateThread(cyberspace_neural_connector_input_tf_sdl, NULL);
if(cyberspace_input_thread_sdl==NULL) {
fprintf(stderr, "FATAL ERROR: GUI thread creation fails: %s.\n", SDL_GetError());
exit(EXIT_FAILURE);
}
int command_code;
cyberspace_to_end=false;
while(!cyberspace_to_end) {
printf("invia un comando\n");
printf("\t0\tclose connection\n");
scanf("%d", &command_code);
cyberspace_output_command.type=command_code;
/* data->out_command.type=CYBERSPACE_COMMAND_SERVER_ERROR;
data->out_command.include_data_s=true;
data->out_command.include_data_m=false;
data->out_command.include_data_l=false;
char* errormessage=new char[CYBERSPACE_COMMAND_SIZE_S];
sprintf(errormessage, "unexpected message in login");
memcpy(data->out_command.data_s, errormessage, strlen(errormessage)+1);
delete[] errormessage;
cyberspace_user_connection_output(data, &(data->out_command));*/
// cyberspace_neural_connector_output(&cyberspace_output_command);
printf("message NOT sent\n");
}
SDL_WaitThread(cyberspace_GUI_thread_sdl, NULL);
SDL_WaitThread(cyberspace_input_thread_sdl, NULL);
printf("neural_connector: ENDING\n");
// pthread_exit(NULL);
exit(EXIT_SUCCESS);
}
int g_Open( char *file ) {
char c; int i; float f;
float screenfactor;
unsigned long x, y;
FILE *fp;
char name[32];
char valid_data[10];
Mix_Chunk *psize;
gameloop = 1;
hx=xres>>1; hy=yres>>1; hz = hx;
screenfactor = ((float)(xres))/320.0;
//SDL_Rect src, dest;
//src.x=0; dest.x=0;
//src.y=0; dest.y=0;
//src.w=1280*screenfactor; dest.w=0;
//src.h=468*screenfactor; dest.h=0;
// allocate memory for tables
zbuffer = (float *) malloc(sizeof(f)*yres*xres);
floorbuffer = (int *) malloc(sizeof(i)*yres*xres*2);
floorbuffer_s = (int *) malloc(sizeof(i)*yres*xres*2);
rowbuffer = (char *) malloc(sizeof(c)*yres);
// build some tables
map.loaded = 0;
for( x=0; x<xres; x++ ) {
for( y=0; y<yres; y++ ) {
floorbuffer_s[y+x*yres]=16383;
floorbuffer_s[y+x*yres+vidsize]=-1;
}
}
// load general bitmaps
font8_bmp = SDL_LoadBMP("images/8font.bmp");
SDL_SetColorKey( font8_bmp, SDL_SRCCOLORKEY, SDL_MapRGB( font8_bmp->format, 255, 0, 255 ) );
font16_bmp = SDL_LoadBMP("images/16font.bmp");
SDL_SetColorKey( font16_bmp, SDL_SRCCOLORKEY, SDL_MapRGB( font16_bmp->format, 255, 0, 255 ) );
r_LoadBmp("images/console.bmp", &console_bmp);
// load textures
sky2_bmp = SDL_LoadBMP("images/sky.bmp");
sky_bmp = r_ScaleSurface(sky2_bmp, 1280*screenfactor,468*screenfactor);
//sky_bmp = SDL_CreateRGBSurface(SDL_HWSURFACE,1280*screenfactor,468*screenfactor,32,0,0,0,0);
//SDL_BlitSurface( SPG_Scale( sky2_bmp, screenfactor, screenfactor ), &src, sky_bmp, &dest );
//SDL_BlitSurface( sky2_bmp, &src, sky_bmp, &dest );
//SDL_BlitSurface( sky2_bmp, &src, sky_bmp, &dest );
fp = fopen("images/textures.txt","r");
for( texture_num=0; !feof(fp); texture_num++ ) {
while( fgetc(fp) != '\n' ) if( feof(fp) ) break;
}
fclose(fp);
walltex_bmp = (bitmap_t *) malloc(sizeof(bitmap_t)*texture_num);
fp = fopen("images/textures.txt","r");
for( x=0; !feof(fp); x++ ) {
fscanf(fp,"%s",name); while( fgetc(fp) != '\n' ) if( feof(fp) ) break;
r_LoadBmp(name, &walltex_bmp[x]);
}
fclose(fp);
// load sprites
fp = fopen("images/sprites.txt","r");
for( sprite_num=0; !feof(fp); sprite_num++ ) {
while( fgetc(fp) != '\n' ) if( feof(fp) ) break;
}
fclose(fp);
sprite_bmp = (bitmap_t *) malloc(sizeof(bitmap_t)*sprite_num);
fp = fopen("images/sprites.txt","r");
for( x=0; !feof(fp); x++ ) {
fscanf(fp,"%s",name); while( fgetc(fp) != '\n' ) if( feof(fp) ) break;
r_LoadBmp(name, &sprite_bmp[x]);
}
fclose(fp);
// load weapon bitmaps
r_LoadBmp( "images/pistol1.bmp", &pistol_bmp[0] );
r_LoadBmp( "images/pistol2.bmp", &pistol_bmp[1] );
r_LoadBmp( "images/pistol3.bmp", &pistol_bmp[2] );
r_LoadBmp( "images/pistol4.bmp", &pistol_bmp[3] );
r_LoadBmp( "images/pistol5.bmp", &pistol_bmp[4] );
r_LoadBmp( "images/shotgun1.bmp", &shotgun_bmp[0] );
r_LoadBmp( "images/shotgun3.bmp", &shotgun_bmp[1] );
shotgun_bmp[2] = shotgun_bmp[0];
shotgun_bmp[3] = shotgun_bmp[0];
shotgun_bmp[4] = shotgun_bmp[0];
shotgun_bmp[5] = shotgun_bmp[0];
r_LoadBmp( "images/shotgun4.bmp", &shotgun_bmp[6] );
shotgun_bmp[7] = shotgun_bmp[6];
r_LoadBmp( "images/shotgun5.bmp", &shotgun_bmp[8] );
shotgun_bmp[9] = shotgun_bmp[6];
shotgun_bmp[10] = shotgun_bmp[6];
r_LoadBmp( "images/shotgun2.bmp", &shotgun_bmp[11] ); // swapped with shotgun[1] when needed
// precompute some things
sprsize = 2.45*((double)yres/240);
texsize = 2.5*((double)yres/240);
// load a map
if( strstr(file,".bsm") == NULL )
strcat(file,".bsm");
fp = fopen(file, "rb");
if( fp == NULL ) {
printf( "ERROR: Could not load map file: %s\n\n", file );
g_Close();
exit(15);
}
// validate the file
fread(valid_data, sizeof(char), strlen("BSDLMAP"), fp);
if( strncmp(valid_data,"BSDLMAP",7) || fgetc(fp) != MAPVERSION ) {
printf( "ERROR: Not a valid map file: %s\n\n", file );
fclose(fp);
g_Close();
exit(46);
}
else
map.loaded = 1; // lets the engine know that there's junk to be freed
// header
fread(map.name, sizeof(char), 32, fp); // map name
fread(map.author, sizeof(char), 32, fp); // map author
fread(&map.width, sizeof(int), 1, fp); // map width
fread(&map.height, sizeof(int), 1, fp); // map height
// allocate data
map.floors = (int *) malloc(sizeof(int)*map.width*map.height);
map.floors_tex = (int *) malloc(sizeof(int)*map.width*map.height);
map.floors_tex2 = (int *) malloc(sizeof(int)*map.width*map.height);
map.ceilings = (int *) malloc(sizeof(int)*map.width*map.height);
map.ceilings_tex = (int *) malloc(sizeof(int)*map.width*map.height);
map.ceilings_tex2 = (int *) malloc(sizeof(int)*map.width*map.height);
// map data
fread(map.floors, sizeof(int), map.width*map.height, fp); // floor height
fread(map.floors_tex, sizeof(int), map.width*map.height, fp); // lower wall texture
fread(map.floors_tex2, sizeof(int), map.width*map.height, fp); // floor texture
fread(map.ceilings, sizeof(int), map.width*map.height, fp); // ceiling height
fread(map.ceilings_tex, sizeof(int), map.width*map.height, fp); // upper wall texture
fread(map.ceilings_tex2, sizeof(int), map.width*map.height, fp); // ceiling texture
// close the file
fclose(fp);
// spawn the player
if( !server ) {
e_CreateEntity();
player = lastentity;
player->behavior = &e_ActPlayer;
player->sizex = .5;
player->sizey = .5;
player->sizez = 52;
player->x=2.5;
player->y=2.5;
player->z=0;
player->ang=0;
}
vang=0;
bob1 = 0; bob2 = 0; bob3 = 1;
weap_mag[2]=2;
// set camera
camx=8;
camy=2.5;
camz=0;
camang=0;
// initiate SDL
if( SDL_Init( SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER ) == -1 ) {
printf("ERROR: Could not initialize SDL. Aborting...\n\n");
g_Close();
exit(4);
}
//SDL_WM_GrabInput(SDL_GRAB_ON);
// open audio
if(Mix_OpenAudio(audio_rate, audio_format, audio_channels, audio_buffers)) {
printf("Unable to open audio!\n");
exit(1);
}
// create a screen surface
screen = SDL_CreateRGBSurface(SDL_HWSURFACE,xres,yres,32,0,0,0,0);
if( !windowed )
screen2 = SDL_SetVideoMode( xres, yres, 32, SDL_HWSURFACE | SDL_FULLSCREEN );
else
screen2 = SDL_SetVideoMode( xres, yres, 32, SDL_HWSURFACE );
if( screen == NULL || screen2 == NULL ) {
printf("ERROR: Could not create video surface. Aborting...\n\n");
g_Close();
exit(5);
}
SDL_WM_SetCaption( "Bubbenstein/SDL\n\n", 0 );
SDL_ShowCursor(SDL_DISABLE);
// reset the clock
ot=SDL_GetTicks();
i_GetFrameRate();
// load sound effects
fp = fopen("sound/sounds.txt","r");
for( sound_num=0; !feof(fp); sound_num++ ) {
while( fgetc(fp) != '\n' ) if( feof(fp) ) break;
}
fclose(fp);
sounds = (Mix_Chunk **) malloc(sizeof(psize)*sound_num);
fp = fopen("sound/sounds.txt","r");
for( x=0; !feof(fp); x++ ) {
fscanf(fp,"%s",name); while( fgetc(fp) != '\n' ) if( feof(fp) ) break;
sounds[x] = Mix_LoadWAV(name);
}
fclose(fp);
// load music
music = Mix_LoadMUS("music/dead.ogg");
Mix_VolumeMusic(64);
//Mix_PlayMusic(music, -1);
musicplaying=0;
// multiplayer
if (SDLNet_Init() < 0) {
g_Close();
printf("ERROR: SDLNet_Init: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
// starting a server
if( server ) {
// listen on the host's port
if( !(sd = SDLNet_UDP_Open(PORT)) ) {
g_Close();
printf("ERROR: SDLNet_UDP_Open: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
// Allocate memory for the packet
if( !(packet = SDLNet_AllocPacket(512)) ) {
printf("ERROR: SDLNet_AllocPacket: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
}
// joining a server
else if( address != NULL ) {
if( !(sd = SDLNet_UDP_Open(0)) ) {
g_Close();
printf("ERROR: SDLNet_UDP_Open: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
if( SDLNet_ResolveHost(&ip, address, PORT) < 0 ) {
printf("ERROR: SDLNet_ResolveHost: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
// Allocate memory for the packet
if( !(packet = SDLNet_AllocPacket(512)) ) {
printf("ERROR: SDLNet_AllocPacket: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
}
// report a success!
if( address == NULL )
i_Message( "Map loaded: %s", file );
else
i_Message( "Map loaded: %s\nConnected to %s", file, address );
return(0);
}
char *rocsmq_error() {
return SDLNet_GetError();
}
void Rekd2D::Core::Game::Run(char* title, unsigned int width, unsigned int height, unsigned int windowWidth, unsigned int windowHeight)
{
SDL_Init(SDL_INIT_EVERYTHING);
InitGL(2, 1);
m_Window = new Window(title, width, height, windowWidth, windowHeight);
int err = glewInit();
if (err != 0) std::cout << "GLEW ERROR " << err << ": " << glewGetErrorString(err) << std::endl;
Init();
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
err = SDLNet_Init();
if (err != 0) std::cout << "SDLNet ERROR " << err << ": " << SDLNet_GetError() << std::endl;
err = IMG_Init(IMG_INIT_JPG | IMG_INIT_PNG | IMG_INIT_TIF);
if (!err) std::cout << "IMG ERROR " << err << ": " << IMG_GetError() << std::endl;
m_Renderer = new Renderer(m_Window);
m_Window->GenerateFramebuffer();
m_PostProcess = new PredefinedShader(
"void main() { gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; gl_TexCoord[0] = gl_MultiTexCoord0; }",
"uniform sampler2D sampler; void main() { gl_FragColor = texture2D(sampler, gl_TexCoord[0].st); }"
);
SDL_StartTextInput();
Load();
Event e;
m_Window->Show();
unsigned int last = 0, delta = 0;
unsigned int now;
MouseState s;
KeyboardState ks;
while (m_Window->Update())
{
m_Window->BindFramebuffer();
now = SDL_GetTicks();
if (now > last)
{
delta = now - last;
last = now;
}
while (m_Window->PollEvent(&e))
{
s = Mouse::GetState();
ks = Keyboard::GetState();
if (e.Type == Enum::EventType::MouseMove)
{
s.X = (int)((e.MouseMove.DestinationX + e.MouseMove.RelativeX) / (float)m_Window->GetWidth() * width);
s.Y = (int)((e.MouseMove.DestinationY + e.MouseMove.RelativeY) / (float)m_Window->GetHeight() * height);
s.RelX = e.MouseMove.RelativeX;
s.RelY = e.MouseMove.RelativeY;
Mouse::SetState(s);
}
else if (e.Type == Enum::EventType::MouseClick)
{
s.X = (int)(e.MouseButton.X / (float)m_Window->GetWidth() * width);
s.Y = (int)(e.MouseButton.Y / (float)m_Window->GetHeight() * height);
if (e.MouseButton.Button < 4)
s.MouseButtons[e.MouseButton.Button] = true;
Mouse::SetState(s);
}
else if (e.Type == Enum::EventType::MouseRelease)
{
s.X = (int)(e.MouseButton.X / (float)m_Window->GetWidth() * width);
s.Y = (int)(e.MouseButton.Y / (float)m_Window->GetHeight() * height);
if (e.MouseButton.Button < 4)
s.MouseButtons[e.MouseButton.Button] = false;
Mouse::SetState(s);
}
else if (e.Type == Enum::EventType::KeyDown)
{
ks.Keys[e.Keyboard.KeyCode] = true;
ks.Mods[e.Keyboard.KeyCode] = e.Keyboard.Modifiers;
Keyboard::SetState(ks);
}
else if (e.Type == Enum::EventType::KeyUp)
{
ks.Keys[e.Keyboard.KeyCode] = false;
ks.Mods[e.Keyboard.KeyCode] = 0;
Keyboard::SetState(ks);
}
else if (e.Type == Enum::EventType::Text)
{
KeyDown(e.Text.Append, e.Text.Text, e.Text.Cursor, e.Text.SelectionLength);
}
}
m_Renderer->Clear(Color(43, 78, 124));
Update(delta);
Render(delta);
m_Window->UnbindFramebuffer();
m_Renderer->Clear(Color(43, 78, 124));
glLoadIdentity();
m_PostProcess->Bind();
m_Window->BindScreentex();
glBegin(GL_QUADS);
glTexCoord2f(0, 1);
glVertex2f(0, 0);
glTexCoord2f(1, 1);
glVertex2f(width, 0);
glTexCoord2f(1, 0);
glVertex2f(width, height);
glTexCoord2f(0, 0);
glVertex2f(0, height);
glEnd();
}
Unload();
IMG_Quit();
SDLNet_Quit();
m_Renderer->Dispose();
m_Window->Dispose();
delete m_Window;
delete m_Renderer;
SDL_Quit();
}
void Network::receive()
{
SDLNet_SocketSet set;
if (!(set = SDLNet_AllocSocketSet(1)))
{
setError("Error in SDLNet_AllocSocketSet(): " +
std::string(SDLNet_GetError()));
return;
}
if (SDLNet_TCP_AddSocket(set, mSocket) == -1)
{
setError("Error in SDLNet_AddSocket(): " +
std::string(SDLNet_GetError()));
}
while (mState == CONNECTED)
{
// TODO Try to get this to block all the time while still being able
// to escape the loop
int numReady = SDLNet_CheckSockets(set, (static_cast<uint32_t>(500)));
int ret;
switch (numReady)
{
case -1:
logger->log1("Error: SDLNet_CheckSockets");
// FALLTHROUGH
case 0:
break;
case 1:
// Receive data from the socket
SDL_mutexP(mMutex);
ret = SDLNet_TCP_Recv(mSocket, mInBuffer + mInSize,
BUFFER_SIZE - mInSize);
if (!ret)
{
// We got disconnected
mState = IDLE;
logger->log1("Disconnected.");
}
else if (ret < 0)
{
setError(_("Connection to server terminated. ") +
std::string(SDLNet_GetError()));
}
else
{
// DEBUGLOG("Receive " + toString(ret) + " bytes");
mInSize += ret;
if (mToSkip)
{
if (mInSize >= mToSkip)
{
mInSize -= mToSkip;
memmove(mInBuffer, mInBuffer + mToSkip, mInSize);
mToSkip = 0;
}
else
{
mToSkip -= mInSize;
mInSize = 0;
}
}
}
SDL_mutexV(mMutex);
break;
default:
// more than one socket is ready..
// this should not happen since we only listen once socket.
std::stringstream errorStream;
errorStream << "Error in SDLNet_TCP_Recv(), " << numReady
<< " sockets are ready: " << SDLNet_GetError();
setError(errorStream.str());
break;
}
}
if (SDLNet_TCP_DelSocket(set, mSocket) == -1)
logger->log("Error in SDLNet_DelSocket(): %s", SDLNet_GetError());
SDLNet_FreeSocketSet(set);
}
int main( int argc, char * argv[] ) {
IDCounter = 0;
unsigned char consoleWidth = 60;
for (Uint8 k = 0; k < 10; k++) {
const char * newName = GenerateName();
if ( strlen (newName) > consoleWidth ) {
consoleWidth = 80;
printf("\n");
}
consoleWidth -= strlen (newName);
printf( "%s ", newName );
}
printf( "\n" );
printf( "Initializing SDL system... " );
if(SDL_Init(SDL_INIT_EVERYTHING) == -1) {printf("\nSDL_Init: %s\n", SDL_GetError());exit(1); }
if(SDLNet_Init() == -1 ) {printf("\nSDLNet_Init: %s\n", SDLNet_GetError());exit(2);}
printf( "ok.\n" );
printf( "Starting server...\n" );
//
//
if( SDLNet_ResolveHost(&ip, NULL, 3879) < 0 ) {
printf( "\nSDLNet_ResolveHost: %s\n", SDLNet_GetError());
exit(1);
} else {
//ip.host = convFromIP(127,0,0,1);
ip.port = 3879;
printf( "Resolved address: %s\n", getStringAddress(ip));
}
socket = SDLNet_TCP_Open( &ip );
if(!socket ) {
printf( "\nSDLNet_TCP_Open: %s\n", SDLNet_GetError());
exit(2);
}
printf( "ok.\n");
SDLNet_TCP_AddSocket( socketSet, socket );
printf("Waiting for clients...\n");
acceptClientThread = SDL_CreateThread(clientNetLoop, NULL);
updateLoopThread = SDL_CreateThread(updateLoop, NULL);
char instr = 0;
for(;;) {
scanf("%c", &instr);
if (instr == 'q')
break;
if (instr == 'a') {
send(&lastSocket, 'm', "yopt", 4);
}
if (instr == 'b') {
char * broadcastMsg = (char*)malloc(255);
broadcastMsg[0] = 1;
broadcastMsg[1] = 0;
scanf("%[' 'A-z'\'''!'-'+']s", broadcastMsg);
broadcast('m', broadcastMsg, strlen(broadcastMsg));
}
if (instr == 'w') {
printf("startPos: %i; recvSize: %i\n", clients[0]->startPos, clients[0]->recvSize);
for (unsigned char i = 0; i < clients[i]->recvSize; i++) {
if ( clients[0]->msg[i] != '\n'
&& clients[0]->msg[i] != 10)
printf("%3i\'%c\'; ", (unsigned char)clients[0]->msg[i], (unsigned char)clients[0]->msg[i]);
else
printf("%3i\' \'; ", (unsigned char)clients[0]->msg[i]);
}
printf("\n");
}
instr = 0;
}
terminated = true;
printf("Terminated.\n");
int status = 0;
printf("Wait for accepting thread end. ");
SDL_WaitThread(acceptClientThread,&status);
printf("Ended.\nClosing socket. ");
SDLNet_TCP_Close(socket);
printf("Closed.\n");
SDL_Quit();
return 0x127;
}
int
main(int argc, char *argv[])
{
SDL_Window *window;
CLC_CONFIG config;
Uint8 *kbdstate;
SDL_Event e;
PLAYER *me;
PLAYER *player;
Uint32 time;
IPaddress srv_ip;
TCPsocket srv_sock;
Uint16 magic;
int i;
SDLNet_SocketSet srv_sset;
char myname[PNAME_SIZE];
unsigned char myno;
if (SDL_Init(SDL_INIT_TIMER | SDL_INIT_VIDEO | SDL_INIT_EVENTS) == -1)
{
fprintf(stderr, "SDL_Init: %s\n", SDL_GetError());
exit(EXIT_FAILURE);
}
if (SDLNet_Init() == -1)
{
fprintf(stderr, "SDLNet_Init: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
parsecfg(&config);
/*
* Get player name.
*/
printf("Wow such name: ");
fgets(myname, PNAME_SIZE, stdin);
for (i = 0; i < PNAME_SIZE; i++)
{
if (myname[i] == '\n')
{
myname[i] = '\0';
break;
}
}
/*
* Connect to server!
*/
if (SDLNet_ResolveHost(&srv_ip, config.defaultsrv,
atoi(config.defaultport)))
{
fprintf(stderr, "SDLNet_ResolveHost: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
/*
* Bind socket!
*/
if (!(srv_sock = SDLNet_TCP_Open(&srv_ip)))
{
fprintf(stderr, "SDLNet_TCP_Open: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
/*
* Add (a single) server socket to srv_sset for cheap hack for checking
* the server socket's state.
*/
srv_sset = SDLNet_AllocSocketSet(1);
if (!srv_sset)
{
printf("SDLNet_AllocSocketSet: %s\n", SDLNet_GetError());
exit(EXIT_FAILURE);
}
SDLNet_TCP_AddSocket(srv_sset, srv_sock);
/*
* Get maze, add connecting players to buffer and wait until the game
* begins.
*/
getmaze(srv_sock);
window = SDL_CreateWindow(
"MAZE OF TORMENT",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
config.win_width,
config.win_height,
config.win_flags
);
SDL_GetWindowSize(window, &config.win_width, &config.win_height);
if (window == NULL)
{
fprintf(stderr, "Could not create window: %s\n",
SDL_GetError());
exit(EXIT_FAILURE);
}
renderer = SDL_CreateRenderer(window, -1, config.renderflags);
hsprite = loadPic("img/predator.gif");
psprite = loadPic("img/prey.gif");
black = loadPic("img/black.gif");
/*
* Initialize maze, and send player name.
*/
MAZE.X = (config.win_width - MAZE.w * 16) / 2;
MAZE.Y = (config.win_height - MAZE.h * 16) / 2;
SDLNet_TCP_Send(srv_sock, myname, PNAME_SIZE);
/*
* Initialize maze and get the LOCAL player, then the REMOTE players.
*/
SDLNet_TCP_Recv(srv_sock, &myno, 1);
player = calloc(1, sizeof(PLAYER));
if (!((magic = getshort(srv_sock)) == ADD_PLAYER))
{
printf("server not sending players\n!");
exit(EXIT_FAILURE);
}
unsigned char hunter = addp(player, srv_sock);
choose_hunter(player, hunter);
me = choose_player(player, myno);
SDL_SetRenderDrawColor(renderer, 0, 255, 255, 255);
draw_maze(MAZE.X, MAZE.Y);
PLAYER *temp;
for (temp = player->next; temp != NULL; temp = temp->next)
{
printf("drew player %d\n", temp->playerno);
drawPlayer(temp);
}
printf("starting game!!\n");
/*
* Game loop!
*/
for (;;)
{
time = SDL_GetTicks();
/*
* Poll the network in each frame. Because.
*/
int result, numready = SDLNet_CheckSockets(srv_sset, 0);
if (numready == -1)
{
printf("SDLNet_CheckSockets: %s\n", SDLNet_GetError());
perror("SDLNet_CheckSockets");
}
else if (numready)
{
unsigned char packet;
unsigned char pnum, movx, movy;
printf("srv socket is ready!!\n");
if ((result = SDLNet_TCP_Recv(srv_sock, &packet, 2)) == 2)
{
switch (SDLNet_Read16(&packet))
{
case PLAYER_MOV:
puts("PLAYER_MOV");
pnum = getshort(srv_sock);
movx = getshort(srv_sock);
movy = getshort(srv_sock);
printf("player %d moved to (%d,%d)\n",
pnum, movx, movy);
movePlayer(choose_player(player,pnum), movx, movy);
break;
case PLAYER_WIN:
puts("PLAYER_WIN");
break;
case PLAYER_DC:
puts("PLAYER_DC");
pnum = getshort(srv_sock);
printf("Player %d disconnected!!\n", pnum);
removep(choose_player(player,pnum));
break;
case PLAYER_DIE:
puts("PLAYER_DIE");
pnum = getshort(srv_sock);
if (pnum == myno)
{
puts("YOU ARE DEAD\nGAME OVER");
goto exit;
}
printf("Player %d deaded!!!!!\n", pnum);
removep(choose_player(player, pnum));
break;
}
}
else if (result <= 0)
{
fprintf(stderr, "SDLNet_TCP_Recv: %s\n", SDLNet_GetError());
fprintf(stderr, "Lost connection to the server?\n");
break;
}
}
/*
* Poll for keys
*/
if (SDL_PollEvent(&e))
{
if (e.type == SDL_QUIT)
{
break;
}
kbdstate = (Uint8 *) SDL_GetKeyboardState(NULL);
if (kbdstate[SDL_SCANCODE_Q])
{
break;
}
local_player_update(srv_sock, me, player, SDL_GetKeyboardState(NULL));
}
SDL_SetRenderDrawColor(renderer, 0, 255, 255, 255);
SDL_RenderPresent(renderer);
if (20 > (SDL_GetTicks() - time))
{
SDL_Delay(20 - (SDL_GetTicks() - time));
}
}
exit:
SDL_DestroyTexture(psprite.texture);
SDL_DestroyTexture(hsprite.texture);
SDL_DestroyTexture(black.texture);
free(player);
free(MAZE.data);
SDL_DestroyWindow(window);
SDLNet_Quit();
SDL_Quit();
return 0;
}
int main(int argc, char *argv[])
{
if(argc != 4)
{
printf("Please run bot as such:\nDnDRollBot Server IP Nick\n\n");
return(1);
}
SDLNet_SocketSet set;
IPaddress ip;
TCPsocket TCPsock;
char *inbuffer = new char[1024], *buffer = new char[1024], *words[256] = {0}, *channels[16] = {0};
char temp = '\0', *ptmp = 0;
int inbufferpos = 0, x = 0, wordc = 0, chanc = 0, nd = 0, vd = 0;
bool Done = false, LineReady = false, DoneParsing = false;
srand((unsigned int)time(NULL));
if(SDL_Init(0) == -1)
{
printf("SDL_Init: %s\n", SDL_GetError());
CLEANUP();
return(2);
}
if(SDLNet_Init() == -1)
{
printf("SDLNet_Init: %s\n", SDLNet_GetError());
CLEANUP();
return(3);
}
set = SDLNet_AllocSocketSet(1);
if(!set)
{
printf("SDLNet_AllocSocketSet: %s\n", SDLNet_GetError());
CLEANUP();
return(4);
}
printf("SDL and SDL_net initiated successfully, resolving server...\n");
if(SDLNet_ResolveHost(&ip, argv[1], atoi(argv[2])) == -1)
{
printf("SDLNet_ResolveHost: %s\n", SDLNet_GetError());
CLEANUP();
return(5);
}
printf("Host resolved, attempting to connect...\n");
TCPsock = SDLNet_TCP_Open(&ip);
if(!TCPsock)
{
printf("SDLNet_TCP_Open: %s\n", SDLNet_GetError());
CLEANUP();
return(6);
}
printf("Connected to host, handshaking...\n");
sprintf(buffer, "NICK %s\n", argv[3]);
SDLNet_TCP_Send(TCPsock, buffer, strlen(buffer));
sprintf(buffer, "USER DnD 0 DnD :DnDRollBot\n");
SDLNet_TCP_Send(TCPsock, buffer, strlen(buffer));
while(!Done)
{
while(!LineReady)
{
if(SDLNet_TCP_Recv(TCPsock, &temp, 1) <= 0)
{
printf("SDLNet_TCP_Recv: %s\n", SDLNet_GetError());
SDLNet_TCP_Close(TCPsock);
CLEANUP();
return(0);
}
inbuffer[inbufferpos] = temp;
if(inbuffer[inbufferpos] == '\n')
{
LineReady = true;
inbuffer[++inbufferpos] = '\0';
}
else
{
inbufferpos++;
}
if(inbufferpos >= 1020)
{
inbuffer[inbufferpos] = '\n';
inbuffer[++inbufferpos] = '\0';
LineReady = true;
}
}
TrimBlanks(inbuffer);
wordc = 0;
printf("%s", inbuffer);
//thanks again Hero, this is damn clever
words[wordc++] = inbuffer;
while(inbuffer[x] != '\0')
{
if(inbuffer[x] == ' ')
{
inbuffer[x] = '\0';
words[wordc++] = &inbuffer[++x];
continue;
}
x++;
}
//Do some fun parsing
if(!strcasecmp(words[0], "PING"))
{
sprintf(buffer, "PONG %s", words[1]);
SDLNet_TCP_Send(TCPsock, buffer, strlen(buffer));
}
if(!strcasecmp(words[1], "PRIVMSG"))
{
if(!strcasecmp(words[3] + 1, "!JOIN"))
{
ptmp = GrabAfter(words[4], wordc - 4);
sprintf(buffer, "JOIN %s\n", ptmp);
delete [] ptmp;
ptmp = 0;
SDLNet_TCP_Send(TCPsock, buffer, strlen(buffer));
}
if(!strcasecmp(words[3] + 1, "!PART"))
{
ptmp = GrabAfter(words[4], wordc - 4);
sprintf(buffer, "PART %s :%s\n", words[4], ptmp);
delete [] ptmp;
ptmp = 0;
SDLNet_TCP_Send(TCPsock, buffer, strlen(buffer));
}
if(!strcasecmp(words[3] + 1, "!QUIT"))
{
ptmp = GrabAfter(words[4], wordc - 4);
sprintf(buffer, "QUIT :%s\n", ptmp);
delete [] ptmp;
ptmp = 0;
SDLNet_TCP_Send(TCPsock, buffer, strlen(buffer));
Done = true;
}
if(!strcasecmp(words[3] + 1, "\001ACTION") && !strcasecmp(words[4], "slaps") && !strcasecmp(words[5], argv[3]))
{
strcpy(buffer, "QUIT :Ouch!\n");
SDLNet_TCP_Send(TCPsock, buffer, strlen(buffer));
Done = true;
}
if(!strcasecmp(words[3] + 1, "!ROLL"))
{
ptmp = strchr(words[4], 'd');
if(!ptmp || !atoi(words[4]))
{
sprintf(buffer, "PRIVMSG %s :#d# is proper format!\n", words[2]);
SDLNet_TCP_Send(TCPsock, buffer, strlen(buffer));
for(x = 0; x <= wordc; x++)
{
words[x] = 0;
}
LineReady = DoneParsing = false;
wordc = x = inbufferpos = 0;
continue;
}
*ptmp = '\0';
ptmp++;
nd = atoi(words[4]);
vd = atoi(ptmp);
if(nd == 0 || vd == 0)
{
sprintf(buffer, "PRIVMSG %s :#d# is proper format!\n", words[2]);
SDLNet_TCP_Send(TCPsock, buffer, strlen(buffer));
for(x = 0; x <= wordc; x++)
{
words[x] = 0;
}
LineReady = DoneParsing = false;
wordc = x = inbufferpos = 0;
continue;
}
ptmp--;
*ptmp = 'd';
ptmp = 0;
sprintf(buffer, "PRIVMSG %s :Rolled a %d!\n", words[2], Roll(nd, vd));
SDLNet_TCP_Send(TCPsock, buffer, strlen(buffer));
}
}
for(x = 0; x <= wordc; x++)
{
words[x] = 0;
}
LineReady = DoneParsing = false;
wordc = x = inbufferpos = 0;
}
sprintf(buffer, "QUIT\n");
SDLNet_TCP_Send(TCPsock, buffer, strlen(buffer));
SDLNet_TCP_Close(TCPsock);
CLEANUP();
return(0);
}
