Daodan/MSVC/Flatline_Server.c

#include "Flatline.h"
#include "Flatline_Server.h"
#include <Windows.h>
#include "PortForwardWrapper.h"
#include "Mariusnet_Public.h"
//I hereby apologize for the uglyness of the below code. 
//It was never intended to be "final" code, much less shared with anyone

int total_players = 0;
uint16_t max_connections = MAX_CONNECTIONS;

player_info* FLrServer_AddPlayer(int ip, char* name, bool is_server, bool is_bot) {
        flatline_packet new_char = {0};
        CharacterObject* Char;
        uint32_t player_slot = 0;
        int playerlist_slot = 0;
        
        if(is_server || total_players < max_connections) {
                
                int i = 0;
                int k = 0;

                //Skip for the host
                if(!is_server)
                {
                        char* zero = strchr(name, 0);
                        playerlist_slot = FLr_FindEmptyListSlot();

                        total_players++;

                        //checks to see if a name exists or not
                        //then appends [#] on the end of it if it does
                        //May be buggy, come back to this.
                        if(zero - name > 28) zero = name + 28; 
                        for(i = 0; i < max_connections; i++) {
                                if(PlayerList[i] != 0 && !strcmp(name, PlayerList[i]->name)) {
                                        k++;                            
                                        sprintf(zero, "[%i]", k);
                                        i = 0;
                                }
                        }
                }
                
                new_char.new_player.Playernumber = playerlist_slot; 

                //Set up a new Character structure to be spawned as the new player.
                //Can this code be surrounded with if(!is_server){}?
                Char = &new_char.new_player.Character;
                memset(Char, 0, sizeof(CharacterObject));
                Char->Header.Type = 'CHAR';
                sprintf(Char->OSD.Name,"%s",name);
                sprintf(Char->OSD.Class, "%s", "konoko_generic");
                if(is_bot) {
                        Char->OSD.MeleeID = 22;
                        Char->OSD.JobID = 1;
                        Char->OSD.MinimalAlertLevel = 4;
                        Char->OSD.InvestigatingAlertLevel = 4;
                        Char->OSD.InitialAlertLevel = 4;
                        Char->OSD.StartJobAlertLevel = 4;
                }
                else if( !is_server )
                {
                        Char->Header.Position.X = PlayerList[0]->Chr->Position.X;
                        Char->Header.Position.Y = PlayerList[0]->Chr->Position.Y;
                        Char->Header.Position.Z = PlayerList[0]->Chr->Position.Z;
                }
                
                //TMrInstance_GetDataPtr('ONCC', "striker_easy_1", PlayerList[playerlist_slot]->Chr->ONCC);

                new_char.id = NEW_PLAYER;
                if(!is_server) { 
                        ONrGameState_NewCharacter(Char, NULL, NULL, &(player_slot));
                        //move this to a set up characters function...
                        if(!is_bot) ONgGameState->CharacterStorage[player_slot].charType = 0;

                        PlayerList[playerlist_slot] = Players+player_slot;
                        PlayerList[playerlist_slot]->spawnnumber = player_slot;
                        PlayerList[playerlist_slot]->Chr = &(ONgGameState->CharacterStorage)[player_slot];
                        //PlayerList[playerlist_slot]->Chr->Flags = chr_dontaim | chr_unkillable; //&= 0xFFBFFFFF; //WTF
                        if(!is_bot) PlayerList[playerlist_slot]->Chr->Flags &= 0xFFBFFFFF; //WTF, magic number. 
                        sprintf_s(PlayerList[playerlist_slot]->Chr->Name, 32, "%s", name);              
                        sprintf_s(PlayerList[playerlist_slot]->name, 32, "%s", name);           
                        UDPServer_SendToAll( (char*)&new_char, sizeof(new_player) + FLATLINE_HEADER );
                        
                }
                else {
                        PlayerList[0] = Players;
                        PlayerList[0]->Chr = (Character *)(((GameState * )(ONgGameState))->CharacterStorage);
                }

                //add player to list
                
                PlayerList[playerlist_slot]->ip = ip;
                PlayerList[playerlist_slot]->list_slot = playerlist_slot;
                sprintf_s(PlayerList[playerlist_slot]->name, 32, "%s", name);           
                
                MultiplayerStatus.PleaseUpdateAllPlayers = 1;

                return &Players[player_slot];
        }
        return (player_info*)(-1);
}

