00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include <interfaces/GameStateInterface.h>
00025
00026 #include <core/exceptions/software.h>
00027
00028 #include <cstring>
00029 #include <cstdlib>
00030
00031 namespace fawkes {
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045 const uint32_t GameStateInterface::GS_FROZEN = 0u;
00046
00047 const uint32_t GameStateInterface::GS_PLAY = 1u;
00048
00049 const uint32_t GameStateInterface::GS_KICK_OFF = 2u;
00050
00051 const uint32_t GameStateInterface::GS_DROP_BALL = 3u;
00052
00053 const uint32_t GameStateInterface::GS_PENALTY = 4u;
00054
00055 const uint32_t GameStateInterface::GS_CORNER_KICK = 5u;
00056
00057 const uint32_t GameStateInterface::GS_THROW_IN = 6u;
00058
00059 const uint32_t GameStateInterface::GS_FREE_KICK = 7u;
00060
00061 const uint32_t GameStateInterface::GS_GOAL_KICK = 8u;
00062
00063 const uint32_t GameStateInterface::GS_HALF_TIME = 9u;
00064
00065 const uint32_t GameStateInterface::GS_SPL_INITIAL = 0u;
00066
00067 const uint32_t GameStateInterface::GS_SPL_READY = 1u;
00068
00069 const uint32_t GameStateInterface::GS_SPL_SET = 2u;
00070
00071 const uint32_t GameStateInterface::GS_SPL_PLAY = 3u;
00072
00073 const uint32_t GameStateInterface::GS_SPL_FINISHED = 4u;
00074
00075
00076 GameStateInterface::GameStateInterface() : Interface()
00077 {
00078 data_size = sizeof(GameStateInterface_data_t);
00079 data_ptr = malloc(data_size);
00080 data = (GameStateInterface_data_t *)data_ptr;
00081 data_ts = (interface_data_ts_t *)data_ptr;
00082 memset(data_ptr, 0, data_size);
00083 add_fieldinfo(IFT_UINT32, "game_state", 1, &data->game_state);
00084 add_fieldinfo(IFT_ENUM, "state_team", 1, &data->state_team, "if_gamestate_team_t");
00085 add_fieldinfo(IFT_ENUM, "our_team", 1, &data->our_team, "if_gamestate_team_t");
00086 add_fieldinfo(IFT_ENUM, "our_goal_color", 1, &data->our_goal_color, "if_gamestate_goalcolor_t");
00087 add_fieldinfo(IFT_ENUM, "half", 1, &data->half, "if_gamestate_half_t");
00088 add_fieldinfo(IFT_BOOL, "kickoff", 1, &data->kickoff);
00089 add_fieldinfo(IFT_ENUM, "role", 1, &data->role, "if_gamestate_role_t");
00090 add_fieldinfo(IFT_UINT32, "score_cyan", 1, &data->score_cyan);
00091 add_fieldinfo(IFT_UINT32, "score_magenta", 1, &data->score_magenta);
00092 add_messageinfo("SetTeamColorMessage");
00093 add_messageinfo("SetKickoffMessage");
00094 add_messageinfo("SetStateTeamMessage");
00095 unsigned char tmp_hash[] = {0xf5, 0x19, 0x26, 0x77, 0x6, 0x54, 0x44, 0xb4, 0xe1, 0x61, 0x40, 0x2a, 0x65, 0xfc, 0xaf, 0xa1};
00096 set_hash(tmp_hash);
00097 }
00098
00099
00100 GameStateInterface::~GameStateInterface()
00101 {
00102 free(data_ptr);
00103 }
00104
00105
00106
00107
00108 const char *
00109 GameStateInterface::tostring_if_gamestate_team_t(if_gamestate_team_t value) const
00110 {
00111 switch (value) {
00112 case TEAM_NONE: return "TEAM_NONE";
00113 case TEAM_CYAN: return "TEAM_CYAN";
00114 case TEAM_MAGENTA: return "TEAM_MAGENTA";
00115 case TEAM_BOTH: return "TEAM_BOTH";
00116 default: return "UNKNOWN";
00117 }
00118 }
00119
00120
00121
00122
00123 const char *
00124 GameStateInterface::tostring_if_gamestate_goalcolor_t(if_gamestate_goalcolor_t value) const
00125 {
00126 switch (value) {
00127 case GOAL_BLUE: return "GOAL_BLUE";
00128 case GOAL_YELLOW: return "GOAL_YELLOW";
00129 default: return "UNKNOWN";
00130 }
00131 }
00132
00133
00134
00135
00136 const char *
00137 GameStateInterface::tostring_if_gamestate_half_t(if_gamestate_half_t value) const
00138 {
00139 switch (value) {
00140 case HALF_FIRST: return "HALF_FIRST";
00141 case HALF_SECOND: return "HALF_SECOND";
00142 default: return "UNKNOWN";
00143 }
00144 }
00145
00146
00147
00148
00149 const char *
00150 GameStateInterface::tostring_if_gamestate_role_t(if_gamestate_role_t value) const
00151 {
00152 switch (value) {
00153 case ROLE_GOALIE: return "ROLE_GOALIE";
00154 case ROLE_DEFENDER: return "ROLE_DEFENDER";
00155 case ROLE_MID_LEFT: return "ROLE_MID_LEFT";
00156 case ROLE_MID_RIGHT: return "ROLE_MID_RIGHT";
00157 case ROLE_ATTACKER: return "ROLE_ATTACKER";
00158 default: return "UNKNOWN";
00159 }
00160 }
00161
00162
00163
00164
00165
00166 uint32_t
00167 GameStateInterface::game_state() const
00168 {
00169 return data->game_state;
00170 }
00171
00172
00173
00174
00175
00176 size_t
00177 GameStateInterface::maxlenof_game_state() const
00178 {
00179 return 1;
00180 }
00181
00182
00183
00184
00185
00186 void
00187 GameStateInterface::set_game_state(const uint32_t new_game_state)
00188 {
00189 data->game_state = new_game_state;
00190 data_changed = true;
00191 }
00192
00193
00194
00195
00196
00197 GameStateInterface::if_gamestate_team_t
00198 GameStateInterface::state_team() const
00199 {
00200 return data->state_team;
00201 }
00202
00203
00204
00205
00206
00207 size_t
00208 GameStateInterface::maxlenof_state_team() const
00209 {
00210 return 1;
00211 }
00212
00213
00214
00215
00216
00217 void
00218 GameStateInterface::set_state_team(const if_gamestate_team_t new_state_team)
00219 {
00220 data->state_team = new_state_team;
00221 data_changed = true;
00222 }
00223
00224
00225
00226
00227
00228 GameStateInterface::if_gamestate_team_t
00229 GameStateInterface::our_team() const
00230 {
00231 return data->our_team;
00232 }
00233
00234
00235
00236
00237
00238 size_t
00239 GameStateInterface::maxlenof_our_team() const
00240 {
00241 return 1;
00242 }
00243
00244
00245
00246
00247
00248 void
00249 GameStateInterface::set_our_team(const if_gamestate_team_t new_our_team)
00250 {
00251 data->our_team = new_our_team;
00252 data_changed = true;
00253 }
00254
00255
00256
00257
00258
00259 GameStateInterface::if_gamestate_goalcolor_t
00260 GameStateInterface::our_goal_color() const
00261 {
00262 return data->our_goal_color;
00263 }
00264
00265
00266
00267
00268
00269 size_t
00270 GameStateInterface::maxlenof_our_goal_color() const
00271 {
00272 return 1;
00273 }
00274
00275
00276
00277
00278
00279 void
00280 GameStateInterface::set_our_goal_color(const if_gamestate_goalcolor_t new_our_goal_color)
00281 {
00282 data->our_goal_color = new_our_goal_color;
00283 data_changed = true;
00284 }
00285
00286
00287
00288
00289
00290 GameStateInterface::if_gamestate_half_t
00291 GameStateInterface::half() const
00292 {
00293 return data->half;
00294 }
00295
00296
00297
00298
00299
00300 size_t
00301 GameStateInterface::maxlenof_half() const
00302 {
00303 return 1;
00304 }
00305
00306
00307
00308
00309
00310 void
00311 GameStateInterface::set_half(const if_gamestate_half_t new_half)
00312 {
00313 data->half = new_half;
00314 data_changed = true;
00315 }
00316
00317
00318
00319
00320
00321 bool
00322 GameStateInterface::is_kickoff() const
00323 {
00324 return data->kickoff;
00325 }
00326
00327
00328
00329
00330
00331 size_t
00332 GameStateInterface::maxlenof_kickoff() const
00333 {
00334 return 1;
00335 }
00336
00337
00338
00339
00340
00341 void
00342 GameStateInterface::set_kickoff(const bool new_kickoff)
00343 {
00344 data->kickoff = new_kickoff;
00345 data_changed = true;
00346 }
00347
00348
00349
00350
00351
00352 GameStateInterface::if_gamestate_role_t
00353 GameStateInterface::role() const
00354 {
00355 return data->role;
00356 }
00357
00358
00359
00360
00361
00362 size_t
00363 GameStateInterface::maxlenof_role() const
00364 {
00365 return 1;
00366 }
00367
00368
00369
00370
00371
00372 void
00373 GameStateInterface::set_role(const if_gamestate_role_t new_role)
00374 {
00375 data->role = new_role;
00376 data_changed = true;
00377 }
00378
00379
00380
00381
00382
00383 uint32_t
00384 GameStateInterface::score_cyan() const
00385 {
00386 return data->score_cyan;
00387 }
00388
00389
00390
00391
00392
00393 size_t
00394 GameStateInterface::maxlenof_score_cyan() const
00395 {
00396 return 1;
00397 }
00398
00399
00400
00401
00402
00403 void
00404 GameStateInterface::set_score_cyan(const uint32_t new_score_cyan)
00405 {
00406 data->score_cyan = new_score_cyan;
00407 data_changed = true;
00408 }
00409
00410
00411
00412
00413
00414 uint32_t
00415 GameStateInterface::score_magenta() const
00416 {
00417 return data->score_magenta;
00418 }
00419
00420
00421
00422
00423
00424 size_t
00425 GameStateInterface::maxlenof_score_magenta() const
00426 {
00427 return 1;
00428 }
00429
00430
00431
00432
00433
00434 void
00435 GameStateInterface::set_score_magenta(const uint32_t new_score_magenta)
00436 {
00437 data->score_magenta = new_score_magenta;
00438 data_changed = true;
00439 }
00440
00441
00442 Message *
00443 GameStateInterface::create_message(const char *type) const
00444 {
00445 if ( strncmp("SetTeamColorMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00446 return new SetTeamColorMessage();
00447 } else if ( strncmp("SetKickoffMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00448 return new SetKickoffMessage();
00449 } else if ( strncmp("SetStateTeamMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00450 return new SetStateTeamMessage();
00451 } else {
00452 throw UnknownTypeException("The given type '%s' does not match any known "
00453 "message type for this interface type.", type);
00454 }
00455 }
00456
00457
00458
00459
00460
00461 void
00462 GameStateInterface::copy_values(const Interface *other)
00463 {
00464 const GameStateInterface *oi = dynamic_cast<const GameStateInterface *>(other);
00465 if (oi == NULL) {
00466 throw TypeMismatchException("Can only copy values from interface of same type (%s vs. %s)",
00467 type(), other->type());
00468 }
00469 memcpy(data, oi->data, sizeof(GameStateInterface_data_t));
00470 }
00471
00472 const char *
00473 GameStateInterface::enum_tostring(const char *enumtype, int val) const
00474 {
00475 if (strcmp(enumtype, "if_gamestate_team_t") == 0) {
00476 return tostring_if_gamestate_team_t((if_gamestate_team_t)val);
00477 }
00478 if (strcmp(enumtype, "if_gamestate_goalcolor_t") == 0) {
00479 return tostring_if_gamestate_goalcolor_t((if_gamestate_goalcolor_t)val);
00480 }
00481 if (strcmp(enumtype, "if_gamestate_half_t") == 0) {
00482 return tostring_if_gamestate_half_t((if_gamestate_half_t)val);
00483 }
00484 if (strcmp(enumtype, "if_gamestate_role_t") == 0) {
00485 return tostring_if_gamestate_role_t((if_gamestate_role_t)val);
00486 }
00487 throw UnknownTypeException("Unknown enum type %s", enumtype);
00488 }
00489
00490
00491
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501 GameStateInterface::SetTeamColorMessage::SetTeamColorMessage(const if_gamestate_team_t ini_our_team) : Message("SetTeamColorMessage")
00502 {
00503 data_size = sizeof(SetTeamColorMessage_data_t);
00504 data_ptr = malloc(data_size);
00505 memset(data_ptr, 0, data_size);
00506 data = (SetTeamColorMessage_data_t *)data_ptr;
00507 data_ts = (message_data_ts_t *)data_ptr;
00508 data->our_team = ini_our_team;
00509 add_fieldinfo(IFT_ENUM, "our_team", 1, &data->our_team, "if_gamestate_team_t");
00510 }
00511
00512 GameStateInterface::SetTeamColorMessage::SetTeamColorMessage() : Message("SetTeamColorMessage")
00513 {
00514 data_size = sizeof(SetTeamColorMessage_data_t);
00515 data_ptr = malloc(data_size);
00516 memset(data_ptr, 0, data_size);
00517 data = (SetTeamColorMessage_data_t *)data_ptr;
00518 data_ts = (message_data_ts_t *)data_ptr;
00519 add_fieldinfo(IFT_ENUM, "our_team", 1, &data->our_team, "if_gamestate_team_t");
00520 }
00521
00522
00523 GameStateInterface::SetTeamColorMessage::~SetTeamColorMessage()
00524 {
00525 free(data_ptr);
00526 }
00527
00528
00529
00530
00531 GameStateInterface::SetTeamColorMessage::SetTeamColorMessage(const SetTeamColorMessage *m) : Message("SetTeamColorMessage")
00532 {
00533 data_size = m->data_size;
00534 data_ptr = malloc(data_size);
00535 memcpy(data_ptr, m->data_ptr, data_size);
00536 data = (SetTeamColorMessage_data_t *)data_ptr;
00537 data_ts = (message_data_ts_t *)data_ptr;
00538 }
00539
00540
00541
00542
00543
00544
00545 GameStateInterface::if_gamestate_team_t
00546 GameStateInterface::SetTeamColorMessage::our_team() const
00547 {
00548 return data->our_team;
00549 }
00550
00551
00552
00553
00554
00555 size_t
00556 GameStateInterface::SetTeamColorMessage::maxlenof_our_team() const
00557 {
00558 return 1;
00559 }
00560
00561
00562
00563
00564
00565 void
00566 GameStateInterface::SetTeamColorMessage::set_our_team(const if_gamestate_team_t new_our_team)
00567 {
00568 data->our_team = new_our_team;
00569 }
00570
00571
00572
00573
00574
00575
00576 Message *
00577 GameStateInterface::SetTeamColorMessage::clone() const
00578 {
00579 return new GameStateInterface::SetTeamColorMessage(this);
00580 }
00581
00582
00583
00584
00585
00586
00587
00588
00589
00590
00591 GameStateInterface::SetKickoffMessage::SetKickoffMessage(const bool ini_kickoff) : Message("SetKickoffMessage")
00592 {
00593 data_size = sizeof(SetKickoffMessage_data_t);
00594 data_ptr = malloc(data_size);
00595 memset(data_ptr, 0, data_size);
00596 data = (SetKickoffMessage_data_t *)data_ptr;
00597 data_ts = (message_data_ts_t *)data_ptr;
00598 data->kickoff = ini_kickoff;
00599 add_fieldinfo(IFT_BOOL, "kickoff", 1, &data->kickoff);
00600 }
00601
00602 GameStateInterface::SetKickoffMessage::SetKickoffMessage() : Message("SetKickoffMessage")
00603 {
00604 data_size = sizeof(SetKickoffMessage_data_t);
00605 data_ptr = malloc(data_size);
00606 memset(data_ptr, 0, data_size);
00607 data = (SetKickoffMessage_data_t *)data_ptr;
00608 data_ts = (message_data_ts_t *)data_ptr;
00609 add_fieldinfo(IFT_BOOL, "kickoff", 1, &data->kickoff);
00610 }
00611
00612
00613 GameStateInterface::SetKickoffMessage::~SetKickoffMessage()
00614 {
00615 free(data_ptr);
00616 }
00617
00618
00619
00620
00621 GameStateInterface::SetKickoffMessage::SetKickoffMessage(const SetKickoffMessage *m) : Message("SetKickoffMessage")
00622 {
00623 data_size = m->data_size;
00624 data_ptr = malloc(data_size);
00625 memcpy(data_ptr, m->data_ptr, data_size);
00626 data = (SetKickoffMessage_data_t *)data_ptr;
00627 data_ts = (message_data_ts_t *)data_ptr;
00628 }
00629
00630
00631
00632
00633
00634
00635 bool
00636 GameStateInterface::SetKickoffMessage::is_kickoff() const
00637 {
00638 return data->kickoff;
00639 }
00640
00641
00642
00643
00644
00645 size_t
00646 GameStateInterface::SetKickoffMessage::maxlenof_kickoff() const
00647 {
00648 return 1;
00649 }
00650
00651
00652
00653
00654
00655 void
00656 GameStateInterface::SetKickoffMessage::set_kickoff(const bool new_kickoff)
00657 {
00658 data->kickoff = new_kickoff;
00659 }
00660
00661
00662
00663
00664
00665
00666 Message *
00667 GameStateInterface::SetKickoffMessage::clone() const
00668 {
00669 return new GameStateInterface::SetKickoffMessage(this);
00670 }
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681 GameStateInterface::SetStateTeamMessage::SetStateTeamMessage(const if_gamestate_team_t ini_state_team) : Message("SetStateTeamMessage")
00682 {
00683 data_size = sizeof(SetStateTeamMessage_data_t);
00684 data_ptr = malloc(data_size);
00685 memset(data_ptr, 0, data_size);
00686 data = (SetStateTeamMessage_data_t *)data_ptr;
00687 data_ts = (message_data_ts_t *)data_ptr;
00688 data->state_team = ini_state_team;
00689 add_fieldinfo(IFT_ENUM, "state_team", 1, &data->state_team, "if_gamestate_team_t");
00690 }
00691
00692 GameStateInterface::SetStateTeamMessage::SetStateTeamMessage() : Message("SetStateTeamMessage")
00693 {
00694 data_size = sizeof(SetStateTeamMessage_data_t);
00695 data_ptr = malloc(data_size);
00696 memset(data_ptr, 0, data_size);
00697 data = (SetStateTeamMessage_data_t *)data_ptr;
00698 data_ts = (message_data_ts_t *)data_ptr;
00699 add_fieldinfo(IFT_ENUM, "state_team", 1, &data->state_team, "if_gamestate_team_t");
00700 }
00701
00702
00703 GameStateInterface::SetStateTeamMessage::~SetStateTeamMessage()
00704 {
00705 free(data_ptr);
00706 }
00707
00708
00709
00710
00711 GameStateInterface::SetStateTeamMessage::SetStateTeamMessage(const SetStateTeamMessage *m) : Message("SetStateTeamMessage")
00712 {
00713 data_size = m->data_size;
00714 data_ptr = malloc(data_size);
00715 memcpy(data_ptr, m->data_ptr, data_size);
00716 data = (SetStateTeamMessage_data_t *)data_ptr;
00717 data_ts = (message_data_ts_t *)data_ptr;
00718 }
00719
00720
00721
00722
00723
00724
00725 GameStateInterface::if_gamestate_team_t
00726 GameStateInterface::SetStateTeamMessage::state_team() const
00727 {
00728 return data->state_team;
00729 }
00730
00731
00732
00733
00734
00735 size_t
00736 GameStateInterface::SetStateTeamMessage::maxlenof_state_team() const
00737 {
00738 return 1;
00739 }
00740
00741
00742
00743
00744
00745 void
00746 GameStateInterface::SetStateTeamMessage::set_state_team(const if_gamestate_team_t new_state_team)
00747 {
00748 data->state_team = new_state_team;
00749 }
00750
00751
00752
00753
00754
00755
00756 Message *
00757 GameStateInterface::SetStateTeamMessage::clone() const
00758 {
00759 return new GameStateInterface::SetStateTeamMessage(this);
00760 }
00761
00762
00763
00764
00765 bool
00766 GameStateInterface::message_valid(const Message *message) const
00767 {
00768 const SetTeamColorMessage *m0 = dynamic_cast<const SetTeamColorMessage *>(message);
00769 if ( m0 != NULL ) {
00770 return true;
00771 }
00772 const SetKickoffMessage *m1 = dynamic_cast<const SetKickoffMessage *>(message);
00773 if ( m1 != NULL ) {
00774 return true;
00775 }
00776 const SetStateTeamMessage *m2 = dynamic_cast<const SetStateTeamMessage *>(message);
00777 if ( m2 != NULL ) {
00778 return true;
00779 }
00780 return false;
00781 }
00782
00783
00784 EXPORT_INTERFACE(GameStateInterface)
00785
00786
00787
00788 }