Daodan/MSVC/Flatline_PacketBuilder.c

#include "Flatline.h"
#include <assert.h>

#define FLAG_AND_INCREMENT( FLAG )      PD->UpdateFlags |= (1 << FLAG ); DataPointer += FLpData_PartSize( FLAG );

void FLsPacketBuild( uint8_t p, PlayerData* PD, bool UpdateAll )
{
        Character* Player = PlayerList[p]->Chr;
        ActiveCharacter* APlayer = ONrGetActiveCharacter(Player);
        player_info * PI = PlayerList[p];
        uint8_t * DataPointer = PD->data;
        PD->ID = p;
        
        //if ( data has changed )
        //{
        //      copy it to the buffer
        //  copy it to the player info
        //  set the changed flag
        //  increment the buffer pointer
        //}

        /* 
        //Could probably send this every frame, but afk players can save a few bytes, eh?
        if( PI->Input.Actions1 != PI->InputFromClient.Actions1 ||
                PI->Input.Actions2 != PI->InputFromClient.Actions2 ||
                PI->Input.MouseDeltaX != PI->InputFromClient.MouseDeltaX ||
                PI->Input.MouseDeltaY != PI->InputFromClient.MouseDeltaY )
        {*/

        //Better in case of dropped packets to send input every frame
        if(1)
        {
                memcpy( DataPointer, &PI->InputFromClient, sizeof(PlayerInput));
                PI->Input = PI->InputFromClient;

                FLAG_AND_INCREMENT( PFlag_Input );
        }

        if( PI->Facings.Facing != Player->Facing ||
                PI->Facings.DesiredFacing != Player->DesiredFacing || UpdateAll )
        {
                PlayerFacing* ptr = (void*)DataPointer;
                ptr->Facing = Player->Facing;
                ptr->DesiredFacing = Player->DesiredFacing;

                PI->Facings = *ptr;

                FLAG_AND_INCREMENT( PFlag_Facing );
        }

        if(PI->Health.Health != Player->Health ||
                PI->Health.MaxHealth != Player->MaxHealth || UpdateAll )
        {
                PlayerHealth* ptr = (void*)DataPointer;
                ptr->Health = Player->Health;
                ptr->MaxHealth = Player->MaxHealth;

                PI->Health = *ptr;

                FLAG_AND_INCREMENT( PFlag_Health );
        }

        //Score
        //skipping for now

        //Frame and ping can be sent every frame, i guess. Improve this later,
        if( 1 )
        {
                PlayerFP* ptr = (void*)DataPointer;
                if(APlayer)
                {
                        ptr->Frame = APlayer->Frame;
                }
                else
                {
                        ptr->Frame = -1;
                }
                ptr->Ping = PI->Ping;

                PI->Frame = ptr->Frame;

                FLAG_AND_INCREMENT( PFlag_FramePing );
        }
        
        //Skipping inventory because we dont need it right now
        if( 0 )
        {
                //Do inventory
        }

        if( PI->Class != Player->ONCC || UpdateAll )
        {
                sprintf_s( DataPointer, 32, "%s", TMrInstance_GetInstanceName( Player->ONCC ) );
                sprintf_s( PI->ClassString, 32, "%s", DataPointer );
                PI->Class = Player->ONCC;

                FLAG_AND_INCREMENT( PFlag_Class );
        }

        if(APlayer)
        {
                if( (APlayer->PhyContext) && (memcmp(&PI->Position, &APlayer->PhyContext->Position, sizeof(Vector3)) || UpdateAll ))
                {
                        Vector3* ptr = (Vector3*)DataPointer;
                        *ptr = PI->Position = APlayer->PhyContext->Position;
                
                        FLAG_AND_INCREMENT( PFlag_Position );
                }

                if(APlayer->Animation != PI->Animation || !APlayer->Frame || UpdateAll )
                {
                        sprintf_s( DataPointer, 32, "%s", TMrInstance_GetInstanceName( APlayer->Animation ) );
                        sprintf_s( PI->AnimationString, 32, "%s", DataPointer );
                        PI->Animation = APlayer->Animation;

                        
                        FLAG_AND_INCREMENT( PFlag_Animation );
                }

                if(APlayer->targetThrow)
                {
                        if(!PI->HasAppliedThrow || UpdateAll )
                        {
                                PlayerThrowData* ptr = (void*)DataPointer;
                                ptr->throwing = Players[APlayer->throwing].list_slot;
                                memcpy(ptr->throwName, TMrInstance_GetInstanceName(APlayer->targetThrow), 31);
                                ptr->throwFrame = ONrGetActiveCharacter(APlayer->targetThrow)->Frame;

                                PI->ThrowData = *ptr;

                                PI->HasAppliedThrow = 1;

                                FLAG_AND_INCREMENT( PFlag_Throws );
                        }
                }
                else
                {
                        PI->HasAppliedThrow = 0;
                }
        }
        
        PD->Size = (uint32_t)DataPointer - (uint32_t)PD;

        PI->UpdateFlags = PD->UpdateFlags;      
        
}