void FLrServer_Initialize(){
        FLrServer_AddPlayer(inet_addr("127.0.0.1"), "host", 1, 0);
}

//UDPServer_SendToAll
//Sends a packet to all the clients currently connected.
//Returns the number of players sent to.
int UDPServer_SendToAll(void* packet, int size) {
        int j;
        int players = 0;
        sockaddr_in address;
        memset(&address, 0, sizeof(sockaddr_in)); 
        address.sin_family = AF_INET;
        address.sin_addr.s_addr = htonl(INADDR_ANY);
        address.sin_port = htons(27777);
        for(j = 0; j < max_connections; j++) {
                if (PlayerList[j] != 0 && PlayerList[j]->ip && (PlayerList[j]->ip != inet_addr("127.0.0.1"))) {
                        int sent_bytes;
                        address.sin_addr.s_addr = htonl(PlayerList[j]->ip);//*((struct in_addr*)(int*)&(Players[j].ip));                
                        sent_bytes = NetUDPServer_Send((sockaddr *) &address, (char*)packet, size);
                        if(sent_bytes == SOCKET_ERROR) NetCatchError();
                        else players++;
                }
        }
        return players;
}

//FLsPublic_Event
//Sends an event (door opening, player disconnecting, etc) to all players
//Always make sure you send a pointer to this, even if it is just one arg. ;).
//If it is void the double door in State crashes. Probably stack corruption,
//I'm not sure exactly why.
//So we return 0 to stop that.
int FLsPublic_Event( const unsigned int eventIndex, const int * args )
{
        int numArgs = FLrEvent_GetNumArgs( eventIndex );
        int ret;
        flatline_packet eventPacket = {0};
        eventPacket.id = FLATLINE_EVENT;
        eventPacket.flatline_event.event_index = eventIndex;
        ret = memcpy( eventPacket.flatline_event.intArray, args, sizeof(int) * numArgs );
        ret = UDPServer_SendToAll( &eventPacket, sizeof(int) * (numArgs + 1) + FLATLINE_HEADER );
        return 0;
}

void FLsPingAll()
{
        flatline_packet ping;
        ping.id = PK_PING;
        lastPingTime = ping.ping = GetTickCount();
        UDPServer_SendToAll(&ping, FLATLINE_HEADER + 4);
}

