Daodan/MSVC/Flatline.h

#pragma once
#ifndef FLATLINE_H
#define FLATLINE_H

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
//#define DDrStartupMessage printf

#include <string.h>
#include "bool.h"
////#include <stdint.h>

#define thread __thread

#include "Flatline_Public.h"

#ifdef WIN32
#include <winsock2.h>
#include "Flatline_Win32.h"
#else
#include <sys/ioctl.h> 
#include <sys/types.h>
#include <sys/socket.h> 
#include <unistd.h> 
#include <stropts.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#define NetPlatform_Initalize() /* */
#define NetPlatform_Shutdown() /* */
#define closesocket close
#define ioctlsocket ioctl
#endif

#include "Daodan.h"
#include "BFW_Utility.h"
#include "Daodan_Console.h"
#include "Oni_Character.h"
#include "Flatline_Packet.h"


//#define breakpoint asm("int3")


#include "Flatline_Net.h"

DWORD WINAPI StartServer(void* lol);
DWORD WINAPI StartClient(void* lol);


//initial connection
typedef struct {
        char country[2];
        char name[256];
} connect_send; //signature="CONNECT\0"

//reply to connection.
//goodtogo is if it is going to let you in
//message is optional, only used for denial message
typedef struct {
        bool goodtogo;
        int player_slot;
        char message[256];
} connect_reply;

//um, status of the server? :/
//probably obsolete. revive again once i do something crazy
//like make a master server
typedef struct {
        char name[256];
        uint32_t numplayers; //signature="STATUS\0\0"
} server_status;

typedef struct {
        uint16_t         Playernumber;
        CharacterObject Character;
} new_player;

//extern int update_rate;

typedef struct {
        float MouseDeltaX;
        float MouseDeltaY;
        uint32_t Actions1;
        uint32_t Actions2;
        float DesiredFacing;
        //unsigned int Time;
} input_struct;

//TODO:
//Varient
//Figure out + fix overlays
//AC->HeadFacing
//AC->HeadPitch
typedef struct {
        uint16_t                                throwing;
        uint16_t                                throwFrame;
        char                                    throwName[32];
} td;
/*
typedef struct {
        uint16_t PlayerNum;
        //Vector3 Position;
        
        //float Facing;
        //float DesiredFacing;

        float UD;
        float LR;

        uint32_t Health;
        uint32_t MaxHealth;
        //input_struct Inputs;
        int rare_sync_index;
        char Animation[32];
        uint16_t Frame;
        td throw_data;
        int Kills;
        int Damage;
        int Deaths;
        uint16_t Ping;

} player_data;

//todo, move health in...
/*typedef struct {
        short unsigned int PlayerNum;
        unsigned int index;
        Inventory Inventory;
        char Class[32];
} rare_sync_data;
*/
typedef struct {
        unsigned int event_index;
        int intArray[];
} flatline_event;
/*
typedef struct {
        int16_t PlayerNum;
        float MouseDeltaX;
        float MouseDeltaY;
        uint32_t Actions1;
        uint32_t Actions2;
        float Facing;
        float DesiredFacing;
        Vector3 Position;
} player_input;
*/
//used for storing data about each player
typedef struct {
        //int   FLATLINE;
        short   signature;
        short   id;
        int             size;
        //int           packet_index;
        union   
        {
                char                    data[1080];
                connect_reply   connect_reply;
                connect_send    connect_send;
                input_struct    input_struct;
                new_player              new_player;
                server_status   server_status;
                //player_data           player_data;
                //rare_sync_data  rare_sync_data;
                uint16_t                sync_request;
                flatline_event  flatline_event;
                uint32_t                ping;
                //player_input  all_input[33];
                uint32_t                integer; //generic integer ;)
        };
} flatline_packet;
#define FLATLINE_HEADER (sizeof(flatline_packet)-sizeof(char)*1080)
//#define FLATLINE_PACKET_SIZE sizeof(flatline_packet) 


bool FLrServer_PacketCallback(char* data, int datalen, int from);
bool FLrServer_Run();
bool FLrClient_Run(flatline_packet* packet);
extern int sock;