void FLsSendPlayerData()
{
        PlayerData BuildData[32] = {0};
        uint8_t p = 0;
        uint32_t PacketSize = 0;
        flatline_packet OutputPacket = {0};
        uint8_t* OutputPointer = OutputPacket.data;
        //Most of the time we won't even hit this. Could probably be bumped up a few hundred bytes
        const uint32_t max_packet_size = 1000;

        //Prepare buffers
        OutputPacket.id = PK_PLAYER_DATA;
        memset( BuildData, 0, sizeof(PlayerData) * 32 );

        //Build data
        for(p = 0; p < MAX_PLAYERS; p++)
        {
                if(PlayerList[p] && PlayerList[p]->Chr)
                {
                        FLsPacketBuild(p, &BuildData[p], 0);
                        
                        assert( BuildData[p].Size < 255 );
                        
                        if( BuildData[p].Size > 0 )
                        {

                                //If we hit maximum size, send the packet and reset the buffer for a new one
                                if( BuildData[p].Size + PacketSize > max_packet_size )
                                {
                                        UDPServer_SendToAll(&OutputPacket, PacketSize + FLATLINE_HEADER);

                                        memset( OutputPacket.data, 0, PacketSize );
                                        OutputPointer = OutputPacket.data;
                                        PacketSize = 0;
                                }

                                //add to the packet
                                memcpy( OutputPointer, &BuildData[p], BuildData[p].Size );

                                OutputPointer += BuildData[p].Size;
                                PacketSize += BuildData[p].Size;
                        }
                }
        }
        //Send data
        if( PacketSize > 0 )
        {
                UDPServer_SendToAll(&OutputPacket, PacketSize + FLATLINE_HEADER);
        }
}
Revision:	586
Committed:	Wed Feb 2 08:17:19 2011 UTC (14 years, 8 months ago) by gumby
Content type:	text/x-csrc
File size:	5038 byte(s)
Log Message:	stuff
#	Content
1	#include "Flatline.h"
2	#include <assert.h>
3
4	#define FLAG_AND_INCREMENT( FLAG ) PD->UpdateFlags \|= (1 << FLAG ); DataPointer += FLpData_PartSize( FLAG );
5
6	void FLsPacketBuild( uint8_t p, PlayerData* PD, bool UpdateAll )
7	{
8	Character* Player = PlayerList[p]->Chr;
9	ActiveCharacter* APlayer = ONrGetActiveCharacter(Player);
10	player_info * PI = PlayerList[p];
11	uint8_t * DataPointer = PD->data;
12	PD->ID = p;
13
14	//if ( data has changed )
15	//{
16	// copy it to the buffer
17	// copy it to the player info
18	// set the changed flag
19	// increment the buffer pointer
20	//}
21
22	/*
23	//Could probably send this every frame, but afk players can save a few bytes, eh?
24	if( PI->Input.Actions1 != PI->InputFromClient.Actions1 \|\|
25	PI->Input.Actions2 != PI->InputFromClient.Actions2 \|\|
26	PI->Input.MouseDeltaX != PI->InputFromClient.MouseDeltaX \|\|
27	PI->Input.MouseDeltaY != PI->InputFromClient.MouseDeltaY )
28	{*/
29
30	//Better in case of dropped packets to send input every frame
31	if(1)
32	{
33	memcpy( DataPointer, &PI->InputFromClient, sizeof(PlayerInput));
34	PI->Input = PI->InputFromClient;
35
36	FLAG_AND_INCREMENT( PFlag_Input );
37	}
38
39	if( PI->Facings.Facing != Player->Facing \|\|
40	PI->Facings.DesiredFacing != Player->DesiredFacing \|\| UpdateAll )
41	{
42	PlayerFacing* ptr = (void*)DataPointer;
43	ptr->Facing = Player->Facing;
44	ptr->DesiredFacing = Player->DesiredFacing;
45
46	PI->Facings = *ptr;
47
48	FLAG_AND_INCREMENT( PFlag_Facing );
49	}
50
51	if(PI->Health.Health != Player->Health \|\|
52	PI->Health.MaxHealth != Player->MaxHealth \|\| UpdateAll )
53	{
54	PlayerHealth* ptr = (void*)DataPointer;
55	ptr->Health = Player->Health;
56	ptr->MaxHealth = Player->MaxHealth;
57
58	PI->Health = *ptr;
59
60	FLAG_AND_INCREMENT( PFlag_Health );
61	}
62
63	//Score
64	//skipping for now
65
66	//Frame and ping can be sent every frame, i guess. Improve this later,
67	if( 1 )
68	{
69	PlayerFP* ptr = (void*)DataPointer;
70	if(APlayer)
71	{
72	ptr->Frame = APlayer->Frame;
73	}
74	else
75	{
76	ptr->Frame = -1;
77	}
78	ptr->Ping = PI->Ping;
79
80	PI->Frame = ptr->Frame;
81
82	FLAG_AND_INCREMENT( PFlag_FramePing );
83	}
84
85	//Skipping inventory because we dont need it right now
86	if( 0 )
87	{
88	//Do inventory
89	}
90
91	if( PI->Class != Player->ONCC \|\| UpdateAll )
92	{
93	sprintf_s( DataPointer, 32, "%s", TMrInstance_GetInstanceName( Player->ONCC ) );
94	sprintf_s( PI->ClassString, 32, "%s", DataPointer );
95	PI->Class = Player->ONCC;
96
97	FLAG_AND_INCREMENT( PFlag_Class );
98	}
99
100	if(APlayer)
101	{
102	if( (APlayer->PhyContext) && (memcmp(&PI->Position, &APlayer->PhyContext->Position, sizeof(Vector3)) \|\| UpdateAll ))
103	{
104	Vector3* ptr = (Vector3*)DataPointer;
105	*ptr = PI->Position = APlayer->PhyContext->Position;
106
107	FLAG_AND_INCREMENT( PFlag_Position );
108	}
109
110	if(APlayer->Animation != PI->Animation \|\| !APlayer->Frame \|\| UpdateAll )
111	{
112	sprintf_s( DataPointer, 32, "%s", TMrInstance_GetInstanceName( APlayer->Animation ) );
113	sprintf_s( PI->AnimationString, 32, "%s", DataPointer );
114	PI->Animation = APlayer->Animation;
115
116
117	FLAG_AND_INCREMENT( PFlag_Animation );
118	}
119
120	if(APlayer->targetThrow)
121	{
122	if(!PI->HasAppliedThrow \|\| UpdateAll )
123	{
124	PlayerThrowData* ptr = (void*)DataPointer;
125	ptr->throwing = Players[APlayer->throwing].list_slot;
126	memcpy(ptr->throwName, TMrInstance_GetInstanceName(APlayer->targetThrow), 31);
127	ptr->throwFrame = ONrGetActiveCharacter(APlayer->targetThrow)->Frame;
128
129	PI->ThrowData = *ptr;
130
131	PI->HasAppliedThrow = 1;
132
133	FLAG_AND_INCREMENT( PFlag_Throws );
134	}
135	}
136	else
137	{
138	PI->HasAppliedThrow = 0;
139	}
140	}
141
142	PD->Size = (uint32_t)DataPointer - (uint32_t)PD;
143
144	PI->UpdateFlags = PD->UpdateFlags;
145
146	}
147
148
149
150	void FLsSendPlayerData()
151	{
152	PlayerData BuildData[32] = {0};
153	uint8_t p = 0;
154	uint32_t PacketSize = 0;
155	flatline_packet OutputPacket = {0};
156	uint8_t* OutputPointer = OutputPacket.data;
157	//Most of the time we won't even hit this. Could probably be bumped up a few hundred bytes
158	const uint32_t max_packet_size = 1000;
159
160	//Prepare buffers
161	OutputPacket.id = PK_PLAYER_DATA;
162	memset( BuildData, 0, sizeof(PlayerData) * 32 );
163
164	//Build data
165	for(p = 0; p < MAX_PLAYERS; p++)
166	{
167	if(PlayerList[p] && PlayerList[p]->Chr)
168	{
169	FLsPacketBuild(p, &BuildData[p], 0);
170
171	assert( BuildData[p].Size < 255 );
172
173	if( BuildData[p].Size > 0 )
174	{
175
176	//If we hit maximum size, send the packet and reset the buffer for a new one
177	if( BuildData[p].Size + PacketSize > max_packet_size )
178	{
179	UDPServer_SendToAll(&OutputPacket, PacketSize + FLATLINE_HEADER);
180
181	memset( OutputPacket.data, 0, PacketSize );
182	OutputPointer = OutputPacket.data;
183	PacketSize = 0;
184	}
185
186	//add to the packet
187	memcpy( OutputPointer, &BuildData[p], BuildData[p].Size );
188
189	OutputPointer += BuildData[p].Size;
190	PacketSize += BuildData[p].Size;
191	}
192	}
193	}
194	//Send data
195	if( PacketSize > 0 )
196	{
197	UDPServer_SendToAll(&OutputPacket, PacketSize + FLATLINE_HEADER);
198	}
199	}