void FLsUpdateName( int index, char* name )
{
        flatline_packet message;
        int message_size;       

        char message_buffer[1024];
        sprintf(message_buffer,"%s changed their name to %s", PlayerList[index]->name, name);
        COrMessage_Print(message_buffer, "name_change", 0);
        
        sprintf_s(PlayerList[index]->name, 32, "%s", name);
        sprintf_s(PlayerList[index]->Chr->Name, 32, "%s", name);

        message.id = CHANGE_NAME;
        message.data[0] = index;
        message_size = sprintf(message.data + 1, "%s", name);

        UDPServer_SendToAll(&message, message_size + 2 + FLATLINE_HEADER);
}
void FLsSend_BINACHAR( short j, sockaddr* socket )
{

        ActiveCharacter* AC = ONrGetActiveCharacter( PlayerList[j]->Chr);
        flatline_packet new_char = {0};
        CharacterObject* Char = &new_char.new_player.Character; 

        new_char.id = NEW_PLAYER;
        new_char.new_player.Playernumber = j;

//      memset(Char, 0, sizeof(CharacterObject));
        Char->Header.Type = 'CHAR';
        Char->OSD.Options = chr_dontaim;

        sprintf(Char->OSD.Name,"%s",PlayerList[j]->name);

        sprintf(Char->OSD.Class, "%s", TMrInstance_GetInstanceName(PlayerList[j]->Chr->ONCC));
                
        if(AC && AC->PhyContext)
        {
                Char->Header.Position = AC->PhyContext->Position;
        }
        else
        {
                Char->Header.Position.X = 0;
                Char->Header.Position.Y = 0;
                Char->Header.Position.Z = 0;
        }
        
        NetTCPServer_Send(socket, (char*)&new_char, sizeof(new_player) + FLATLINE_HEADER );
}
bool FLrServer_PacketCallback(char* data, int datalen, int from)
{
        int i, j;
        bool found_player = 0;
        flatline_packet * packet = (flatline_packet*)data;
        static int recieved = 0;
        sockaddr_in sender;
        sender.sin_family = AF_INET;
        sender.sin_port = htons(27777);
        sender.sin_addr = *((struct in_addr*)(int*)&from);


        //packet->data[datalen] = '\0';

        //DDrConsole_PrintF("Packet \r%d recieved from %i",  ++recieved, from);


        //if data[0] != CONNECT_SEND, search in playerlist for ip address


        switch(packet->id) {
                flatline_packet connect_recv;
                player_info * playah;
                //rewrite this when we get TCP support.
                //rewrite this before we get TCP support*
                //the way of seeing if there is room for players sucks.
        case CONNECT_SEND:
                ;

                connect_recv.id = CONNECT_REPLY;

                //if(Players[i].ip == sender.sin_addr.S_un.S_addr) break; //needs to send an error message
                sender.sin_addr.S_un.S_addr = htonl(sender.sin_addr.S_un.S_addr);
                playah = FLrServer_AddPlayer(from,packet->connect_send.name, 0, 0);
                DDrConsole_PrintF("%s connected from %s", packet->connect_send.name, inet_ntoa(sender.sin_addr ) );
                if(!((int)playah > -5 && (int)playah <= 0)) {
                        
                        connect_recv.connect_reply.goodtogo = 1;
                        connect_recv.connect_reply.player_slot = playah->list_slot;
                        //DDrConsole_PrintF("Slot: %i", playah->list_slot);

                        //sending this several times to make sure it gets through. Really need to make up some form of packet tracking.
                        NetUDPServer_Send((sockaddr *) &sender, (char*)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
                        NetUDPServer_Send((sockaddr *) &sender, (char*)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
                        NetUDPServer_Send((sockaddr *) &sender, (char*)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
                        NetUDPServer_Send((sockaddr *) &sender, (char*)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
                        NetUDPServer_Send((sockaddr *) &sender, (char*)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
                        Sleep(100);

                        
                        for(j = 0; j < max_connections; j++) {
                                if(PlayerList[j] != 0) {
                                        FLsSend_BINACHAR( j, (sockaddr *)&sender);
                                }

                        }
                }
                else {
                        //fix the error messages...
                        DDrConsole_PrintF("Server is full. :(");
                        connect_recv.connect_reply.goodtogo = 0;
                        sender.sin_addr.S_un.S_addr = htonl(sender.sin_addr.S_un.S_addr);
                        memcpy(&connect_recv.connect_reply.message,"Server is full.", sizeof("Server is full."));
                        NetTCPServer_Send((sockaddr *) &sender, (char*)&connect_recv, sizeof(bool)*2 + FLATLINE_HEADER + sizeof("Server is full."));    

                } 


                break;
        case CONNECT_REPLY:
                break;  //do nothing...a server shouldn't recieve this type of packet.
        case MESSAGE:
                for(i = 0; i < MAX_PLAYERS; i++) {
                        //DDrConsole_PrintF("%i : %i | %s : %s", from, Players[i].ip, inet_ntoa(*(struct in_addr*)&from), inet_ntoa(*(struct in_addr*)&(Players[i].ip)));
                        if(Players[i].ip == sender.sin_addr.S_un.S_addr) {
                                found_player = 1;
                                break;
                        }       
                }
                if(found_player == 0) break;
                else {
                        char message_buffer[512] = {0};
                        flatline_packet message;
                        int message_size;
                        data[datalen] = 0;

                        DDrConsole_PrintF("%s: %s", Players[i].name, packet->data);
                        sprintf(message_buffer, "%s: %s", Players[i].name, packet->data);

                        message.id = MESSAGE;
                        message_size = sprintf(message.data, "%s", message_buffer);
                        COrMessage_Print(message_buffer, "chat", 0);
                        UDPServer_SendToAll(&message, message_size + 1 + FLATLINE_HEADER);
                        break;
                }
        case CHANGE_NAME:
                for(i = 0; i < MAX_PLAYERS; i++) {
                        if(PlayerList[i] && PlayerList[i]->ip == sender.sin_addr.S_un.S_addr) {
                                found_player = 1;
                                break;
                        }       
                }
                if(found_player == 0) break;
                else {
                        bool name_exists = 0;
                        for(j = 0; j < MAX_PLAYERS; j++) {
                                if(PlayerList[j] && !strcmp(packet->data, PlayerList[j]->name)) {
                                        name_exists = 1;
                                        break;
                                }
                        }
                        if(!name_exists) {
                                FLsUpdateName( i, packet->data );
                        }
                        break;
                }
        case PLAYER_INPUT:

                for(i = 0; i < max_connections; i++) {
                        if(PlayerList[i] != 0 && PlayerList[i]->ip == sender.sin_addr.S_un.S_addr) {
                                found_player = 1;
                                break;
                        }       
                }

                if(found_player == 0) break;
                else {
                        input_struct * packet_input = &packet->input_struct;


                        PlayerList[i]->InputFromClient.Actions1 = packet_input->Actions1;
                        PlayerList[i]->InputFromClient.Actions2 = packet_input->Actions2;
                        PlayerList[i]->InputFromClient.MouseDeltaX = packet_input->MouseDeltaX;
                        PlayerList[i]->InputFromClient.MouseDeltaY = packet_input->MouseDeltaY;
                        PlayerList[i]->FacingFromClient = packet_input->DesiredFacing;
                        //PlayerList[i]->LastInputTime = packet_input->Time;

                        break;
                }
        case PK_PONG:
                for(i = 0; i < max_connections; i++) {
                        if(PlayerList[i] != 0 && PlayerList[i]->ip == sender.sin_addr.S_un.S_addr) {
                                found_player = 1;
                                break;
                        }       
                }

                if(found_player == 0) break;
                if(packet->ping != lastPingTime)
                {
                        PlayerList[i]->Ping = 999;
                }
                else
                {
                        PlayerList[i]->Ping = GetTickCount() - packet->ping;
                }
                break;
        case PK_MISSING_PLAYER:
                if(packet->integer < MAX_PLAYERS)
                {
                        FLsSend_BINACHAR( packet->integer, &sender);
                }
                break;
        default:
                DDrConsole_PrintF("Warning, recieved badly formed packet!");
                break;
        }
        return true;
}


bool FLrServer_Run()
{
        m_announcegame Game;
        HRESULT ret;
        PortMappingContainer_C PMC = 
        {
                "", 
                "27777",
                "27777",
                "UDP",
                "",
                "",
                "Flatline!"
        };
        // Get the local hostname
        char szHostName[255];
        struct hostent *host_entry;
        gethostname(szHostName, 255);

        host_entry=gethostbyname(szHostName);

        strcpy( PMC.InternalClient, inet_ntoa (*(struct in_addr *)*host_entry->h_addr_list) );
        ret = uPnP_Forward( &PMC );
        if(!ret)
        {
                DDrConsole_Print( "Port Forwarded" );
        }
        else
        {
                LPSTR Message;
                FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM, &ret,0,0,&Message,0,NULL);
                DDrConsole_Print( Message );
        }

        DDrConsole_PrintF("Server started at %s...", inet_ntoa (*(struct in_addr *)*host_entry->h_addr_list));

        Game.port = htons(27777);
        sprintf_s(Game.g.Buffer, 128, "%s's Game", MariusLogin);

        MSNet_CreateGame( &Game );

        return NetUDPServer_Listen(27777, FLrServer_PacketCallback);
}
Revision:	589
Committed:	Sat Aug 20 09:47:49 2011 UTC (14 years, 1 month ago) by gumby
Content type:	text/x-csrc
File size:	13102 byte(s)
Log Message:	stuff
#	Content
1	#include "Flatline.h"
2	#include "Flatline_Server.h"
3	#include <Windows.h>
4	#include "PortForwardWrapper.h"
5	#include "Mariusnet_Public.h"
6	//I hereby apologize for the uglyness of the below code.
7	//It was never intended to be "final" code, much less shared with anyone
8
9	int total_players = 0;
10	uint16_t max_connections = MAX_CONNECTIONS;
11
12	player_info* FLrServer_AddPlayer(int ip, char* name, bool is_server, bool is_bot) {
13	flatline_packet new_char = {0};
14	CharacterObject* Char;
15	uint32_t player_slot = 0;
16	int playerlist_slot = 0;
17
18	if(is_server \|\| total_players < max_connections) {
19
20	int i = 0;
21	int k = 0;
22
23	//Skip for the host
24	if(!is_server)
25	{
26	char* zero = strchr(name, 0);
27	playerlist_slot = FLr_FindEmptyListSlot();
28
29	total_players++;
30
31	//checks to see if a name exists or not
32	//then appends [#] on the end of it if it does
33	//May be buggy, come back to this.
34	if(zero - name > 28) zero = name + 28;
35	for(i = 0; i < max_connections; i++) {
36	if(PlayerList[i] != 0 && !strcmp(name, PlayerList[i]->name)) {
37	k++;
38	sprintf(zero, "[%i]", k);
39	i = 0;
40	}
41	}
42	}
43
44	new_char.new_player.Playernumber = playerlist_slot;
45
46	//Set up a new Character structure to be spawned as the new player.
47	//Can this code be surrounded with if(!is_server){}?
48	Char = &new_char.new_player.Character;
49	memset(Char, 0, sizeof(CharacterObject));
50	Char->Header.Type = 'CHAR';
51	sprintf(Char->OSD.Name,"%s",name);
52	sprintf(Char->OSD.Class, "%s", "konoko_generic");
53	if(is_bot) {
54	Char->OSD.MeleeID = 22;
55	Char->OSD.JobID = 1;
56	Char->OSD.MinimalAlertLevel = 4;
57	Char->OSD.InvestigatingAlertLevel = 4;
58	Char->OSD.InitialAlertLevel = 4;
59	Char->OSD.StartJobAlertLevel = 4;
60	}
61	else if( !is_server )
62	{
63	Char->Header.Position.X = PlayerList[0]->Chr->Position.X;
64	Char->Header.Position.Y = PlayerList[0]->Chr->Position.Y;
65	Char->Header.Position.Z = PlayerList[0]->Chr->Position.Z;
66	}
67
68	//TMrInstance_GetDataPtr('ONCC', "striker_easy_1", PlayerList[playerlist_slot]->Chr->ONCC);
69
70	new_char.id = NEW_PLAYER;
71	if(!is_server) {
72	ONrGameState_NewCharacter(Char, NULL, NULL, &(player_slot));
73	//move this to a set up characters function...
74	if(!is_bot) ONgGameState->CharacterStorage[player_slot].charType = 0;
75
76	PlayerList[playerlist_slot] = Players+player_slot;
77	PlayerList[playerlist_slot]->spawnnumber = player_slot;
78	PlayerList[playerlist_slot]->Chr = &(ONgGameState->CharacterStorage)[player_slot];
79	//PlayerList[playerlist_slot]->Chr->Flags = chr_dontaim \| chr_unkillable; //&= 0xFFBFFFFF; //WTF
80	if(!is_bot) PlayerList[playerlist_slot]->Chr->Flags &= 0xFFBFFFFF; //WTF, magic number.
81	sprintf_s(PlayerList[playerlist_slot]->Chr->Name, 32, "%s", name);
82	sprintf_s(PlayerList[playerlist_slot]->name, 32, "%s", name);
83	UDPServer_SendToAll( (char*)&new_char, sizeof(new_player) + FLATLINE_HEADER );
84
85	}
86	else {
87	PlayerList[0] = Players;
88	PlayerList[0]->Chr = (Character )(((GameState )(ONgGameState))->CharacterStorage);
89	}
90
91	//add player to list
92
93	PlayerList[playerlist_slot]->ip = ip;
94	PlayerList[playerlist_slot]->list_slot = playerlist_slot;
95	sprintf_s(PlayerList[playerlist_slot]->name, 32, "%s", name);
96
97	MultiplayerStatus.PleaseUpdateAllPlayers = 1;
98
99	return &Players[player_slot];
100	}
101	return (player_info*)(-1);
102	}
103
104	void FLrServer_Initialize(){
105	FLrServer_AddPlayer(inet_addr("127.0.0.1"), "host", 1, 0);
106	}
107
108	//UDPServer_SendToAll
109	//Sends a packet to all the clients currently connected.
110	//Returns the number of players sent to.
111	int UDPServer_SendToAll(void* packet, int size) {
112	int j;
113	int players = 0;
114	sockaddr_in address;
115	memset(&address, 0, sizeof(sockaddr_in));
116	address.sin_family = AF_INET;
117	address.sin_addr.s_addr = htonl(INADDR_ANY);
118	address.sin_port = htons(27777);
119	for(j = 0; j < max_connections; j++) {
120	if (PlayerList[j] != 0 && PlayerList[j]->ip && (PlayerList[j]->ip != inet_addr("127.0.0.1"))) {
121	int sent_bytes;
122	address.sin_addr.s_addr = htonl(PlayerList[j]->ip);//((struct in_addr)(int*)&(Players[j].ip));
123	sent_bytes = NetUDPServer_Send((sockaddr ) &address, (char)packet, size);
124	if(sent_bytes == SOCKET_ERROR) NetCatchError();
125	else players++;
126	}
127	}
128	return players;
129	}
130
131	//FLsPublic_Event
132	//Sends an event (door opening, player disconnecting, etc) to all players
133	//Always make sure you send a pointer to this, even if it is just one arg. ;).
134	//If it is void the double door in State crashes. Probably stack corruption,
135	//I'm not sure exactly why.
136	//So we return 0 to stop that.
137	int FLsPublic_Event( const unsigned int eventIndex, const int * args )
138	{
139	int numArgs = FLrEvent_GetNumArgs( eventIndex );
140	int ret;
141	flatline_packet eventPacket = {0};
142	eventPacket.id = FLATLINE_EVENT;
143	eventPacket.flatline_event.event_index = eventIndex;
144	ret = memcpy( eventPacket.flatline_event.intArray, args, sizeof(int) * numArgs );
145	ret = UDPServer_SendToAll( &eventPacket, sizeof(int) * (numArgs + 1) + FLATLINE_HEADER );
146	return 0;
147	}
148
149	void FLsPingAll()
150	{
151	flatline_packet ping;
152	ping.id = PK_PING;
153	lastPingTime = ping.ping = GetTickCount();
154	UDPServer_SendToAll(&ping, FLATLINE_HEADER + 4);
155	}
156
157	void FLsUpdateName( int index, char* name )
158	{
159	flatline_packet message;
160	int message_size;
161
162	char message_buffer[1024];
163	sprintf(message_buffer,"%s changed their name to %s", PlayerList[index]->name, name);
164	COrMessage_Print(message_buffer, "name_change", 0);
165
166	sprintf_s(PlayerList[index]->name, 32, "%s", name);
167	sprintf_s(PlayerList[index]->Chr->Name, 32, "%s", name);
168
169	message.id = CHANGE_NAME;
170	message.data[0] = index;
171	message_size = sprintf(message.data + 1, "%s", name);
172
173	UDPServer_SendToAll(&message, message_size + 2 + FLATLINE_HEADER);
174	}
175	void FLsSend_BINACHAR( short j, sockaddr* socket )
176	{
177
178	ActiveCharacter* AC = ONrGetActiveCharacter( PlayerList[j]->Chr);
179	flatline_packet new_char = {0};
180	CharacterObject* Char = &new_char.new_player.Character;
181
182	new_char.id = NEW_PLAYER;
183	new_char.new_player.Playernumber = j;
184
185	// memset(Char, 0, sizeof(CharacterObject));
186	Char->Header.Type = 'CHAR';
187	Char->OSD.Options = chr_dontaim;
188
189	sprintf(Char->OSD.Name,"%s",PlayerList[j]->name);
190
191	sprintf(Char->OSD.Class, "%s", TMrInstance_GetInstanceName(PlayerList[j]->Chr->ONCC));
192
193	if(AC && AC->PhyContext)
194	{
195	Char->Header.Position = AC->PhyContext->Position;
196	}
197	else
198	{
199	Char->Header.Position.X = 0;
200	Char->Header.Position.Y = 0;
201	Char->Header.Position.Z = 0;
202	}
203
204	NetTCPServer_Send(socket, (char*)&new_char, sizeof(new_player) + FLATLINE_HEADER );
205	}
206	bool FLrServer_PacketCallback(char* data, int datalen, int from)
207	{
208	int i, j;
209	bool found_player = 0;
210	flatline_packet * packet = (flatline_packet*)data;
211	static int recieved = 0;
212	sockaddr_in sender;
213	sender.sin_family = AF_INET;
214	sender.sin_port = htons(27777);
215	sender.sin_addr = ((struct in_addr)(int*)&from);
216
217
218	//packet->data[datalen] = '\0';
219
220	//DDrConsole_PrintF("Packet \r%d recieved from %i", ++recieved, from);
221
222
223
224	//if data[0] != CONNECT_SEND, search in playerlist for ip address
225
226
227
228
229	switch(packet->id) {
230	flatline_packet connect_recv;
231	player_info * playah;
232	//rewrite this when we get TCP support.
233	//rewrite this before we get TCP support*
234	//the way of seeing if there is room for players sucks.
235	case CONNECT_SEND:
236	;
237
238	connect_recv.id = CONNECT_REPLY;
239
240	//if(Players[i].ip == sender.sin_addr.S_un.S_addr) break; //needs to send an error message
241	sender.sin_addr.S_un.S_addr = htonl(sender.sin_addr.S_un.S_addr);
242	playah = FLrServer_AddPlayer(from,packet->connect_send.name, 0, 0);
243	DDrConsole_PrintF("%s connected from %s", packet->connect_send.name, inet_ntoa(sender.sin_addr ) );
244	if(!((int)playah > -5 && (int)playah <= 0)) {
245
246	connect_recv.connect_reply.goodtogo = 1;
247	connect_recv.connect_reply.player_slot = playah->list_slot;
248	//DDrConsole_PrintF("Slot: %i", playah->list_slot);
249
250	//sending this several times to make sure it gets through. Really need to make up some form of packet tracking.
251	NetUDPServer_Send((sockaddr ) &sender, (char)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
252	NetUDPServer_Send((sockaddr ) &sender, (char)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
253	NetUDPServer_Send((sockaddr ) &sender, (char)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
254	NetUDPServer_Send((sockaddr ) &sender, (char)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
255	NetUDPServer_Send((sockaddr ) &sender, (char)&connect_recv, sizeof(connect_reply) + FLATLINE_HEADER);
256	Sleep(100);
257
258
259
260	for(j = 0; j < max_connections; j++) {
261	if(PlayerList[j] != 0) {
262	FLsSend_BINACHAR( j, (sockaddr *)&sender);
263	}
264
265	}
266	}
267	else {
268	//fix the error messages...
269	DDrConsole_PrintF("Server is full. :(");
270	connect_recv.connect_reply.goodtogo = 0;
271	sender.sin_addr.S_un.S_addr = htonl(sender.sin_addr.S_un.S_addr);
272	memcpy(&connect_recv.connect_reply.message,"Server is full.", sizeof("Server is full."));
273	NetTCPServer_Send((sockaddr ) &sender, (char)&connect_recv, sizeof(bool)*2 + FLATLINE_HEADER + sizeof("Server is full."));
274
275	}
276
277
278	break;
279	case CONNECT_REPLY:
280	break; //do nothing...a server shouldn't recieve this type of packet.
281	case MESSAGE:
282	for(i = 0; i < MAX_PLAYERS; i++) {
283	//DDrConsole_PrintF("%i : %i \| %s : %s", from, Players[i].ip, inet_ntoa((struct in_addr)&from), inet_ntoa((struct in_addr)&(Players[i].ip)));
284	if(Players[i].ip == sender.sin_addr.S_un.S_addr) {
285	found_player = 1;
286	break;
287	}
288	}
289	if(found_player == 0) break;
290	else {
291	char message_buffer[512] = {0};
292	flatline_packet message;
293	int message_size;
294	data[datalen] = 0;
295
296	DDrConsole_PrintF("%s: %s", Players[i].name, packet->data);
297	sprintf(message_buffer, "%s: %s", Players[i].name, packet->data);
298
299	message.id = MESSAGE;
300	message_size = sprintf(message.data, "%s", message_buffer);
301	COrMessage_Print(message_buffer, "chat", 0);
302	UDPServer_SendToAll(&message, message_size + 1 + FLATLINE_HEADER);
303	break;
304	}
305	case CHANGE_NAME:
306	for(i = 0; i < MAX_PLAYERS; i++) {
307	if(PlayerList[i] && PlayerList[i]->ip == sender.sin_addr.S_un.S_addr) {
308	found_player = 1;
309	break;
310	}
311	}
312	if(found_player == 0) break;
313	else {
314	bool name_exists = 0;
315	for(j = 0; j < MAX_PLAYERS; j++) {
316	if(PlayerList[j] && !strcmp(packet->data, PlayerList[j]->name)) {
317	name_exists = 1;
318	break;
319	}
320	}
321	if(!name_exists) {
322	FLsUpdateName( i, packet->data );
323	}
324	break;
325	}
326	case PLAYER_INPUT:
327
328	for(i = 0; i < max_connections; i++) {
329	if(PlayerList[i] != 0 && PlayerList[i]->ip == sender.sin_addr.S_un.S_addr) {
330	found_player = 1;
331	break;
332	}
333	}
334
335	if(found_player == 0) break;
336	else {
337	input_struct * packet_input = &packet->input_struct;
338
339
340	PlayerList[i]->InputFromClient.Actions1 = packet_input->Actions1;
341	PlayerList[i]->InputFromClient.Actions2 = packet_input->Actions2;
342	PlayerList[i]->InputFromClient.MouseDeltaX = packet_input->MouseDeltaX;
343	PlayerList[i]->InputFromClient.MouseDeltaY = packet_input->MouseDeltaY;
344	PlayerList[i]->FacingFromClient = packet_input->DesiredFacing;
345	//PlayerList[i]->LastInputTime = packet_input->Time;
346
347	break;
348	}
349	case PK_PONG:
350	for(i = 0; i < max_connections; i++) {
351	if(PlayerList[i] != 0 && PlayerList[i]->ip == sender.sin_addr.S_un.S_addr) {
352	found_player = 1;
353	break;
354	}
355	}
356
357	if(found_player == 0) break;
358	if(packet->ping != lastPingTime)
359	{
360	PlayerList[i]->Ping = 999;
361	}
362	else
363	{
364	PlayerList[i]->Ping = GetTickCount() - packet->ping;
365	}
366	break;
367	case PK_MISSING_PLAYER:
368	if(packet->integer < MAX_PLAYERS)
369	{
370	FLsSend_BINACHAR( packet->integer, &sender);
371	}
372	break;
373	default:
374	DDrConsole_PrintF("Warning, recieved badly formed packet!");
375	break;
376	}
377	return true;
378	}
379
380
381
382	bool FLrServer_Run()
383	{
384	m_announcegame Game;
385	HRESULT ret;
386	PortMappingContainer_C PMC =
387	{
388	"",
389	"27777",
390	"27777",
391	"UDP",
392	"",
393	"",
394	"Flatline!"
395	};
396	// Get the local hostname
397	char szHostName[255];
398	struct hostent *host_entry;
399	gethostname(szHostName, 255);
400
401	host_entry=gethostbyname(szHostName);
402
403	strcpy( PMC.InternalClient, inet_ntoa ((struct in_addr )*host_entry->h_addr_list) );
404	ret = uPnP_Forward( &PMC );
405	if(!ret)
406	{
407	DDrConsole_Print( "Port Forwarded" );
408	}
409	else
410	{
411	LPSTR Message;
412	FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER\|FORMAT_MESSAGE_FROM_SYSTEM, &ret,0,0,&Message,0,NULL);
413	DDrConsole_Print( Message );
414	}
415
416	DDrConsole_PrintF("Server started at %s...", inet_ntoa ((struct in_addr )*host_entry->h_addr_list));
417
418	Game.port = htons(27777);
419	sprintf_s(Game.g.Buffer, 128, "%s's Game", MariusLogin);
420
421	MSNet_CreateGame( &Game );
422
423	return NetUDPServer_Listen(27777, FLrServer_PacketCallback);
424	}