[984] | 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 | }*/ |
---|