00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #include "EnemyManager.hpp"
00020 #include "Singletons.hpp"
00021
00022 #include <boost/format.hpp>
00023 #include <libintl.h>
00024 #define _(string) gettext(string)
00025
00026 bool CEnemyManager::init(std::string filename_waves,
00027 std::string filename_parameter,
00028 global_data_pointers data,
00029 CPlayer *playership,
00030 bool* play_Info,
00031 std::list<SInfo*>* Infos)
00032 {
00033 errorCode error = SUCCESS;
00034
00035 m_Data = data;
00036
00037 p_blend = play_Info;
00038
00039 p_Infos = Infos;
00040
00041 player = playership;
00042
00043
00044 m_activeWave = 0;
00045
00046 error = readParameter(filename_parameter);
00047
00048 switch (error)
00049 {
00050 case FAILED_OPEN:
00051 LOG4CXX_ERROR(log_, boost::format(_("Error while opening File %1%!")) % filename_parameter);
00052 break;
00053 case WRONG_SYNTAX:
00054 LOG4CXX_ERROR(log_, boost::format(_("invalid Syntax in File %1%!")) % filename_parameter);
00055 break;
00056 case MISSING_ATTRIBUTE:
00057 LOG4CXX_ERROR(log_, boost::format(_("Missing Attributes in File %1%!")) % filename_parameter);
00058 break;
00059 }
00060
00061 if (parameter->max_power == 0) parameter->max_power = 4;
00062
00063 error = readFile(filename_waves);
00064
00065 switch (error)
00066 {
00067 case FAILED_OPEN:
00068 LOG4CXX_ERROR(log_, boost::format(_("Error while opening File %1%!")) % filename_waves);
00069 break;
00070 case WRONG_SYNTAX:
00071 LOG4CXX_ERROR(log_, boost::format(_("invalid Syntax in File %1%!")) % filename_waves);
00072 break;
00073 case MISSING_ATTRIBUTE:
00074 LOG4CXX_ERROR(log_, boost::format(_("Missing Attributes in File %1%!")) % filename_waves);
00075 break;
00076 }
00077
00078 m_NextToEvaluate_Enemy = m_ActiveEnemys.end();
00079 m_NextToEvaluate_Ally = m_ActiveAllys.begin();
00080
00081 m_no_fight.sort(less_S_no_fight());
00082
00083 return (error == SUCCESS);
00084 }
00085
00086 bool CEnemyManager::reset()
00087 {
00088 player = NULL;
00089 m_activePower = 0;
00090
00091 std::list<ANPC*>::iterator clear_Iterator = m_ActiveEnemys.begin();
00092
00093
00094
00095 while (clear_Iterator != m_ActiveEnemys.end())
00096 {
00097 if ((*clear_Iterator)) delete (*clear_Iterator);
00098
00099 m_ActiveEnemys.erase(clear_Iterator++);
00100 }
00101
00102 clear_Iterator = m_PassiveEnemys.begin();
00103
00104 while (clear_Iterator != m_PassiveEnemys.end())
00105 {
00106 if ((*clear_Iterator)) delete (*clear_Iterator);
00107
00108 m_PassiveEnemys.erase(clear_Iterator++);
00109 }
00110
00111
00112 clear_Iterator = m_ActiveAllys.begin();
00113
00114 while (clear_Iterator != m_ActiveAllys.end())
00115 {
00116 if ((*clear_Iterator)) delete (*clear_Iterator);
00117 m_ActiveAllys.erase(clear_Iterator++);
00118 }
00119
00120 clear_Iterator = m_PassiveAllys.begin();
00121
00122 while (clear_Iterator != m_PassiveAllys.end())
00123 {
00124 if ((*clear_Iterator)) delete (*clear_Iterator);
00125
00126 m_PassiveAllys.erase(clear_Iterator++);
00127 }
00128
00129
00130 std::list<S_no_fight>::iterator clear_IteratorII = m_no_fight.begin();
00131
00132 while (clear_IteratorII != m_no_fight.end())
00133 {
00134 m_no_fight.erase(clear_IteratorII++);
00135 }
00136
00137 return true;
00138 }
00139
00140 errorCode CEnemyManager::readParameter(std::string filename)
00141 {
00142
00143 AI_parameter* tmp;
00144
00145 float tmp_float;
00146 int tmp_int;
00147
00148 std::string Tag;
00149 std::string Data;
00150 std::string Buffer;
00151
00152 char buffer[255];
00153
00154 FILE* theFile = std::fopen(filename.c_str(),"r");
00155 if(theFile == NULL)
00156 {
00157 return FAILED_OPEN;
00158 }
00159
00160 while(std::feof(theFile) == 0)
00161 {
00162 std::fscanf(theFile, "%s", buffer);
00163
00164 Buffer = buffer;
00165
00166 if (Buffer == "<parameter>")
00167 {
00168 tmp = new AI_parameter;
00169 tmp->sep_x_mult = 50;
00170 tmp->sep_y_mult = 50;
00171 tmp->des_man = 1000;
00172 while (std::fscanf(theFile, "%s", buffer))
00173 {
00174 Buffer = buffer;
00175
00176 if (Buffer == "</parameter>") break;
00177
00178 if (Buffer == "<dist_divisor>")
00179 {
00180 tmp_float = 0;
00181 std::fscanf(theFile, "%f", &tmp_float);
00182 std::fscanf(theFile, "%s", buffer);
00183 Tag = buffer;
00184 if (Tag != "</dist_divisor>")
00185 {
00186 return WRONG_SYNTAX;
00187 }
00188 tmp->dist_divisor = tmp_float;
00189 }
00190
00191 else if (Buffer == "<max_enemy>")
00192 {
00193 tmp_int = 4;
00194 std::fscanf(theFile, "%d", &tmp_int);
00195 std::fscanf(theFile, "%s", buffer);
00196 Tag = buffer;
00197 if (Tag != "</max_enemy>")
00198 {
00199 return WRONG_SYNTAX;
00200 }
00201 if (tmp_int == 0) tmp_int = 128;
00202 tmp->max_power = tmp_int;
00203 }
00204
00205 else if (Buffer == "<player_weight>")
00206 {
00207 tmp_float = 0;
00208 std::fscanf(theFile, "%f", &tmp_float);
00209 std::fscanf(theFile, "%s", buffer);
00210 Tag = buffer;
00211 if (Tag != "</player_weight>")
00212 {
00213 return WRONG_SYNTAX;
00214 }
00215 tmp->player_weight = tmp_float;
00216 }
00217
00218 else if (Buffer == "<searchdepth>")
00219 {
00220 tmp_int = 0;
00221 std::fscanf(theFile, "%d", &tmp_int);
00222 std::fscanf(theFile, "%s", buffer);
00223 Tag = buffer;
00224 if (Tag != "</searchdepth>")
00225 {
00226 return WRONG_SYNTAX;
00227 }
00228 tmp->searchdepth = tmp_int;
00229 }
00230
00231 else if (Buffer == "<des_dist_base>")
00232 {
00233 tmp_int = 0;
00234 std::fscanf(theFile, "%d", &tmp_int);
00235 std::fscanf(theFile, "%s", buffer);
00236 Tag = buffer;
00237 if (Tag != "</des_dist_base>")
00238 {
00239 return WRONG_SYNTAX;
00240 }
00241 tmp->des_dist_base = tmp_int;
00242 }
00243
00244 else if (Buffer == "<des_dist_var>")
00245 {
00246 tmp_int = 0;
00247 std::fscanf(theFile, "%d", &tmp_int);
00248 std::fscanf(theFile, "%s", buffer);
00249 Tag = buffer;
00250 if (Tag != "</des_dist_var>")
00251 {
00252 return WRONG_SYNTAX;
00253 }
00254 tmp->des_dist_var = tmp_int;
00255 }
00256
00257 else if (Buffer == "<des_x_var>")
00258 {
00259 tmp_int = 0;
00260 std::fscanf(theFile, "%d", &tmp_int);
00261 std::fscanf(theFile, "%s", buffer);
00262 Tag = buffer;
00263 if (Tag != "</des_x_var>")
00264 {
00265 return WRONG_SYNTAX;
00266 }
00267 tmp->des_x_var = tmp_int;
00268 }
00269
00270 else if (Buffer == "<pause>")
00271 {
00272 tmp_int = 0;
00273 std::fscanf(theFile, "%d", &tmp_int);
00274 std::fscanf(theFile, "%s", buffer);
00275 Tag = buffer;
00276 if (Tag != "</pause>")
00277 {
00278 return WRONG_SYNTAX;
00279 }
00280 tmp->pause = tmp_int;
00281 }
00282
00283 else if (Buffer == "<sensibility_x>")
00284 {
00285 tmp_int = 0;
00286 std::fscanf(theFile, "%d", &tmp_int);
00287 std::fscanf(theFile, "%s", buffer);
00288 Tag = buffer;
00289 if (Tag != "</sensibility_x>")
00290 {
00291 return WRONG_SYNTAX;
00292 }
00293 tmp->sensibility_x = tmp_int;
00294 }
00295
00296 else if (Buffer == "<sensibility_y>")
00297 {
00298 tmp_int = 0;
00299 std::fscanf(theFile, "%d", &tmp_int);
00300 std::fscanf(theFile, "%s", buffer);
00301 Tag = buffer;
00302 if (Tag != "</sensibility_y>")
00303 {
00304 return WRONG_SYNTAX;
00305 }
00306 tmp->sensibility_y = tmp_int;
00307 }
00308
00309 else if (Buffer == "<des_x_heavy>")
00310 {
00311 tmp_float = 0;
00312 std::fscanf(theFile, "%f", &tmp_float);
00313 std::fscanf(theFile, "%s", buffer);
00314 Tag = buffer;
00315
00316 if (Tag != "</des_x_heavy>")
00317 {
00318 return WRONG_SYNTAX;
00319 }
00320 tmp->des_x_heavy = tmp_float;
00321 }
00322
00323 else if (Buffer == "<sep_x_mult>")
00324 {
00325 tmp_int = 0;
00326 std::fscanf(theFile, "%d", &tmp_int);
00327 std::fscanf(theFile, "%s", buffer);
00328 Tag = buffer;
00329 if (Tag != "</sep_x_mult>")
00330 {
00331 return WRONG_SYNTAX;
00332 }
00333 tmp->sep_x_mult = tmp_int;
00334 }
00335
00336 else if (Buffer == "<sep_y_mult>")
00337 {
00338 tmp_int = 0;
00339 std::fscanf(theFile, "%d", &tmp_int);
00340 std::fscanf(theFile, "%s", buffer);
00341 Tag = buffer;
00342 if (Tag != "</sep_y_mult>")
00343 {
00344 return WRONG_SYNTAX;
00345 }
00346 tmp->sep_y_mult = tmp_int;
00347 }
00348
00349 else if (Buffer == "<des_man>")
00350 {
00351 tmp_int = 0;
00352 std::fscanf(theFile, "%d", &tmp_int);
00353 std::fscanf(theFile, "%s", buffer);
00354 Tag = buffer;
00355 if (Tag != "</des_man>")
00356 {
00357 return WRONG_SYNTAX;
00358 }
00359 tmp->des_man = tmp_int;
00360 }
00361
00362
00363 else if (Buffer == "<!--")
00364 {
00365 do
00366 {
00367 std::fscanf(theFile, "%s", buffer);
00368 Buffer = buffer;
00369 }
00370 while(Buffer != "-->");
00371 }
00372 parameter = tmp;
00373 }
00374
00375 if (Buffer != "</parameter>")
00376 {
00377 return WRONG_SYNTAX;
00378 }
00379 }
00380 else if (Buffer == "<!--")
00381 {
00382 do
00383 {
00384 std::fscanf(theFile, "%s", buffer);
00385 Buffer = buffer;
00386 }
00387 while(Buffer != "-->");
00388 }
00389 else if (Buffer == "<strength>")
00390 {
00391 while (std::fscanf(theFile, "%s", buffer))
00392 {
00393 Buffer = buffer;
00394
00395 if (Buffer == "</strength>") break;
00396
00397 if (Buffer == "<default>")
00398 {
00399 while (std::fscanf(theFile, "%s", buffer))
00400 {
00401 Buffer = buffer;
00402
00403 int i;
00404 bonus *tmp;
00405 tmp = new bonus;
00406
00407 if (Buffer == "</default>") break;
00408
00409 else if (Buffer == "<firedist>")
00410 {
00411 std::fscanf(theFile, "%d", &m_strength[0].firedist);
00412 for (i = 1; i < 10; i++)
00413 m_strength[i].firedist = m_strength[0].firedist;
00414
00415 std::fscanf(theFile, "%s", buffer);
00416 Buffer = buffer;
00417
00418 if (Buffer != "</firedist>") return WRONG_SYNTAX;
00419 }
00420 else if (Buffer == "<bonus")
00421 {
00422 std::fscanf(theFile, "%s", buffer);
00423 std::sscanf(buffer, "id=\"%d\">", &tmp->id);
00424 std::fscanf(theFile, "%d", &tmp->number);
00425 for (i = 0; i < 10; i++)
00426 m_strength[i].boni.push_back(new bonus(*tmp));
00427
00428 std::fscanf(theFile, "%s", buffer);
00429 Buffer = buffer;
00430 if (Buffer != "</bonus>") return WRONG_SYNTAX;
00431 }
00432 }
00433 }
00434 else if (Buffer == "<enemy")
00435 {
00436 int enemy = 0;
00437
00438 std::fscanf(theFile, "%s", buffer);
00439 std::sscanf(buffer, "str=\"%d\">", &enemy);
00440 (enemy < 50) ? enemy -= 1 : enemy -= 96;
00441
00442 std::list<bonus*>::iterator clIt = m_strength[enemy].boni.begin();
00443
00444 while (clIt != m_strength[enemy].boni.end())
00445 {
00446 delete *clIt;
00447 m_strength[enemy].boni.erase(clIt++);
00448 }
00449
00450
00451 while (std::fscanf(theFile, "%s", buffer))
00452 {
00453 bonus *tmp;
00454 tmp = new bonus;
00455 Buffer = buffer;
00456
00457 if (Buffer == "</enemy>") break;
00458
00459 else if (Buffer == "<firedist>")
00460 {
00461 std::fscanf(theFile, "%d", &m_strength[enemy].firedist);
00462
00463 std::fscanf(theFile, "%s", buffer);
00464 Buffer = buffer;
00465
00466 if (Buffer != "</firedist>") return WRONG_SYNTAX;
00467 }
00468 else if (Buffer == "<bonus")
00469 {
00470 std::fscanf(theFile, "%s", buffer);
00471 std::sscanf(buffer, "id=\"%d\">", &tmp->id);
00472 std::fscanf(theFile, "%d", &tmp->number);
00473 std::fscanf(theFile, "%s", buffer);
00474 m_strength[enemy].boni.push_back(tmp);
00475 Buffer = buffer;
00476 if (Buffer != "</bonus>") return WRONG_SYNTAX;
00477 }
00478 }
00479 }
00480
00481 }
00482 }
00483 else if (Buffer == "</parameter>")
00484 {
00485 #ifndef NO_DEBUG
00486 m_Console->printString("CEnemyManager::readParameter:\nÜberzähliges </parameter>\n");
00487 #endif
00488 }
00489 else if (Buffer == "</strength>")
00490 {
00491 #ifndef NO_DEBUG
00492 m_Console->printString("CEnemyManager::readParameter:\nÜberzähliges </parameter>\n");
00493 #endif
00494 }
00495 else
00496 {
00497 return WRONG_SYNTAX;
00498 }
00499 }
00500 fclose(theFile);
00501 return SUCCESS;
00502 }
00503
00504
00505
00506 errorCode CEnemyManager::readFile(std::string filename)
00507 {
00508
00509
00510 int waves = 0;
00511 int ships = 0;
00512
00513
00514 char buffer[255];
00515
00516 std::string Tag;
00517 std::string Data;
00518 std::string Buffer;
00519
00520 int posx, posy;
00521 std::string shipfile;
00522 std::string powerupfile;
00523 CEnemy::Strength theStrength;
00524 unsigned starttime = 0;
00525
00526 S_no_fight nfTmp;
00527
00528 FILE* theFile = std::fopen(filename.c_str(),"r");
00529 if(theFile == NULL)
00530 {
00531 return FAILED_OPEN;
00532 }
00533
00534 while(feof(theFile) == 0)
00535 {
00536 std::fscanf(theFile, "%s", buffer);
00537
00538 Buffer = buffer;
00539
00540 if (Buffer == "<wave")
00541 {
00542 std::fscanf(theFile, "%s", buffer);
00543 Buffer = buffer;
00544 if (Buffer.find("time=\"") == 0)
00545 {
00546 if (Buffer.length() < 8) return UNEXPECTED_ENDING;
00547 std::sscanf(Buffer.c_str(), "time=\"%d\"", &starttime);
00548
00549 if (Buffer[Buffer.length() - 1] != '>')
00550 {
00551 std::fscanf(theFile, "%s", buffer);
00552 Buffer = buffer;
00553 if (Buffer.find("neutral=\"") == 0)
00554 {
00555 if (Buffer.length() < 11) return UNEXPECTED_ENDING;
00556 std::sscanf(Buffer.c_str(), "neutral=\"%d\"", &nfTmp.end);
00557
00558 nfTmp.end *= 1000;
00559 nfTmp.begin = starttime * 1000;
00560 m_no_fight.push_back(nfTmp);
00561 }
00562 else return WRONG_SYNTAX;
00563 }
00564 }
00565 else if (Buffer.find("neutral=\"") == 0)
00566 {
00567 if (Buffer.length() < 11) return UNEXPECTED_ENDING;
00568 std::sscanf(Buffer.c_str(), "neutral=\"%d\"", &nfTmp.end);
00569
00570 nfTmp.end *= 1000;
00571
00572 std::fscanf(theFile, "%s", buffer);
00573 Buffer = buffer;
00574 if (Buffer.find("time=\"") == 0)
00575 {
00576 if (Buffer.length() < 8) return UNEXPECTED_ENDING;
00577 std::sscanf(Buffer.c_str(), "time=\"%d\"", &nfTmp.begin);
00578 nfTmp.begin *= 1000;
00579
00580 m_no_fight.push_back(nfTmp);
00581 }
00582 else return WRONG_SYNTAX;
00583 }
00584 else return WRONG_SYNTAX;
00585 if(starttime > 0)
00586 {
00587 while(std::feof(theFile) == 0)
00588 {
00589 std::fscanf(theFile, "%s", buffer);
00590 Buffer = buffer;
00591 while (Buffer == "<enemy>" || Buffer == "<!--" || Buffer == "<ally>" || Buffer == "<info>")
00592 {
00593 if (Buffer == "<!--")
00594 {
00595 do
00596 {
00597 std::fscanf(theFile, "%s", buffer);
00598 Buffer = buffer;
00599 }
00600 while(Buffer != "-->");
00601 }
00602 else if (Buffer == "<enemy>")
00603 {
00604 shipfile = "Ships/Bummer.txt";
00605 theStrength = CEnemy::EMPTY;
00606 posx = 0;
00607 posy = 1;
00608 powerupfile = "";
00609 while (std::fscanf(theFile, "%s", buffer))
00610 {
00611 Buffer = buffer;
00612
00613 if (Buffer == "</enemy>") break;
00614
00615 if (Buffer == "<strength>")
00616 {
00617 std::fscanf(theFile, "%d", &theStrength);
00618 std::fscanf(theFile, "%s", buffer);
00619 Tag = buffer;
00620 if (Tag != "</strength>")
00621 {
00622 return WRONG_SYNTAX;
00623 }
00624 }
00625 else if (Buffer == "<posx>")
00626 {
00627 std::fscanf(theFile, "%d", &posx);
00628 std::fscanf(theFile, "%s", buffer);
00629 Tag = buffer;
00630 if (Tag != "</posx>")
00631 {
00632 return WRONG_SYNTAX;
00633 }
00634 }
00635 else if (Buffer == "<posy>")
00636 {
00637 std::fscanf(theFile, "%d", &posy);
00638 std::fscanf(theFile, "%s", buffer);
00639 Tag = buffer;
00640 if (Tag != "</posy>")
00641 {
00642 return WRONG_SYNTAX;
00643 }
00644 }
00645 else if (Buffer == "<shiptype>")
00646 {
00647 std::fscanf(theFile, "%s", buffer);
00648 shipfile = buffer;
00649 std::fscanf(theFile, "%s", buffer);
00650 Tag = buffer;
00651 if (Tag != "</shiptype>")
00652 {
00653 return WRONG_SYNTAX;
00654 }
00655 }
00656 else if (Buffer == "<powerup>")
00657 {
00658 std::fscanf(theFile, "%s", buffer);
00659 powerupfile = buffer;
00660 std::fscanf(theFile, "%s", buffer);
00661 Tag = buffer;
00662 if (Tag != "</powerup>")
00663 {
00664 return WRONG_SYNTAX;
00665 }
00666 }
00667 else if (Buffer == "<!--")
00668 {
00669 do
00670 {
00671 std::fscanf(theFile, "%s", buffer);
00672 Buffer = buffer;
00673 }
00674 while(Buffer != "-->");
00675 }
00676 }
00677 if (posx && posy && (theStrength != CEnemy::EMPTY) && (shipfile != ""))
00678 {
00679 m_PassiveEnemys.push_back(new CEnemy(starttime, posx, posy, theStrength, shipfile, powerupfile, parameter));
00680 }
00681 else
00682 {
00683 return MISSING_ATTRIBUTE;
00684 }
00685 ships++;
00686 }
00687 else if (Buffer == "<ally>")
00688 {
00689 shipfile = "Ships/Bummer.txt";
00690 theStrength = CEnemy::EMPTY;
00691 posx = 0;
00692 posy = 1;
00693 powerupfile = "";
00694 while (std::fscanf(theFile, "%s", buffer))
00695 {
00696 Buffer = buffer;
00697
00698 if (Buffer == "</ally>") break;
00699
00700 if (Buffer == "<strength>")
00701 {
00702 std::fscanf(theFile, "%d", &theStrength);
00703 std::fscanf(theFile, "%s", buffer);
00704 Tag = buffer;
00705 if (Tag != "</strength>")
00706 {
00707 std::printf ("strength\n");
00708 return WRONG_SYNTAX;
00709 }
00710 }
00711 else if (Buffer == "<posx>")
00712 {
00713 std::fscanf(theFile, "%d", &posx);
00714 std::fscanf(theFile, "%s", buffer);
00715 Tag = buffer;
00716 if (Tag != "</posx>")
00717 {
00718 std::printf ("posx\n");
00719 return WRONG_SYNTAX;
00720 }
00721 }
00722 else if (Buffer == "<posy>")
00723 {
00724 std::fscanf(theFile, "%d", &posy);
00725 std::fscanf(theFile, "%s", buffer);
00726 Tag = buffer;
00727 if (Tag != "</posy>")
00728 {
00729 std::printf ("posy\n");
00730 return WRONG_SYNTAX;
00731 }
00732 }
00733 else if (Buffer == "<shiptype>")
00734 {
00735 std::fscanf(theFile, "%s", buffer);
00736 shipfile = buffer;
00737 std::fscanf(theFile, "%s", buffer);
00738 Tag = buffer;
00739 if (Tag != "</shiptype>")
00740 {
00741 std::printf ("shiptype\n");
00742 return WRONG_SYNTAX;
00743 }
00744 }
00745 else if (Buffer == "<!--")
00746 {
00747 do
00748 {
00749 std::fscanf(theFile, "%s", buffer);
00750 Buffer = buffer;
00751 }
00752 while(Buffer != "-->");
00753 }
00754 }
00755 if (posx && posy && (theStrength != CEnemy::EMPTY) && (shipfile != ""))
00756 {
00757 CAlly* tmp = new CAlly(starttime, posx, posy, theStrength, shipfile, parameter);
00758 m_PassiveAllys.push_back(tmp);
00759 }
00760 else
00761 {
00762 return MISSING_ATTRIBUTE;
00763 }
00764 ships++;
00765 }
00766 else if (Buffer == "<info>")
00767 {
00768 std::string content;
00769 std::string image;
00770 int framecount = 4, frameofset = 4;
00771 char buffer[255];
00772 while (!feof(theFile))
00773 {
00774 std::fscanf(theFile, "%s", buffer);
00775 Buffer = buffer;
00776
00777 if (Buffer == "</info>") break;
00778
00779 if (Buffer == "<content>")
00780 {
00781 while (!feof(theFile))
00782 {
00783
00784 std::fscanf(theFile, "%s", buffer);
00785 Buffer = buffer;
00786
00787 if (Buffer == "</content>") break;
00788
00789 content += " " + Buffer;
00790 }
00791 }
00792 else if (Buffer == "<image>")
00793 {
00794 while (!feof(theFile))
00795 {
00796 std::fscanf(theFile, "%s", buffer);
00797 Buffer = buffer;
00798
00799 if (Buffer == "</image>") break;
00800
00801 if (Buffer == "<file>")
00802 {
00803 std::fscanf(theFile, "%s", buffer);
00804 image = buffer;
00805 std::fscanf(theFile, "%s", buffer);
00806 Buffer = buffer;
00807 if (Buffer != "</file>") return WRONG_SYNTAX;
00808 }
00809 else if (Buffer == "<framecount>")
00810 {
00811 std::fscanf(theFile, "%d", &framecount);
00812 std::fscanf(theFile, "%s", buffer);
00813 Buffer = buffer;
00814 if (Buffer != "</framecount>") return WRONG_SYNTAX;
00815 }
00816 else if (Buffer == "<frameofset>")
00817 {
00818 std::fscanf(theFile, "%d", &frameofset);
00819 std::fscanf(theFile, "%s", buffer);
00820 Buffer = buffer;
00821 if (Buffer != "</frameofset>") return WRONG_SYNTAX;
00822 }
00823 else if (Buffer == "<!--")
00824 {
00825 do
00826 {
00827 std::fscanf(theFile, "%s", buffer);
00828 Buffer = buffer;
00829 }
00830 while(Buffer != "-->");
00831 }
00832 else return WRONG_SYNTAX;
00833 }
00834
00835 }
00836 else if (Buffer == "<!--")
00837 {
00838 do
00839 {
00840 std::fscanf(theFile, "%s", buffer);
00841 Buffer = buffer;
00842 }
00843 while(Buffer != "-->");
00844 }
00845 else return WRONG_SYNTAX;
00846 }
00847 if ( image == "") image = "data/gfx/statik.png";
00848 m_Infos.push_back(new SInfo(content, image, starttime, framecount, frameofset));
00849 }
00850
00851 std::fscanf(theFile, "%s", buffer);
00852 Buffer = buffer;
00853 }
00854 if (Buffer == "</wave>")
00855 {
00856 break;
00857 }
00858 else
00859 {
00860 std::cout << Buffer << std::endl;
00861 return WRONG_SYNTAX;
00862 }
00863 }
00864 }
00865 else
00866 {
00867 return WRONG_SYNTAX;
00868 }
00869 waves++;
00870 }
00871
00872 else if (Buffer == "<!--")
00873 {
00874 do
00875 {
00876 std::fscanf(theFile, "%s", buffer);
00877 Buffer = buffer;
00878 }
00879 while(Buffer != "-->");
00880 }
00881 else if (Buffer == "</wave>")
00882 {
00884 LOG4CXX_DEBUG(log_, _("CEnemyManager::readFile:\nÜberzähliges </wave>\n"));
00885 }
00886 else
00887 {
00888 return WRONG_SYNTAX;
00889 }
00890 }
00891 fclose(theFile);
00892
00893 return SUCCESS;
00894 }
00895
00896
00897
00898
00899
00900
00901 bool CEnemyManager::update()
00902 {
00903 unsigned time = sgl::get_clock().GetElapsedTime();
00904
00905 bool fight;
00906
00907 std::list<S_no_fight>::iterator S_n_f_i = m_no_fight.begin();
00908 while (S_n_f_i != m_no_fight.end() && S_n_f_i->end < m_activeWave)
00909 {
00910 m_no_fight.erase(S_n_f_i++);
00911 }
00912
00913 if (m_no_fight.size())
00914 {
00915 fight = (m_no_fight.begin()->begin >= m_activeWave);
00916 }
00917 else
00918 {
00919 fight = true;
00920 }
00921
00922 std::list<ANPC*>::iterator enemyIterator;
00923
00924 if ((m_activePower == 0 || !fight) && *p_blend == false)
00925 {
00926
00927 if (m_Infos.size() > 0)
00928 {
00929 if(m_PassiveEnemys.size())
00930 {
00931 int earliest = time;
00932 enemyIterator = m_PassiveEnemys.begin();
00933 while(true)
00934 {
00935 if ((*enemyIterator)->getStarttime() < m_activeWave)
00936 {
00937 break;
00938 }
00939 else
00940 {
00941 if ((*enemyIterator)->getStarttime() < earliest) earliest = (*enemyIterator)->getStarttime();
00942 enemyIterator++;
00943 }
00944 if(enemyIterator == m_PassiveEnemys.end())
00945 {
00946 m_activeWave = earliest + 1;
00947 break;
00948 }
00949 }
00950 }
00951 else
00952 {
00953 m_activeWave = time;
00954 }
00955
00956 std::list<SInfo*>::iterator tmp = m_Infos.begin();
00957
00958
00959 while(tmp != m_Infos.end() && (*tmp)->time < m_activeWave)
00960 {
00961 tmp++;
00962 }
00963 if (tmp != ++(m_Infos.end()) && tmp != m_Infos.begin())
00964 {
00965 p_Infos->splice(p_Infos->begin(), m_Infos, m_Infos.begin(), tmp);
00966 *p_blend = true;
00967 }
00968 else
00969 {
00970
00971 }
00972 }
00973 else
00974 {
00975 if (m_PassiveEnemys.size())
00976 {
00977 int earliest = time;
00978 enemyIterator = m_PassiveEnemys.begin();
00979 while(true)
00980 {
00981 if ((*enemyIterator)->getStarttime() < m_activeWave)
00982 {
00983 break;
00984 }
00985 else
00986 {
00987 if ((*enemyIterator)->getStarttime() < earliest) earliest = (*enemyIterator)->getStarttime();
00988 enemyIterator++;
00989 }
00990 if(enemyIterator == m_PassiveEnemys.end())
00991 {
00992 m_activeWave = earliest + 1;
00993 break;
00994 }
00995 }
00996 }
00997 else
00998 {
00999 m_activeWave = time;
01000 }
01001 }
01002 }
01003
01004
01005 if (!(*p_blend) && m_activePower < parameter->max_power)
01006 {
01007 enemyIterator = m_PassiveEnemys.begin();
01008 while(enemyIterator != m_PassiveEnemys.end())
01009 {
01010 int power;
01011 if ((*enemyIterator)->getStarttime() < m_activeWave && (power = (*enemyIterator)->getPower()) <= (parameter->max_power - m_activePower))
01012 {
01013 ((CEnemy*)(*enemyIterator))->init(m_Data, player, getStrength((*enemyIterator)->getStrength()));
01014 m_activePower += power;
01015 m_ActiveEnemys.splice(m_ActiveEnemys.begin(), m_PassiveEnemys, enemyIterator++);
01016 }
01017 else
01018 {
01019 enemyIterator++;
01020 }
01021 }
01022 }
01023
01024
01025 enemyIterator = m_PassiveAllys.begin();
01026 while(!(*p_blend) && enemyIterator != m_PassiveAllys.end())
01027 {
01028 if ((*enemyIterator)->getStarttime() < m_activeWave)
01029 {
01030 ((CAlly*)(*enemyIterator))->init(m_Data, getStrength((*enemyIterator)->getStrength()));
01031 m_ActiveAllys.splice(m_ActiveAllys.begin(), m_PassiveAllys, enemyIterator++);
01032 }
01033 else
01034 {
01035 enemyIterator++;
01036 }
01037 }
01038
01039
01040 std::list<ANPC*>::iterator col_test;
01041
01042 enemyIterator = m_ActiveEnemys.begin();
01043
01044
01045 while(enemyIterator != m_ActiveEnemys.end())
01046 {
01047 fight ? (*enemyIterator)->update(m_owned_ally) : (*enemyIterator)->update(m_bs_empty);
01048
01049 (*enemyIterator)->Draw();
01050 if(fight)
01051 {
01052 (*enemyIterator)->getShip()->CheckCollision(player->GetShip());
01053 player->CheckCollision((*enemyIterator)->getShip());
01054 }
01055
01056 col_test = m_ActiveAllys.begin();
01057 if(fight)
01058 {
01059 while (col_test != m_ActiveAllys.end())
01060 {
01061 (*col_test)->getShip()->CheckCollision((*enemyIterator)->getShip());
01062 (*enemyIterator)->getShip()->CheckCollision((*col_test)->getShip());
01063 col_test++;
01064 }
01065 }
01066
01067
01068
01069 if ((*enemyIterator)->getShip()->CanBeRemoved())
01070 {
01071 if (m_NextToEvaluate_Enemy == enemyIterator)
01072 m_NextToEvaluate_Enemy++;
01073 if (((CEnemy*)(*enemyIterator))->getPowerUp() != "")
01074 {
01075 CPowerUp* tmp_powerup = new CPowerUp();
01076 tmp_powerup->Init(((CEnemy*)(*enemyIterator))->getPowerUp());
01077 tmp_powerup->SetPosition((*enemyIterator)->getShip()->GetXPosition(), (*enemyIterator)->getShip()->GetYPosition());
01078
01079 m_PowerUps.push_back(tmp_powerup);
01080 }
01081 m_activePower -= (*enemyIterator)->getPower();
01082 delete *enemyIterator;
01083 m_ActiveEnemys.erase(enemyIterator++);
01084 }
01085 else
01086 {
01087 enemyIterator++;
01088 }
01089 }
01090
01091 enemyIterator = m_ActiveAllys.begin();
01092
01093 while(enemyIterator != m_ActiveAllys.end())
01094 {
01095 fight ? (*enemyIterator)->update(m_owned_enemy) : (*enemyIterator)->update(m_bs_empty);
01096
01097 (*enemyIterator)->Draw();
01098
01099
01100 col_test = m_ActiveEnemys.begin();
01101 if (fight)
01102 {
01103 while (col_test != m_ActiveEnemys.end())
01104 {
01105 (*col_test)->getShip()->CheckCollision((*enemyIterator)->getShip());
01106 (*enemyIterator)->getShip()->CheckCollision((*col_test)->getShip());
01107 col_test++;
01108 }
01109 }
01110
01111
01112 if ((*enemyIterator)->getShip()->CanBeRemoved())
01113 {
01114 if (m_NextToEvaluate_Ally == enemyIterator)
01115 m_NextToEvaluate_Ally++;
01116
01117 delete *enemyIterator;
01118 m_ActiveAllys.erase(enemyIterator++);
01119 }
01120 else
01121 {
01122 enemyIterator++;
01123 }
01124 }
01125
01126
01127 if (m_ActiveEnemys.size())
01128 {
01129 if (m_NextToEvaluate_Enemy == m_ActiveEnemys.end())
01130 {
01131 m_regProjectiles_Ally.clear();
01132 registerProjectiles(m_ActiveAllys, m_regProjectiles_Ally);
01133 registerProjectiles();
01134 m_owned_ally.reset();
01135 update_owned(m_ActiveAllys, m_owned_ally);
01136 update_owned();
01137 m_NextToEvaluate_Enemy = m_ActiveEnemys.begin();
01138 }
01139 else
01140 {
01141 (*m_NextToEvaluate_Enemy++)->calculate(m_fancy, m_regProjectiles_Ally, m_ActiveAllys, m_ActiveEnemys);
01142 }
01143 }
01144 if (m_ActiveAllys.size())
01145 {
01146 if (m_NextToEvaluate_Ally == m_ActiveAllys.end())
01147 {
01148 m_regProjectiles_Enemy.clear();
01149 registerProjectiles(m_ActiveEnemys, m_regProjectiles_Enemy);
01150
01151 m_owned_enemy.reset();
01152 update_owned(m_ActiveEnemys, m_owned_enemy);
01153
01154 m_NextToEvaluate_Ally = m_ActiveAllys.begin();
01155 }
01156 else
01157 {
01158 (*m_NextToEvaluate_Ally++)->calculate(m_fancy, m_regProjectiles_Enemy, m_ActiveEnemys, m_ActiveAllys);
01159 }
01160 }
01161
01162 std::list<CPowerUp*>::iterator powerupIterator = m_PowerUps.begin();
01163 while(powerupIterator != m_PowerUps.end())
01164 {
01165 (*powerupIterator)->Update();
01166 (*powerupIterator)->Draw();
01167 if(player->CheckCollision(*powerupIterator))
01168 {
01169 delete *powerupIterator;
01170 m_PowerUps.erase(powerupIterator++);
01171 }
01172 else
01173 {
01174 powerupIterator++;
01175 }
01176 }
01177 return true;
01178 }
01179
01180 void CEnemyManager::registerProjectiles()
01181 {
01182 int i;
01183 projectileData tmp;
01184
01185 m_regProjectiles_Ally.clear();
01186
01187 for (i = 0; i < player->GetProjectilCount(); i++)
01188 {
01189 tmp.posx = player->GetProjectilX(i);
01190 tmp.posy = player->GetProjectilY(i);
01191 tmp.damage = player->GetProjectilDamage(i);
01192 tmp.width = player->GetProjectilWidth(i);
01193 m_regProjectiles_Ally.push_back(tmp);
01194 }
01195 }
01196
01197 void CEnemyManager::registerProjectiles(std::list<ANPC*>& source, std::list<projectileData>& dest)
01198 {
01199 int i;
01200 projectileData tmpD;
01201
01202 dest.clear();
01203
01204 std::list<ANPC*>::iterator tmp = source.begin();
01205 while (tmp != source.end())
01206 {
01207 for (i = 0; i < (*tmp)->getShip()->GetProjectilCount(); i++)
01208 {
01209 tmpD.posx = (*tmp)->getShip()->GetProjectilXPosition(i);
01210 tmpD.posy = (*tmp)->getShip()->GetProjectilYPosition(i);
01211 tmpD.damage = (*tmp)->getShip()->GetProjectilDamage(i);
01212 tmpD.width = (*tmp)->getShip()->GetProjectilWidth(i);
01213 dest.push_back(tmpD);
01214 }
01215 tmp++;
01216 }
01217 }
01218
01219 void CEnemyManager::update_owned(std::list<ANPC*>& source, std::bitset<(SCREEN_X_SIZE - HUD_SIZE_X)>& dest)
01220 {
01221 std::list<ANPC*>::iterator tmp = source.begin();
01222 while (tmp != source.end())
01223 {
01224 for (int i = (*tmp)->getShip()->GetXPosition() - (*tmp)->getShip()->GetCollisionSystemWidth()/2;
01225 i < (*tmp)->getShip()->GetXPosition() + (*tmp)->getShip()->GetCollisionSystemWidth()/2;
01226 i++)
01227 {
01228 if (i > -1 && i < 800)
01229 dest.set(i);
01230 }
01231 tmp++;
01232 }
01233 }
01234
01235 void CEnemyManager::update_owned()
01236 {
01237 for (int i = player->GetShip()->GetXPosition() - player->GetShip()->GetCollisionSystemWidth()/2;
01238 i < player->GetShip()->GetXPosition() + player->GetShip()->GetCollisionSystemWidth()/2;
01239 i++)
01240 {
01241 if (i > -1 && i < (SCREEN_X_SIZE - HUD_SIZE_X))
01242 {
01243 m_owned_ally.set(i);
01244 }
01245 }
01246 }
01247
01248 strength* CEnemyManager::getStrength(int level)
01249 {
01250 strength * tmp;
01251 if (level > 105 || level < 1)
01252 {
01253 LOG4CXX_ERROR(log_, _("BAD Value!"));
01254 return NULL;
01255 }
01256 else
01257 {
01258 int ttp = (level < 50) ? (level - 1) : (level-96);
01259 tmp = &m_strength[ttp];
01260
01261 if (tmp == NULL)
01262 {
01263 LOG4CXX_ERROR(log_, _("BAD Data"));
01264 }
01265 return tmp;
01266 }
01267 }
01268
01269 int CEnemyManager::clearPowerups()
01270 {
01271 int i = 0;
01272 std::list<CPowerUp*>::iterator IT = m_PowerUps.begin();
01273 while (IT != m_PowerUps.end())
01274 {
01275 i++;
01276 delete (*IT);
01277 m_PowerUps.erase(IT++);
01278 }
01279 return i;
01280 }