enum {
        NULL_PACKET, //Don't use. ;)
        CONNECT_SEND,
        CONNECT_REPLY,
        STATUS,
        MESSAGE,
        CHANGE_NAME,
        ECHO,
        NEW_PLAYER,
        PLAYER_INPUT,
        //PLAYER_DATA,
        //RARE_SYNC_DATA,
        //RARE_SYNC_DATA_REQUEST,
        FLATLINE_EVENT,
        PK_PING,
        PK_PONG,
        //PK_ALL_INPUT,
        PK_PLAYER_DATA,
        PK_MISSING_PLAYER,
};

enum FlatlineEvent {
        EV_RESPAWN,
        EV_KILLED,
        EV_DISCONNECT,
        EV_DOOR_OPEN,
        EV_CONSOLE_USE,
        EV_MAX,
};


typedef struct {
        //Server Only
        bool PleaseUpdateAllPlayers;
        //Client stuff (can be used by server "client")

        //Move from random scattered bools to these, please.
        bool ClientConnected;
        unsigned int ClientSlot;
        bool ServerStatus;
} multiplayer_status;

enum {
        STATE_ALIVE,
        STATE_DEAD,
};
enum {
        PF_HOST,
        PF_BOT,
        PF_SCRIPTEDAI,
};
typedef struct {
        int      ip;
        char name[32]; 
        char country[2];
        Character* Chr;
        uint16_t spawnnumber;
        uint16_t list_slot;

        PlayerInput InputFromClient;
        float FacingFromClient;

        ////////////////////////////
        //Sync stuff
        ////////////////////////////
        uint16_t UpdateFlags;

        PlayerInput Input;
        PlayerHealth Health;
        PlayerFacing Facings;
        PlayerScore Score;
        void* Animation;
        char AnimationString[32];
        uint16_t Frame;
        PlayerThrowData ThrowData;
        void* Class;
        char ClassString[32];
        PlayerInventory Inventory;
        Vector3 Position;
        ////////////////////////////
        bool HasAppliedThrow;

        unsigned int LastInputTime;


        uint16_t state;
        int flags;
        int DeathTime;
        uint32_t Ping;
        bool DataApplied;
        bool NeedToSetFP;
        uint32_t ShapeshiftCooldown;
} player_info;

player_info * FLr_FindEmptySlot();
uint16_t FLr_FindEmptyListSlot();
void * ONICALL FLrInput_Update_Keys(void);

void NetCatchError();
#define MAX_PLAYERS 32
#define CONNECTION_TIMEOUT 15
#define MAX_CONNECTIONS 32
#define NetTCPSocket_Send NetUDPSocket_Send
#define NetTCPServer_Send NetUDPServer_Send
extern int client_sock;
//these two could probably be combined
extern sockaddr_in client_address;
extern sockaddr_in address;
extern player_info Players[];
extern player_info * PlayerList[];
extern multiplayer_status MultiplayerStatus;
int UDPServer_SendToAll(void* packet, int size);


void FLrRun_Scores();
void FLrPlayerDisconnect( int Player );
void FLrPlayerRespawn( int Player );
int FLrEvent_GetNumArgs( int eventIndex );
bool FlatlineInitialize();

bool DoWeUpdateThis( uint16_t BitSet, uint16_t Flag );

