src/flatline/Flatline.h

#ifndef FLATLINE_H
#define FLATLINE_H

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

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

#define thread __thread

#include "Flatline_Public.h"

#include <winsock2.h>
#include "Flatline_Win32.h"

#include "../Daodan.h"
#include "../BFW_Utility.h"
#include "../Daodan_Console.h"
#include "../Oni_Character.h"
#include "../Oni_GameState.h"

#include "../Oni_Symbols.h"
//#define breakpoint asm("int3")


#include "Flatline_Net.h"

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


typedef struct
{
        uint16_t ID;
        uint16_t Size;
        uint16_t UpdateFlags;
        uint8_t  data[255];
} PlayerData;


typedef struct {
        uint32_t Actions1;
        uint32_t Actions2;
        float MouseDeltaX;
        float MouseDeltaY;      
} PlayerInput;

typedef struct {
        float Facing;
        float DesiredFacing;
} PlayerFacing;

typedef struct {
        uint16_t Health;
        uint16_t MaxHealth;
} PlayerHealth;

typedef struct {
        uint16_t Score;
        uint16_t Deaths;
} PlayerScore;

//Change this later to be misc info
typedef struct {
        uint16_t Frame;
        uint16_t Ping;
} PlayerFP;

typedef struct {
        uint8_t Ammo;
        uint8_t Cells;
        uint8_t Hypo;
        uint8_t pad;
        uint16_t Invis;
        uint16_t Shield;
} PlayerInventory;

typedef struct {
        uint16_t                                throwing;
        uint16_t                                throwFrame;
        char                                    throwName[32];
} PlayerThrowData;

enum
{
        PFlag_None,
        PFlag_Input,
        PFlag_Facing,   
        PFlag_Health,           
        PFlag_Score,            //TODO
        PFlag_FramePing,
        PFlag_Inventory, //TODO
        PFlag_Class,    
        PFlag_Position,
        PFlag_Animation,        
        PFlag_Throws,
        PFlag_Max,
        PFlag_AnimationWait,//Clients only!
};


//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;

extern char player_name[32];

#define FLATLINE_PORT 27778

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