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