extern unsigned int lastPingTime;
#endif
Revision:	589
Committed:	Sat Aug 20 09:47:49 2011 UTC (14 years, 3 months ago) by gumby
Content type:	text/x-chdr
File size:	6155 byte(s)
Log Message:	stuff
#	Content
1	#pragma once
2	#ifndef FLATLINE_H
3	#define FLATLINE_H
4
5	#include <stdlib.h>
6	#include <stdio.h>
7	#include <time.h>
8	//#define DDrStartupMessage printf
9
10	#include <string.h>
11	#include "bool.h"
12	////#include <stdint.h>
13
14	#define thread __thread
15
16	#include "Flatline_Public.h"
17
18	#ifdef WIN32
19	#include <winsock2.h>
20	#include "Flatline_Win32.h"
21	#else
22	#include <sys/ioctl.h>
23	#include <sys/types.h>
24	#include <sys/socket.h>
25	#include <unistd.h>
26	#include <stropts.h>
27	#include <arpa/inet.h>
28	#include <netinet/in.h>
29
30	#define NetPlatform_Initalize() /* */
31	#define NetPlatform_Shutdown() /* */
32	#define closesocket close
33	#define ioctlsocket ioctl
34	#endif
35
36	#include "Daodan.h"
37	#include "BFW_Utility.h"
38	#include "Daodan_Console.h"
39	#include "Oni_Character.h"
40	#include "Flatline_Packet.h"
41
42
43	//#define breakpoint asm("int3")
44
45
46	#include "Flatline_Net.h"
47
48	DWORD WINAPI StartServer(void* lol);
49	DWORD WINAPI StartClient(void* lol);
50
51
52	//initial connection
53	typedef struct {
54	char country[2];
55	char name[256];
56	} connect_send; //signature="CONNECT\0"
57
58	//reply to connection.
59	//goodtogo is if it is going to let you in
60	//message is optional, only used for denial message
61	typedef struct {
62	bool goodtogo;
63	int player_slot;
64	char message[256];
65	} connect_reply;
66
67	//um, status of the server? :/
68	//probably obsolete. revive again once i do something crazy
69	//like make a master server
70	typedef struct {
71	char name[256];
72	uint32_t numplayers; //signature="STATUS\0\0"
73	} server_status;
74
75	typedef struct {
76	uint16_t Playernumber;
77	CharacterObject Character;
78	} new_player;
79
80	//extern int update_rate;
81
82	typedef struct {
83	float MouseDeltaX;
84	float MouseDeltaY;
85	uint32_t Actions1;
86	uint32_t Actions2;
87	float DesiredFacing;
88	//unsigned int Time;
89	} input_struct;
90
91	//TODO:
92	//Varient
93	//Figure out + fix overlays
94	//AC->HeadFacing
95	//AC->HeadPitch
96	typedef struct {
97	uint16_t throwing;
98	uint16_t throwFrame;
99	char throwName[32];
100	} td;
101	/*
102	typedef struct {
103	uint16_t PlayerNum;
104	//Vector3 Position;
105
106	//float Facing;
107	//float DesiredFacing;
108
109	float UD;
110	float LR;
111
112	uint32_t Health;
113	uint32_t MaxHealth;
114	//input_struct Inputs;
115	int rare_sync_index;
116	char Animation[32];
117	uint16_t Frame;
118	td throw_data;
119	int Kills;
120	int Damage;
121	int Deaths;
122	uint16_t Ping;
123
124	} player_data;
125
126	//todo, move health in...
127	/*typedef struct {
128	short unsigned int PlayerNum;
129	unsigned int index;
130	Inventory Inventory;
131	char Class[32];
132	} rare_sync_data;
133	*/
134	typedef struct {
135	unsigned int event_index;
136	int intArray[];
137	} flatline_event;
138	/*
139	typedef struct {
140	int16_t PlayerNum;
141	float MouseDeltaX;
142	float MouseDeltaY;
143	uint32_t Actions1;
144	uint32_t Actions2;
145	float Facing;
146	float DesiredFacing;
147	Vector3 Position;
148	} player_input;
149	*/
150	//used for storing data about each player
151	typedef struct {
152	//int FLATLINE;
153	short signature;
154	short id;
155	int size;
156	//int packet_index;
157	union
158	{
159	char data[1080];
160	connect_reply connect_reply;
161	connect_send connect_send;
162	input_struct input_struct;
163	new_player new_player;
164	server_status server_status;
165	//player_data player_data;
166	//rare_sync_data rare_sync_data;
167	uint16_t sync_request;
168	flatline_event flatline_event;
169	uint32_t ping;
170	//player_input all_input[33];
171	uint32_t integer; //generic integer ;)
172	};
173	} flatline_packet;
174	#define FLATLINE_HEADER (sizeof(flatline_packet)-sizeof(char)*1080)
175	//#define FLATLINE_PACKET_SIZE sizeof(flatline_packet)
176
177
178	bool FLrServer_PacketCallback(char* data, int datalen, int from);
179	bool FLrServer_Run();
180	bool FLrClient_Run(flatline_packet* packet);
181	extern int sock;
182
183	enum {
184	NULL_PACKET, //Don't use. ;)
185	CONNECT_SEND,
186	CONNECT_REPLY,
187	STATUS,
188	MESSAGE,
189	CHANGE_NAME,
190	ECHO,
191	NEW_PLAYER,
192	PLAYER_INPUT,
193	//PLAYER_DATA,
194	//RARE_SYNC_DATA,
195	//RARE_SYNC_DATA_REQUEST,
196	FLATLINE_EVENT,
197	PK_PING,
198	PK_PONG,
199	//PK_ALL_INPUT,
200	PK_PLAYER_DATA,
201	PK_MISSING_PLAYER,
202	};
203
204	enum FlatlineEvent {
205	EV_RESPAWN,
206	EV_KILLED,
207	EV_DISCONNECT,
208	EV_DOOR_OPEN,
209	EV_CONSOLE_USE,
210	EV_MAX,
211	};
212
213
214	typedef struct {
215	//Server Only
216	bool PleaseUpdateAllPlayers;
217	//Client stuff (can be used by server "client")
218
219	//Move from random scattered bools to these, please.
220	bool ClientConnected;
221	unsigned int ClientSlot;
222	bool ServerStatus;
223	} multiplayer_status;
224
225	enum {
226	STATE_ALIVE,
227	STATE_DEAD,
228	};
229	enum {
230	PF_HOST,
231	PF_BOT,
232	PF_SCRIPTEDAI,
233	};
234	typedef struct {
235	int ip;
236	char name[32];
237	char country[2];
238	Character* Chr;
239	uint16_t spawnnumber;
240	uint16_t list_slot;
241
242	PlayerInput InputFromClient;
243	float FacingFromClient;
244
245	////////////////////////////
246	//Sync stuff
247	////////////////////////////
248	uint16_t UpdateFlags;
249
250	PlayerInput Input;
251	PlayerHealth Health;
252	PlayerFacing Facings;
253	PlayerScore Score;
254	void* Animation;
255	char AnimationString[32];
256	uint16_t Frame;
257	PlayerThrowData ThrowData;
258	void* Class;
259	char ClassString[32];
260	PlayerInventory Inventory;
261	Vector3 Position;
262	////////////////////////////
263	bool HasAppliedThrow;
264
265	unsigned int LastInputTime;
266
267
268	uint16_t state;
269	int flags;
270	int DeathTime;
271	uint32_t Ping;
272	bool DataApplied;
273	bool NeedToSetFP;
274	uint32_t ShapeshiftCooldown;
275	} player_info;
276
277	player_info * FLr_FindEmptySlot();
278	uint16_t FLr_FindEmptyListSlot();
279	void * ONICALL FLrInput_Update_Keys(void);
280
281	void NetCatchError();
282	#define MAX_PLAYERS 32
283	#define CONNECTION_TIMEOUT 15
284	#define MAX_CONNECTIONS 32
285	#define NetTCPSocket_Send NetUDPSocket_Send
286	#define NetTCPServer_Send NetUDPServer_Send
287	extern int client_sock;
288	//these two could probably be combined
289	extern sockaddr_in client_address;
290	extern sockaddr_in address;
291	extern player_info Players[];
292	extern player_info * PlayerList[];
293	extern multiplayer_status MultiplayerStatus;
294	int UDPServer_SendToAll(void* packet, int size);
295
296
297	void FLrRun_Scores();
298	void FLrPlayerDisconnect( int Player );
299	void FLrPlayerRespawn( int Player );
300	int FLrEvent_GetNumArgs( int eventIndex );
301	bool FlatlineInitialize();
302
303	bool DoWeUpdateThis( uint16_t BitSet, uint16_t Flag );
304
305	extern unsigned int lastPingTime;
306	#endif