1 | #include "GameStateManager.h" |
---|
2 | #include "Synchronisable.h" |
---|
3 | #include "GameStateClient.h" |
---|
4 | #include "NetworkPrereqs.h" |
---|
5 | #include "PacketTypes.h" |
---|
6 | #include "iostream" |
---|
7 | #include "core/CoreIncludes.h" |
---|
8 | #include "time.h" |
---|
9 | |
---|
10 | using namespace network; |
---|
11 | |
---|
12 | void printData( unsigned char* data, int length ) { |
---|
13 | for ( int i=0; i<length; i++ ) |
---|
14 | std::cout << (int)data[i] << " "; |
---|
15 | std::cout << std::endl; |
---|
16 | } |
---|
17 | |
---|
18 | void printGameStateCompressed( GameStateCompressed* gc ) { |
---|
19 | std::cout << "=================================================" << std::endl; |
---|
20 | std::cout << "GameStateCompressed id:\t\t" << gc->id << std::endl; |
---|
21 | std::cout << "GameStateCompressed normsize:\t" << gc->normsize << std::endl; |
---|
22 | std::cout << "GameStateCompressed compsize:\t" << gc->compsize << std::endl; |
---|
23 | std::cout << "GameStateCompressed diffed:\t" << gc->diffed << std::endl; |
---|
24 | //std::cout << "GameState data:\t" << gc->data << std::endl; |
---|
25 | std::cout << "GameStateCompressed compressing rate:\t" << 100.0-((100.0/(gc->normsize))*(gc->compsize)) << "%" << std::endl; |
---|
26 | //std::cout << "=================================================" << std::endl; |
---|
27 | return; |
---|
28 | } |
---|
29 | |
---|
30 | bool compareData( GameState* g1, GameState* g2 ) { |
---|
31 | if ( g1->id != g2->id ) { |
---|
32 | std::cout << "GameStates are not comparable -> not same id" << std::endl; |
---|
33 | return 1; |
---|
34 | } |
---|
35 | else if ( g1->size != g2->size ) { |
---|
36 | std::cout << "GameStates are not the same size!!" << std::endl; |
---|
37 | std::cout << g1->size << " != " << g2->size << std::endl; |
---|
38 | } |
---|
39 | int length = g1->size; |
---|
40 | for ( int i=0; i<length; i++ ) { |
---|
41 | if ( g1->data[i] != g2->data[i] ) { |
---|
42 | std::cout << "data of both GameStates are not identical" << std::endl; |
---|
43 | return false; |
---|
44 | } |
---|
45 | } |
---|
46 | std::cout << "GameStates are identical" << std::endl; |
---|
47 | return true; |
---|
48 | } |
---|
49 | |
---|
50 | bool compareGameStates( GameState* g1, GameState* g2 ) { |
---|
51 | if ( g1->id != g2->id ) { |
---|
52 | std::cout << "GameState id's not identical" << std::endl; |
---|
53 | return false; |
---|
54 | } |
---|
55 | else if( g1->size != g2->size ) { |
---|
56 | std::cout << "GameState sizes are not identical" << std::endl; |
---|
57 | return false; |
---|
58 | } |
---|
59 | else if ( g1->diffed != g2->diffed ) { |
---|
60 | std::cout << "GameState diffed params not identical" << std::endl; |
---|
61 | return false; |
---|
62 | } |
---|
63 | else if ( !compareData( g1, g2 ) ) { |
---|
64 | std::cout << "GameState data are not identical" << std::endl; |
---|
65 | return false; |
---|
66 | } |
---|
67 | std::cout << "==>GameStates are identical (GameStateCompare)" << std::endl; |
---|
68 | return true; |
---|
69 | } |
---|
70 | |
---|
71 | void printGameState( GameState* gstate ) { |
---|
72 | std::cout << "=================================================" << std::endl; |
---|
73 | std::cout << "GameState id:\t\t" << gstate->id << std::endl; |
---|
74 | std::cout << "GameState size:\t\t" << gstate->size << std::endl; |
---|
75 | std::cout << "GameState diffed:\t" << gstate->diffed << std::endl; |
---|
76 | //std::cout << "GameState data:\t" << gstate->data << std::endl; |
---|
77 | //std::cout << "=================================================" << std::endl; |
---|
78 | return; |
---|
79 | } |
---|
80 | |
---|
81 | unsigned char* createData( int length, int mode ) { |
---|
82 | char* data = new char[ length ]; |
---|
83 | |
---|
84 | if ( mode == 1 ) { |
---|
85 | for ( int i=0; i<length; i++ ) |
---|
86 | data[i] = (char)(i%255); |
---|
87 | } |
---|
88 | else if ( mode == 2 ) { |
---|
89 | for ( int i=0; i<length; i++ ) { |
---|
90 | if ( i%98 == 0 ) data[i] = (char)(i%255); |
---|
91 | else data[i] = (char)0; |
---|
92 | } |
---|
93 | } |
---|
94 | else if ( mode == 3 ) { |
---|
95 | for ( int i=0; i<length; i++ ) { |
---|
96 | data[i] = (char)(i%255); |
---|
97 | } |
---|
98 | } |
---|
99 | else if ( mode == 4 ) { |
---|
100 | for ( int i=0; i<length; i++ ){ |
---|
101 | data[i] = (char)(rand()%255); |
---|
102 | } |
---|
103 | } |
---|
104 | else if ( mode == 5 ) { |
---|
105 | for ( int i=0; i<length; i++ ){ |
---|
106 | data[i] = (char)(rand()%127); |
---|
107 | } |
---|
108 | } |
---|
109 | |
---|
110 | //printData( data, length ); |
---|
111 | |
---|
112 | unsigned char* dat = (unsigned char*)data; |
---|
113 | return dat; |
---|
114 | } |
---|
115 | |
---|
116 | GameState* changeGameStateABit( GameState* a, int mode ) { |
---|
117 | int length = a->size; |
---|
118 | GameState* b = new GameState; |
---|
119 | b->id = a->id; |
---|
120 | b->diffed = a->diffed; |
---|
121 | |
---|
122 | if ( mode == 1 ) { |
---|
123 | b->data = new unsigned char[a->size]; |
---|
124 | b->size = a->size; |
---|
125 | for ( int i=0; i<length; i++ ) { |
---|
126 | if ( i%10 == 0 ) b->data[i] = rand()%255; |
---|
127 | else b->data[i] = a->data[i]; |
---|
128 | } |
---|
129 | } |
---|
130 | else if ( mode == 2 ) { |
---|
131 | b->data = new unsigned char[a->size]; |
---|
132 | b->size = a->size; |
---|
133 | for ( int i=0; i<length; i++ ) { |
---|
134 | if ( i%5 == 0 ) b->data[i] = rand()%255; |
---|
135 | else b->data[i] = a->data[i]; |
---|
136 | } |
---|
137 | } |
---|
138 | else if ( mode == 3 ) { |
---|
139 | int s = a->size + (a->size)/3; |
---|
140 | b->data = new unsigned char[s]; |
---|
141 | b->size = s; |
---|
142 | for ( int i=0; i<length; i++ ) { |
---|
143 | if ( i%10 == 0 ) b->data[i] = rand()%255; |
---|
144 | else b->data[i] = a->data[i]; |
---|
145 | } |
---|
146 | for( int i=length; i<s; i++ ) { |
---|
147 | b->data[i] = rand()%255; |
---|
148 | } |
---|
149 | } |
---|
150 | |
---|
151 | return b; |
---|
152 | } |
---|
153 | |
---|
154 | void testCompression( int size, int mode ) { |
---|
155 | std::cout << "testing compression with: size = " << size << " ,mode = " << mode << std::endl; |
---|
156 | GameStateClient* g_client; |
---|
157 | GameStateManager* g_manager;; |
---|
158 | |
---|
159 | GameState* g_new = new GameState; |
---|
160 | GameState* g_old = new GameState; |
---|
161 | GameStateCompressed* gc = new GameStateCompressed; |
---|
162 | |
---|
163 | g_old->data = createData( size, mode ); |
---|
164 | g_old->size = size; |
---|
165 | g_old->id = 0; |
---|
166 | g_old->diffed = false; |
---|
167 | printGameState( g_old ); |
---|
168 | |
---|
169 | gc = g_manager->testCompress( g_old ); |
---|
170 | printGameStateCompressed( gc ); |
---|
171 | |
---|
172 | g_new = g_client->testDecompress( gc ); |
---|
173 | printGameState( g_new ); |
---|
174 | |
---|
175 | compareGameStates( g_new, g_old ); |
---|
176 | |
---|
177 | return; |
---|
178 | } |
---|
179 | |
---|
180 | void testDifferentiation( int size, int modeCreateData, int modeChangeData ) { |
---|
181 | std::cout << "testing diff with: size = " << size << " modeCreateData = " |
---|
182 | << modeCreateData << " modeChangeData = " << modeChangeData << std::endl; |
---|
183 | GameStateClient* g_client; |
---|
184 | GameStateManager* g_manager;; |
---|
185 | |
---|
186 | GameState* g_undiff1 = new GameState; |
---|
187 | GameState* g_undiff2 = new GameState; |
---|
188 | GameState* g_diffed; |
---|
189 | GameState* g_result; |
---|
190 | |
---|
191 | g_undiff1->data = createData( size, modeCreateData ); |
---|
192 | g_undiff1->size = size; |
---|
193 | g_undiff1->id = 1; |
---|
194 | g_undiff1->diffed = false; |
---|
195 | printGameState( g_undiff1 ); |
---|
196 | |
---|
197 | g_undiff2 = changeGameStateABit( g_undiff1, modeChangeData ); |
---|
198 | printGameState( g_undiff2 ); |
---|
199 | |
---|
200 | if( !compareData( g_undiff1, g_undiff2 ) ) std::cout << " BUT THAT'S HOW IT HAS TO BE" << std::endl; |
---|
201 | |
---|
202 | //printData( g_undiff1->data, g_undiff1->size ); |
---|
203 | //printData( g_undiff2->data, g_undiff2->size ); |
---|
204 | |
---|
205 | g_diffed = g_manager->testDiff( g_undiff1, g_undiff2 ); |
---|
206 | printGameState( g_diffed ); |
---|
207 | //printData( g_diffed->data, g_diffed->size ); |
---|
208 | |
---|
209 | g_result = g_client->testUndiff( g_undiff1, g_diffed ); |
---|
210 | compareGameStates( g_result, g_undiff2 ); |
---|
211 | |
---|
212 | return; |
---|
213 | } |
---|
214 | |
---|
215 | void testCompressWithDiff( int size, int modeCreateData, int modeChangeData ) { |
---|
216 | std::cout << "testing CompressWithDiff with: size = " << size << " modeCreateData = " |
---|
217 | << modeCreateData << " modeChangeData = " << modeChangeData << std::endl; |
---|
218 | GameStateClient* g_client; |
---|
219 | GameStateManager* g_manager;; |
---|
220 | |
---|
221 | GameStateCompressed* gc = new GameStateCompressed; |
---|
222 | GameStateCompressed* g_compressedNoDiff; |
---|
223 | GameState* g_undiff1 = new GameState; |
---|
224 | GameState* g_undiff2 = new GameState; |
---|
225 | GameState* g_diffed; |
---|
226 | GameState* g_resultDiffed; |
---|
227 | GameState* g_resultUndiffed; |
---|
228 | |
---|
229 | g_undiff1->data = createData( size, modeCreateData ); |
---|
230 | g_undiff1->size = size; |
---|
231 | g_undiff1->id = 1; |
---|
232 | g_undiff1->diffed = false; |
---|
233 | |
---|
234 | std::cout << "---First generated Gamestate" << std::endl; |
---|
235 | printGameState( g_undiff1 ); |
---|
236 | |
---|
237 | g_undiff2 = changeGameStateABit( g_undiff1, modeChangeData ); |
---|
238 | std::cout << "---First gererated Gamestate with some changes ev. longer" << std::endl; |
---|
239 | printGameState( g_undiff2 ); |
---|
240 | |
---|
241 | if( !compareData( g_undiff1, g_undiff2 ) ) std::cout << " BUT THAT'S HOW IT HAS TO BE" << std::endl; |
---|
242 | |
---|
243 | g_diffed = g_manager->testDiff( g_undiff1, g_undiff2 ); |
---|
244 | std::cout << "---Diffed Gamestate not compressed" << std::endl; |
---|
245 | printGameState( g_diffed ); |
---|
246 | |
---|
247 | gc = g_manager->testCompress( g_diffed ); |
---|
248 | std::cout << "---Diffed Gamestate compressed" << std::endl; |
---|
249 | printGameStateCompressed( gc ); |
---|
250 | |
---|
251 | g_compressedNoDiff = g_manager->testCompress( g_undiff2 ); |
---|
252 | std::cout << "---Same not Diffed Gamestate compressen" << std::endl; |
---|
253 | printGameStateCompressed( g_compressedNoDiff ); |
---|
254 | |
---|
255 | g_resultDiffed = g_client->testDecompress( gc ); |
---|
256 | std::cout << "---Diffed Gamestate of above uncompressed" << std::endl; |
---|
257 | printGameState( g_resultDiffed ); |
---|
258 | |
---|
259 | std::cout << "---Diffed Gamestates before compressed and after uncompress comparsion" << std::endl; |
---|
260 | compareGameStates( g_resultDiffed, g_diffed ); |
---|
261 | |
---|
262 | g_resultUndiffed = g_client->testUndiff( g_undiff1, g_resultDiffed ); |
---|
263 | std::cout << "---New Gamestate of pseudo Server compared with new gamestate that Client gets" << std::endl; |
---|
264 | compareGameStates( g_resultUndiffed, g_undiff2 ); |
---|
265 | |
---|
266 | return; |
---|
267 | } |
---|
268 | |
---|
269 | int main( int argc, char* argv[] ) { |
---|
270 | int a,b,c; |
---|
271 | std::string dec = "nothing"; |
---|
272 | std::cout << "############### START TEST (quit q) ###############" << std::endl; |
---|
273 | while ( dec.compare("q") != 0 ) { |
---|
274 | std::cout << "possible tests: testcompression [datalength] [mode]" << std::endl; |
---|
275 | std::cout << "testdiff [datalength] [mode Data] [mode Change]" << std::endl; |
---|
276 | std::cout << "tcd [datalength] [mode Data] [mode Change]" << std::endl; |
---|
277 | std::cin >> dec; |
---|
278 | if ( dec.compare("testcompression") == 0 ) { |
---|
279 | std::cin >> a; std::cin >> b; |
---|
280 | testCompression( a, b ); |
---|
281 | } |
---|
282 | else if ( dec.compare("testdiff") == 0 ) { |
---|
283 | std::cin>> a; std::cin >> b; std::cin >> c; |
---|
284 | testDifferentiation( a, b, c ); |
---|
285 | } |
---|
286 | else if ( dec.compare("tcd") == 0 ) { |
---|
287 | std::cin>> a; std::cin >> b; std::cin >> c; |
---|
288 | testCompressWithDiff( a, b, c ); |
---|
289 | } |
---|
290 | } |
---|
291 | return 0; |
---|
292 | } |
---|
293 | /** |
---|
294 | int main() { |
---|
295 | std::cout << "############### START TEST (quit q) ###############" << std::endl; |
---|
296 | testCompressWithDiff( 5000, 5, 1 ); |
---|
297 | }*/ |
---|