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 "ExManagerConsole.h"
00025
00026 bool ExManagerConsole::m_flag = false;
00027 ExManagerConsole* ExManagerConsole::m_instance = NULL;
00028
00029 ExManagerConsole* ExManagerConsole::CreateSingleton(void){
00030 Guard(ExManagerConsole* ExManagerConsole::CreateSingleton(void))
00031 if(!m_flag)
00032 {
00033 m_flag = true;
00034 m_instance = new ExManagerConsole;
00035 }else
00036 {
00037 std::cout<<"Error singleton already created"<<std::endl;
00038 }
00039 return m_instance;
00040 UnGuard
00041 }
00042
00043 ExManagerConsole::ExManagerConsole(void)
00044 {
00045 Guard(ExManagerConsole::ExManagerConsole(void))
00046 m_ConsoleState=HIDE;
00047 m_LineCounter=2;
00048 PosIntoBuffOldCommand=0;
00049 m_ConsoleTransPalier=20;
00050 m_fBlending=0.3f;
00051 m_fBackGroundBlue=1.0f;
00052 m_fBackGroundRed=1.0f;
00053 m_fBackGroundGreen=1.0f;
00054 console_move = false;
00055 m_BackGroundTextureState=true;
00056 m_Blending = false;
00057 LogConsol =true;
00058 m_AskForCommand=true;
00059 m_Move=0;
00060 #ifdef UNIX_SRC
00061 logfilecsl.open("/tmp/logConsol.txt",ios::out);
00062 #else
00063 logfilecsl.open("logConsol.txt",ios::out);
00064 #endif
00065 logfilecsl.close();
00066 SetStatus(false);
00067 SetAskForCommand(false);
00068 SetAskForExclusifCommand(false);
00069 UnGuard
00070 }
00071
00072
00073 void ExManagerConsole::Reset(void)
00074 {
00075 Guard(ExManagerConsole::Reset(void))
00076 m_ConsoleState=HIDE;
00077 m_LineCounter=2;
00078 PosIntoBuffOldCommand=0;
00079 m_ConsoleTransPalier=20;
00080
00081 m_VecStringAction.clear();
00082
00083 console_move = false;
00084 UnGuard
00085 }
00086
00087 ExManagerConsole::~ExManagerConsole(void)
00088 {
00089 Guard(ExManagerConsole::~ExManagerConsole(void))
00090 UnGuard
00091 }
00092
00093 void ExManagerConsole::Init(void)
00094 {
00095 Guard(void ExManagerConsole::init(void))
00096 SetConsoleBackGroudTexture("back.bmp");
00097 UnGuard
00098 }
00099
00100
00101 void ExManagerConsole::SetConsoleBackGroudTexture(std::string FileName)
00102 {
00103 Guard(void ExManagerConsole::SetConsoleBackGroudTexture(std::string FileName))
00104 if(ManagerTexture->Add(FileName))m_BackGroundTexture=FileName;
00105 UnGuard
00106 }
00107 void ExManagerConsole::Draw(void)
00108 {
00109 Guard(void ExManagerConsole::Draw(void))
00110 if(!GetStatus())return;
00111 int i=0;
00112 float textcoordy=0;
00113 float cordy=0;
00114 char buffer[80];
00115 sprintf(buffer,"version %s ",VERSION);
00116
00117 char bufferdata[255];
00118 sprintf(bufferdata,"]%s",m_BuffCommand.data());
00119
00120 switch(m_ConsoleState)
00121 {
00122 case HIDE:
00123 SetStatus(false);
00124 break;
00125
00126 case HALF:
00127 textcoordy=0.5f;
00128 cordy=ManagerWindow->GetResolutionY()/2;
00129 break;
00130
00131 case FULL:
00132 textcoordy=1.0f;
00133 cordy=ManagerWindow->GetResolutionY();
00134 break;
00135
00136 case HIDETOHALF:
00137
00138 textcoordy=(1.0f/m_ConsoleTransPalier)*m_ConsoleTrans;
00139 cordy=(ManagerWindow->GetResolutionY()/m_ConsoleTransPalier)*m_ConsoleTrans;
00140 m_ConsoleTrans++;
00141 if(cordy>((ManagerWindow->GetResolutionY()/2)-(ManagerWindow->GetResolutionY()/m_ConsoleTransPalier)))
00142 {
00143 m_ConsoleState=m_NextConsoleState;
00144 }
00145 break;
00146
00147 case HIDETOFULL:
00148
00149 textcoordy=((1.0f/m_ConsoleTransPalier)*m_ConsoleTrans);
00150 cordy=(ManagerWindow->GetResolutionY()/m_ConsoleTransPalier)*m_ConsoleTrans;
00151 m_ConsoleTrans++;
00152 if(cordy>(ManagerWindow->GetResolutionY()))
00153 {
00154 m_ConsoleState=m_NextConsoleState;
00155 }
00156 break;
00157
00158 case HALFTOFULL:
00159
00160 textcoordy=((1.0f/m_ConsoleTransPalier)*m_ConsoleTrans)+0.5f;
00161 cordy=((ManagerWindow->GetResolutionY()/m_ConsoleTransPalier)*m_ConsoleTrans)+ManagerWindow->GetResolutionY()/2;
00162 m_ConsoleTrans++;
00163 if(cordy>(ManagerWindow->GetResolutionY()))
00164 {
00165 m_ConsoleState=m_NextConsoleState;
00166 }
00167 break;
00168
00169 case FULLTOHIDE:
00170
00171 textcoordy=1.0f-((1.0f/m_ConsoleTransPalier)*m_ConsoleTrans);
00172 cordy=ManagerWindow->GetResolutionY()-((ManagerWindow->GetResolutionY()/m_ConsoleTransPalier)*m_ConsoleTrans);
00173 m_ConsoleTrans++;
00174 if(cordy<0)
00175 {
00176 m_ConsoleState=m_NextConsoleState;
00177 }
00178 break;
00179
00180 case FULLTOHALF:
00181
00182 textcoordy=1.0f-((1.0f/m_ConsoleTransPalier)*m_ConsoleTrans);
00183 cordy=(ManagerWindow->GetResolutionY())-((ManagerWindow->GetResolutionY()/m_ConsoleTransPalier)*m_ConsoleTrans);
00184 m_ConsoleTrans++;
00185 if(cordy<ManagerWindow->GetResolutionY()/2)
00186 {
00187 m_ConsoleState=m_NextConsoleState;
00188 }
00189 break;
00190
00191 case HALFTOHIDE:
00192
00193 textcoordy=0.5f-((1.0f/m_ConsoleTransPalier)*m_ConsoleTrans);
00194 cordy=(ManagerWindow->GetResolutionY()/2)-((ManagerWindow->GetResolutionY()/m_ConsoleTransPalier)*m_ConsoleTrans);
00195 m_ConsoleTrans++;
00196 if(cordy<0)
00197 {
00198 m_ConsoleState=m_NextConsoleState;
00199 }
00200 break;
00201 }
00202
00203
00204
00205 if(m_Move>0)LineUp();
00206 if(m_Move<0)LineDown();
00207
00208 ExNihilo::EnterOrthoMode();
00209 glPushAttrib(GL_ALL_ATTRIB_BITS);
00210 if(m_BackGroundTextureState)glEnable(GL_TEXTURE_2D);
00211 glDisable(GL_LIGHTING);
00212 glDisable(GL_DEPTH_TEST);
00213 ManagerTexture->SetCurrentObject(m_BackGroundTexture);
00214 if(m_Blending)
00215 {
00216 glColor4f(m_fBackGroundRed,m_fBackGroundGreen,m_fBackGroundBlue,m_fBlending);
00217 glEnable(GL_BLEND);
00218 glEnable(GL_ALPHA);
00219 glBlendFunc(GL_ONE,GL_ONE);
00220 glEnable(GL_ALPHA_TEST);
00221 glAlphaFunc(GL_GREATER,0);
00222 glDisable(GL_LIGHTING);
00223 glBegin(GL_QUADS);
00224 glTexCoord2f(0.0f, textcoordy); glVertex2f(0, 0);
00225 glTexCoord2f(0.0f, 0.0f); glVertex2f(0,cordy );
00226 glTexCoord2f(1.0f, 0.0f); glVertex2f(ManagerWindow->GetResolutionX(),cordy);
00227 glTexCoord2f(1.0f, textcoordy ); glVertex2f(ManagerWindow->GetResolutionX(),0);
00228 glEnd();
00229 }else
00230 {
00231 glColor4f(1,1,1,1);
00232 glBegin(GL_QUADS);
00233 glTexCoord2f(0.0f, textcoordy); glVertex2f(0, 0);
00234 glTexCoord2f(0.0f, 0.0f); glVertex2f(0,cordy );
00235 glTexCoord2f(1.0f, 0.0f); glVertex2f(ManagerWindow->GetResolutionX(),cordy);
00236 glTexCoord2f(1.0f, textcoordy ); glVertex2f(ManagerWindow->GetResolutionX(),0);
00237 glEnd();
00238 }
00239 glPopAttrib();
00240
00241
00242
00243
00244 glColor4f(0,0,1,1);
00245
00246 ExNihilo::RenderBitmapString(ManagerWindow->GetResolutionX()-160,cordy-40,GLUT_BITMAP_8_BY_13,"ExNihilo Engine ");
00247 ExNihilo::RenderBitmapString(ManagerWindow->GetResolutionX()-160,cordy-30,GLUT_BITMAP_8_BY_13,buffer);
00248 ExNihilo::RenderBitmapString(ManagerWindow->GetResolutionX()-160,cordy-20,GLUT_BITMAP_8_BY_13,"Plok Software");
00249
00250
00251
00252 glColor3f(0.5,0,0);
00253
00254 std::string bufferstring,bufferstring2;
00255
00256 bufferstring=Consol->rdbuf( )->str();
00257 Consol->freeze(false);
00258 Consol->clear();
00259 Consol->flush();
00260 m_LineInConsol=0;
00261 do
00262 {
00263 bufferstring2 = bufferstring.substr(0,bufferstring.find ( "\n" ,0));
00264 bufferstring.erase(0,bufferstring.find ( "\n" ,0)+1);
00265 do
00266 {
00267 if(bufferstring2.size()>(unsigned)(ManagerWindow->GetResolutionX()/8)-1)
00268 {
00269 m_BufferConsol.push_back(bufferstring2.substr(0,((int)(ManagerWindow->GetResolutionX()/8))-1));
00270 bufferstring2=bufferstring2.substr(((int)(ManagerWindow->GetResolutionX()/8))-1,bufferstring2.size());
00271 m_LineInConsol++;
00272 }else
00273 {
00274 m_BufferConsol.push_back(bufferstring2);
00275 m_LineInConsol++;
00276 break;
00277 }
00278 }while(1);
00279 }while((unsigned)-1 != bufferstring.find( "\n" ,0));
00280
00281 if(LogConsol=true)
00282 {
00283 #ifdef UNIX_SRC
00284 logfilecsl.open("/tmp/logConsol.txt",ios::out);
00285 #else
00286 logfilecsl.open("logConsol.txt",ios::out);
00287 #endif
00288 i=0;
00289 for(m_ItBufferConsol=m_BufferConsol.begin();m_ItBufferConsol!=m_BufferConsol.end();m_ItBufferConsol++,i++)
00290 {
00291 logfilecsl<<i<<"::"<<m_ItBufferConsol->data()<<std::endl;
00292 }
00293 logfilecsl.close();
00294 }
00295 i=0;
00296
00297 for(m_RItBufferConsol=m_BufferConsol.rbegin();i<m_LineToStar;i++)
00298 {
00299 m_RItBufferConsol++;
00300 }
00301
00302 for(i=0;m_RItBufferConsol!=m_BufferConsol.rend();m_RItBufferConsol++,i++)
00303 {
00304 ExNihilo::RenderBitmapString(10,cordy-(10*i)-20,GLUT_BITMAP_8_BY_13,m_RItBufferConsol->data());
00305 if(i*10>cordy)break;
00306 }
00307 m_BufferConsol.clear();
00308
00309 ExNihilo::RenderBitmapString(10,cordy-10,GLUT_BITMAP_8_BY_13,bufferdata);
00310 glEnable(GL_DEPTH_TEST);
00311 glEnable(GL_LIGHTING);
00312 glDisable(GL_TEXTURE_2D);
00313 ExNihilo::LeaveOrthoMode();
00314
00315 if (m_ConsoleState == m_NextConsoleState && console_move == true) {
00316 console_move = false;
00317 }
00318
00319
00320 UnGuard
00321 }
00322
00323 void ExManagerConsole::LineUp(void)
00324 {
00325 m_LineToStar++;
00326 if(m_LineToStar>m_LineInConsol)m_LineToStar=m_LineInConsol;
00327 }
00328 void ExManagerConsole::LineDown(void)
00329 {
00330 m_LineToStar--;
00331 if(m_LineToStar<0){m_LineToStar=0;}
00332 }
00333
00334 void ExManagerConsole::ConsoleMove (bool p) {
00335 console_move = p;
00336 }
00337
00338 void ExManagerConsole::SetConsoleState(int state)
00339 {
00340 Guard(void ExManagerConsole::SetConsoleState(int state))
00341
00342 SetStatus(true);
00343 switch(m_ConsoleState)
00344 {
00345 case HIDE:
00346 m_NextConsoleState=state;
00347 switch(state)
00348 {
00349 case HALF:
00350 m_ConsoleState=HIDETOHALF;
00351 break;
00352 case FULL:
00353 m_ConsoleState=HIDETOFULL;
00354 break;
00355 }
00356 break;
00357 case HALF:
00358 m_NextConsoleState=state;
00359 switch(state)
00360 {
00361 case FULL:
00362 m_ConsoleState=HALFTOFULL;
00363 break;
00364 case HIDE:
00365 m_ConsoleState=HALFTOHIDE;
00366 break;
00367 }
00368 break;
00369 case FULL:
00370 m_NextConsoleState=state;
00371 switch(state)
00372 {
00373 case HALF:
00374 m_ConsoleState=FULLTOHALF;
00375 break;
00376 case HIDE:
00377 m_ConsoleState=FULLTOHIDE;
00378 break;
00379 }
00380 break;
00381 }
00382 m_ConsoleTrans=1;
00383 UnGuard
00384 }
00385
00386 int ExManagerConsole::NextAviableState(void) {
00387 Guard(int ExManagerConsole::NextAviableState(void))
00388 switch(m_ConsoleState) {
00389 case HIDE: return HALF;
00390 case HALF: return FULL;
00391 case FULL: return HIDE;
00392 case HIDETOHALF : return HALF;
00393 case HIDETOFULL : return FULL;
00394 case HALFTOFULL : return FULL;
00395 case FULLTOHALF : return HALF;
00396 case FULLTOHIDE : return HIDE;
00397 case HALFTOHIDE : return HIDE;
00398 default: return HALF;
00399 }
00400 UnGuard
00401 }
00402
00403 void ExManagerConsole::Write(const char *Label)
00404 {
00405 Guard(void ExManagerConsole::Write(const char *Label))
00406
00407 *Consol << Label << std::endl;
00408
00409 UnGuard
00410 }
00411
00412 ExCAction ExManagerConsole::InputCommand(ExCCommand Command)
00413 {
00414 Guard(ExCAction ExManagerConsole::InputCommand(ExCCommand Command))
00415
00416 switch(Command.m_Command)
00417 {
00418 case KEYBOARD_DOWN_EXP:
00419 InputAction(CONSOL_NEXT_AVIABLE_STATE);
00420 return NOTHING;
00421
00422 case KEYBOARD_DOWN_ESC:
00423 InputAction(HIDE_CONSOL);
00424 return NOTHING;
00425
00426 case KEYBOARD_DOWN_A:
00427 m_BuffCommand.append("a");
00428 return NOTHING;
00429
00430 case KEYBOARD_DOWN_Z:
00431 m_BuffCommand.append("z");
00432 return NOTHING;
00433
00434 case KEYBOARD_DOWN_E:
00435 m_BuffCommand.append("e");
00436 return NOTHING;
00437
00438 case KEYBOARD_DOWN_R:
00439 m_BuffCommand.append("r");
00440 return NOTHING;
00441
00442 case KEYBOARD_DOWN_T:
00443 m_BuffCommand.append("t");
00444 return NOTHING;
00445
00446 case KEYBOARD_DOWN_Y:
00447 m_BuffCommand.append("y");
00448 return NOTHING;
00449
00450 case KEYBOARD_DOWN_U:
00451 m_BuffCommand.append("u");
00452 return NOTHING;
00453 case KEYBOARD_DOWN_I:
00454 m_BuffCommand.append("i");
00455 return NOTHING;
00456
00457 case KEYBOARD_DOWN_O:
00458 m_BuffCommand.append("o");
00459 return NOTHING;
00460
00461 case KEYBOARD_DOWN_P:
00462 m_BuffCommand.append("p");
00463 return NOTHING;
00464
00465 case KEYBOARD_DOWN_Q:
00466 m_BuffCommand.append("q");
00467 return NOTHING;
00468
00469 case KEYBOARD_DOWN_S:
00470 m_BuffCommand.append("s");
00471 return NOTHING;
00472
00473 case KEYBOARD_DOWN_D:
00474 m_BuffCommand.append("d");
00475 return NOTHING;
00476
00477 case KEYBOARD_DOWN_F:
00478 m_BuffCommand.append("f");
00479 return NOTHING;
00480
00481 case KEYBOARD_DOWN_G:
00482 m_BuffCommand.append("g");
00483 return NOTHING;
00484
00485 case KEYBOARD_DOWN_H:
00486 m_BuffCommand.append("h");
00487 return NOTHING;
00488
00489 case KEYBOARD_DOWN_J:
00490 m_BuffCommand.append("j");
00491 return NOTHING;
00492
00493 case KEYBOARD_DOWN_K:
00494 m_BuffCommand.append("k");
00495 return NOTHING;
00496
00497 case KEYBOARD_DOWN_L:
00498 m_BuffCommand.append("l");
00499 return NOTHING;
00500
00501 case KEYBOARD_DOWN_M:
00502 m_BuffCommand.append("m");
00503 return NOTHING;
00504
00505 case KEYBOARD_DOWN_W:
00506 m_BuffCommand.append("w");
00507 return NOTHING;
00508
00509 case KEYBOARD_DOWN_X:
00510 m_BuffCommand.append("x");
00511 return NOTHING;
00512
00513 case KEYBOARD_DOWN_C:
00514 m_BuffCommand.append("c");
00515 return NOTHING;
00516
00517 case KEYBOARD_DOWN_V:
00518 m_BuffCommand.append("v");
00519 return NOTHING;
00520
00521 case KEYBOARD_DOWN_B:
00522 m_BuffCommand.append("b");
00523 return NOTHING;
00524
00525 case KEYBOARD_DOWN_N:
00526 m_BuffCommand.append("n");
00527 return NOTHING;
00528
00529 case KEYBOARD_DOWN_M_A:
00530 m_BuffCommand.append("A");
00531 return NOTHING;
00532
00533 case KEYBOARD_DOWN_M_Z:
00534 m_BuffCommand.append("Z");
00535 return NOTHING;
00536
00537 case KEYBOARD_DOWN_M_E:
00538 m_BuffCommand.append("E");
00539 return NOTHING;
00540
00541 case KEYBOARD_DOWN_M_R:
00542 m_BuffCommand.append("R");
00543 return NOTHING;
00544
00545 case KEYBOARD_DOWN_M_T:
00546 m_BuffCommand.append("T");
00547 return NOTHING;
00548
00549 case KEYBOARD_DOWN_M_Y:
00550 m_BuffCommand.append("Y");
00551 return NOTHING;
00552
00553 case KEYBOARD_DOWN_M_U:
00554 m_BuffCommand.append("U");
00555 return NOTHING;
00556 case KEYBOARD_DOWN_M_I:
00557 m_BuffCommand.append("I");
00558 return NOTHING;
00559
00560 case KEYBOARD_DOWN_M_O:
00561 m_BuffCommand.append("O");
00562 return NOTHING;
00563
00564 case KEYBOARD_DOWN_M_P:
00565 m_BuffCommand.append("P");
00566 return NOTHING;
00567
00568 case KEYBOARD_DOWN_M_Q:
00569 m_BuffCommand.append("Q");
00570 return NOTHING;
00571
00572 case KEYBOARD_DOWN_M_S:
00573 m_BuffCommand.append("S");
00574 return NOTHING;
00575
00576 case KEYBOARD_DOWN_M_D:
00577 m_BuffCommand.append("D");
00578 return NOTHING;
00579
00580 case KEYBOARD_DOWN_M_F:
00581 m_BuffCommand.append("F");
00582 return NOTHING;
00583
00584 case KEYBOARD_DOWN_M_G:
00585 m_BuffCommand.append("G");
00586 return NOTHING;
00587
00588 case KEYBOARD_DOWN_M_H:
00589 m_BuffCommand.append("H");
00590 return NOTHING;
00591
00592 case KEYBOARD_DOWN_M_J:
00593 m_BuffCommand.append("J");
00594 return NOTHING;
00595
00596 case KEYBOARD_DOWN_M_K:
00597 m_BuffCommand.append("K");
00598 return NOTHING;
00599
00600 case KEYBOARD_DOWN_M_L:
00601 m_BuffCommand.append("L");
00602 return NOTHING;
00603
00604 case KEYBOARD_DOWN_M_M:
00605 m_BuffCommand.append("M");
00606 return NOTHING;
00607
00608 case KEYBOARD_DOWN_M_W:
00609 m_BuffCommand.append("W");
00610 return NOTHING;
00611
00612 case KEYBOARD_DOWN_M_X:
00613 m_BuffCommand.append("X");
00614 return NOTHING;
00615
00616 case KEYBOARD_DOWN_M_C:
00617 m_BuffCommand.append("C");
00618 return NOTHING;
00619
00620 case KEYBOARD_DOWN_M_V:
00621 m_BuffCommand.append("V");
00622 return NOTHING;
00623
00624 case KEYBOARD_DOWN_M_B:
00625 m_BuffCommand.append("B");
00626 return NOTHING;
00627
00628 case KEYBOARD_DOWN_M_N:
00629 m_BuffCommand.append("N");
00630 return NOTHING;
00631
00632 case KEYBOARD_DOWN_0:
00633 m_BuffCommand.append("0");
00634 return NOTHING;
00635
00636 case KEYBOARD_DOWN_1:
00637 m_BuffCommand.append("1");
00638 return NOTHING;
00639
00640 case KEYBOARD_DOWN_2:
00641 m_BuffCommand.append("2");
00642 return NOTHING;
00643
00644 case KEYBOARD_DOWN_3:
00645 m_BuffCommand.append("3");
00646 return NOTHING;
00647
00648 case KEYBOARD_DOWN_4:
00649 m_BuffCommand.append("4");
00650 return NOTHING;
00651
00652 case KEYBOARD_DOWN_5:
00653 m_BuffCommand.append("5");
00654 return NOTHING;
00655
00656 case KEYBOARD_DOWN_6:
00657 m_BuffCommand.append("6");
00658 return NOTHING;
00659
00660 case KEYBOARD_DOWN_7:
00661 m_BuffCommand.append("7");
00662 return NOTHING;
00663
00664 case KEYBOARD_DOWN_8:
00665 m_BuffCommand.append("8");
00666 return NOTHING;
00667
00668 case KEYBOARD_DOWN_9:
00669 m_BuffCommand.append("9");
00670 return NOTHING;
00671
00672 case KEYBOARD_DOWN__:
00673 m_BuffCommand.append("_");
00674 return NOTHING;
00675
00676 case KEYBOARD_DOWN_2POINTS:
00677 m_BuffCommand.append(":");
00678 return NOTHING;
00679
00680 case KEYBOARD_DOWN_POINT:
00681 m_BuffCommand.append(".");
00682 return NOTHING;
00683
00684 case KEYBOARD_DOWN_PAGE_UP:
00685 m_Move=-1;
00686 return NOTHING;
00687
00688 case KEYBOARD_DOWN_PAGE_DOWN:
00689 m_Move=1;
00690 return NOTHING;
00691
00692 case KEYBOARD_UP_PAGE_UP:
00693 m_Move=0;
00694 return NOTHING;
00695
00696 case KEYBOARD_UP_PAGE_DOWN:
00697 m_Move=0;
00698 return NOTHING;
00699
00700 case KEYBOARD_DOWN_SPACE:
00701 m_BuffCommand.append(" ");
00702 return NOTHING;
00703
00704 case KEYBOARD_DOWN_ENTER:
00705 return ApplyBuffCommand();
00706
00707 case KEYBOARD_DOWN_TAB: {
00708 std::vector<std::string> vec_tmp;
00709 std::vector<std::string>::iterator i_tmp;
00710
00711 vec_tmp.push_back ("load");
00712 vec_tmp.push_back ("cmd");
00713 vec_tmp.push_back ("help");
00714 vec_tmp.push_back ("clear");
00715 vec_tmp.push_back ("quit");
00716
00717 for (m_ItVecStringAction = m_VecStringAction.begin(); m_ItVecStringAction != m_VecStringAction.end(); m_ItVecStringAction++) {
00718 vec_tmp.push_back (m_ItVecStringAction->first);
00719 }
00720
00721 i_tmp = vec_tmp.begin ();
00722 std::string tmp;
00723
00724 while (i_tmp != vec_tmp.end ()) {
00725 tmp = *i_tmp++;
00726
00727 if (tmp.find (m_BuffCommand) == 0) {
00728 if (tmp.find (' ') < tmp.length ())
00729 m_BuffCommand = tmp.substr (0, tmp.find (' '));
00730 else m_BuffCommand = tmp;
00731
00732
00733 }
00734 }
00735 return NOTHING;
00736 }
00737 case KEYBOARD_DOWN_CTRL_U:
00738 m_BuffCommand = "";
00739 return NOTHING;
00740
00741 case KEYBOARD_UP_ARROW_DOWN:
00742 PosIntoBuffOldCommand++;
00743 if(PosIntoBuffOldCommand<(int)m_BuffOldCommand.size()&&PosIntoBuffOldCommand>=-1)
00744 {
00745 m_BuffCommand=m_BuffOldCommand.at(PosIntoBuffOldCommand);
00746 }else
00747 {
00748 PosIntoBuffOldCommand=0;
00749 }
00750
00751
00752 return NOTHING;
00753
00754 case KEYBOARD_UP_ARROW_UP:
00755 PosIntoBuffOldCommand--;
00756 if(PosIntoBuffOldCommand<(int)m_BuffOldCommand.size()&&PosIntoBuffOldCommand>=0)
00757 {
00758 m_BuffCommand=m_BuffOldCommand.at(PosIntoBuffOldCommand);
00759 }else
00760 {
00761 PosIntoBuffOldCommand=0;
00762 }
00763 return NOTHING;
00764
00765 case KEYBOARD_UP_ARROW_LEFT:
00766 if(m_BuffCommand.size()>0)
00767 {
00768 m_BuffCommand.erase(m_BuffCommand.end()-1,m_BuffCommand.end());
00769 }
00770 return NOTHING;
00771
00772 case KEYBOARD_UP_BACKSPACE:
00773 if(m_BuffCommand.size()>0)
00774 {
00775 m_BuffCommand.erase(m_BuffCommand.end()-1,m_BuffCommand.end());
00776 }
00777 return NOTHING;
00778
00779 default :return NOTHING;
00780 }
00781 UnGuard
00782 }
00783
00784 void ExManagerConsole::ListConsoleCommand(void)
00785 {
00786 Guard(void ExManagerConsole::ListConsoleCommand(void))
00787 *Consol<<"*******************************"<<std::endl;
00788 *Consol<<"*List of all available command*"<<std::endl;
00789 *Consol<<"*******************************"<<std::endl;
00790 *Consol<<"load 'FILENAME'"<<std::endl;
00791 *Consol<<"cmd 'number of command'"<<std::endl;;
00792 *Consol<<"help 'command'"<<std::endl;
00793 *Consol<<"clear 'clear console screen'"<<std::endl;
00794 *Consol<<"quit 'exit ExNihilo'"<<std::endl;
00795 int i=PREDIFINEDCOMMAND;
00796 for(m_ItVecStringAction=m_VecStringAction.begin(); m_ItVecStringAction != m_VecStringAction.end(); m_ItVecStringAction++, i++)
00797 {
00798 *Consol<<m_ItVecStringAction->first.data()<<std::endl;
00799 }
00800 *Consol<<"*****************************"<<std::endl;
00801 UnGuard
00802 }
00803
00804 ExCAction ExManagerConsole::ApplyBuffCommand(void)
00805 {
00806 Guard(ExCAction ExManagerConsole::ApplyBuffCommand(void))
00807 bool findaction=false;
00808 ExCAction Action;
00809 Action.m_StartingLife=(double)((double)glutGet(GLUT_ELAPSED_TIME)/1000);
00810 *Consol<<m_BuffCommand.data()<<std::endl;
00811 for(m_ItVecStringAction=m_VecStringAction.begin();m_ItVecStringAction!=m_VecStringAction.end();m_ItVecStringAction++)
00812 {
00813 if(m_BuffCommand.find(m_ItVecStringAction->first.data())==0)
00814 {
00815 findaction=true;
00816 char buffer[255];
00817 memset(buffer,0,255);
00818 Action.m_Action=m_ItVecStringAction->second;
00819 m_BuffCommand.copy(buffer,(m_BuffCommand.size())-(strlen(m_ItVecStringAction->first.data())),strlen(m_ItVecStringAction->first.data()));
00820 Action.SetParam(buffer);
00821 m_BuffOldCommand.push_back(m_BuffCommand);
00822 m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00823 }
00824 }
00825 if(!findaction)
00826 {
00827 if(strcmp(m_BuffCommand.data(),"clear")==0)
00828 {
00829 m_BuffOldCommand.push_back(m_BuffCommand);
00830 m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00831 m_BufferConsol.clear();
00832 ClearConsol();
00833 Action.m_Action= NOTHING;
00834 return Action;
00835 }
00836
00837 if(m_BuffCommand.find("help")==0)
00838 {
00839 ListConsoleCommand();
00840 m_BuffOldCommand.push_back(m_BuffCommand);
00841 m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00842 Action.m_Action= NOTHING;
00843 return Action;
00844 }
00845 if(m_BuffCommand.find("cmd ")==0)
00846 {
00847 int cmd=0;
00848 char *SBuffer;
00849 SBuffer=new char[strlen(m_BuffCommand.data())-5] ;
00850 memset(SBuffer,0,strlen(m_BuffCommand.data()));
00851 m_BuffCommand.copy(SBuffer,m_BuffCommand.size()-4,4);
00852 m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00853 try
00854 {
00855 cmd=atoi(SBuffer);
00856 Action.m_Action= m_VecStringAction.at(cmd-PREDIFINEDCOMMAND).second;
00857 }catch(...)
00858 {
00859 *Consol<<"Bad argument use list to show command list"<<std::endl;
00860 Action.m_Action= NOTHING;
00861 return Action;
00862 }
00863 }
00864
00865 if(strcmp(m_BuffCommand.data(),"quit")==0)
00866 {
00867 m_BuffOldCommand.push_back(m_BuffCommand);
00868 m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00869 Action.m_Action= QUIT;
00870 return Action;
00871 }
00872
00873 if(strcmp(m_BuffCommand.data(),"reset")==0)
00874 {
00875 m_BuffOldCommand.push_back(m_BuffCommand);
00876 m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00877 Action.m_Action= RESET;
00878 return Action;
00879 }
00880
00881 if(m_BuffCommand.find("load")!=(unsigned)-1)
00882 {
00883 char buffer[255];
00884 memset(buffer,0,255);
00885 Action.m_Action=LOAD_FILE;
00886 m_BuffCommand.copy(buffer,m_BuffCommand.size()-4,4);
00887 Action.SetParam(buffer);
00888 m_BuffOldCommand.push_back(m_BuffCommand);
00889 m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00890 return Action;
00891 }
00892
00893 *Consol<<"Unknow command"<<std::endl;
00894 m_BuffOldCommand.push_back(m_BuffCommand);
00895 m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00896 Action.m_Action= NOTHING;
00897 }
00898 return Action;
00899 UnGuard
00900 }
00901
00902 void ExManagerConsole::AddStringAction(std::string String,int Action)
00903 {
00904 Guard(void ExManagerConsole::AddStringAction(std::string String,int Action))
00905 StringAction ac;
00906 ac.first=String;
00907 ac.second=Action;
00908 m_VecStringAction.push_back(ac);
00909 *Consol<<"Add new command to console command:"<<String<<" Action:"<<Action<<std::endl;
00910 UnGuard
00911 }
00912
00913 void ExManagerConsole::AddStringAction(StringAction StrAction)
00914 {
00915 Guard(void ExManagerConsole::AddStringAction(StringAction StrAction))
00916 AddStringAction(StrAction.first.data(),StrAction.second);
00917 UnGuard
00918 }
00919
00920 void ExManagerConsole::AddStringAction(ExCFileDataAction p) {
00921 Guard(void ExManagerConsole::AddStringAction(ExCFileDataAction p))
00922 StringAction foo;
00923 foo.first = p.getAction();
00924 foo.second = p.getCommand();
00925 AddStringAction(foo);
00926 UnGuard
00927 }
00928
00929 void ExManagerConsole::LoadStringActionFile(const char *FileName)
00930 {
00931 Guard(void ExManagerConsole::LoadStringActionFile(const char *FileName))
00932 char buffer[255];
00933
00934 #ifdef UNIX_SRC
00935 sprintf(buffer, PREFIX "/ExNihilo/Data/Console/%s", FileName);
00936 #else
00937 sprintf(buffer, "../Data/Console/%s", FileName);
00938 #endif
00939 StringAction BuffStringAction;
00940 std::ifstream fin;
00941 std::string buffstring;
00942 char b[256];
00943 fin.open(buffer,std::ios::in);
00944 if(fin.is_open())
00945 {
00946 try
00947 {
00948 do
00949 {
00950 memset(b,0,255);
00951 fin.getline(b,256,'\n');
00952 try
00953 {
00954 buffstring=ExNihilo::ExtracValueFromSring(b,"<consolcommand>","<#consolcommand>");
00955 AddStringAction(ExNihilo::ExtracValueFromSring(buffstring,"<string>","<#string>")
00956 ,ExNihilo::ExtractIntValueFromSring(buffstring,"<action>","<#action>"));
00957 }catch(ExCExpStringNotFound){}
00958 }while(!fin.eof());
00959 fin.close();
00960 }catch(...){throw ExCExpFileReadError();}
00961 }else throw ExCExpFileNotFound();
00962 UnGuard
00963 }
00964
00965 void ExManagerConsole::ClearConsol(void)
00966 {
00967 Guard(void ExManagerConsole::ClearConsol(void))
00968 m_BuffOldCommand.push_back(m_BuffCommand);
00969 m_BuffCommand.erase(m_BuffCommand.begin(),m_BuffCommand.end());
00970 m_BufferConsol.clear();
00971 UnGuard
00972 }
00973
00974
00975 ExCAction ExManagerConsole::InputAction(ExCAction Action)
00976 {
00977 Guard(ExCAction ExManagerConsole::InputAction(ExCAction Action))
00978
00979 switch(Action.m_Action)
00980 {
00981 case CONSOL_LINE_UP:LineUp();break;
00982 case CONSOL_LINE_DOWN:LineDown();break;
00983 case SHOW_HALF_CONSOL:
00984 if (!isConsoleMove ())
00985 {
00986 ConsoleMove (true);
00987 SetStatus(true);
00988 SetAskForCommand(true);
00989 SetAskForExclusifCommand(true);
00990 SetConsoleState(HALF);
00991 }
00992 break;
00993 case SHOW_FULL_CONSOL:
00994 if (!isConsoleMove ())
00995 {
00996 ConsoleMove (true);
00997 SetStatus(true);
00998 SetAskForCommand(true);
00999 SetAskForExclusifCommand(true);
01000 SetConsoleState(FULL);
01001 }
01002 break;
01003 case HIDE_CONSOL:
01004 if (!isConsoleMove ())
01005 {
01006 ConsoleMove (true);
01007 SetStatus(false);
01008 SetConsoleState(HIDE);
01009 SetAskForCommand(false);
01010 SetAskForExclusifCommand(false);
01011 }
01012 break;
01013 case CONSOL_NEXT_AVIABLE_STATE:
01014 switch(NextAviableState())
01015 {
01016 case HIDE:
01017 case FULLTOHIDE:
01018 case HALFTOHIDE:
01019 if (!isConsoleMove ())
01020 {
01021 ConsoleMove (true);
01022 SetStatus(false);
01023 SetConsoleState(HIDE);
01024 SetAskForCommand(false);
01025 SetAskForExclusifCommand(false);
01026 }
01027 break;
01028 case HALF:
01029 case HIDETOHALF:
01030 case FULLTOHALF:
01031 if (!isConsoleMove ())
01032 {
01033 ConsoleMove (true);
01034 SetStatus(true);
01035 SetAskForCommand(true);
01036 SetAskForExclusifCommand(true);
01037 SetConsoleState(HALF);
01038 }
01039 break;
01040 case FULL:
01041 case HIDETOFULL:
01042 case HALFTOFULL:
01043 if (!isConsoleMove ())
01044 {
01045 ConsoleMove (true);
01046 SetStatus(true);
01047 SetAskForCommand(true);
01048 SetAskForExclusifCommand(true);
01049 SetConsoleState(FULL);
01050 }
01051 break;
01052 }
01053 break;
01054
01055 case SET_CONSOL_BACKGROUND_TEXURE:SetConsoleBackGroudTexture(Action.m_Param);break;
01056 case ENABLE_CONSOL_BACKGROUND_TEXTURE:SetConsoleBackGroudTextureState(true);break;
01057 case DISABLE_CONSOL_BACKGROUND_TEXTURE:SetConsoleBackGroudTextureState(false);break;
01058 case SET_CONSOL_BACKGROUND_COLOR:break;
01059 case SET_CONSOL_BACKGROUND_COLOR_BLUE:
01060 try
01061 {
01062 SetConsoleBackGroudColorBlue(atof(Action.m_Param.data()));
01063 }catch(...)
01064 {
01065 *Consol<<"Enter a float value"<<std::endl;
01066 }
01067 break;
01068 case SET_CONSOL_BACKGROUND_COLOR_GREEN:
01069 try
01070 {
01071 SetConsoleBackGroudColorGreen(atof(Action.m_Param.data()));
01072 }catch(...)
01073 {
01074 *Consol<<"Enter a float value"<<std::endl;
01075 }
01076 break;
01077 case SET_CONSOL_BACKGROUND_COLOR_RED:
01078 try
01079 {
01080 SetConsoleBackGroudColorRed(atof(Action.m_Param.data()));
01081 }catch(...)
01082 {
01083 *Consol<<"Enter a float value"<<std::endl;
01084 }
01085 case ENABLE_CONSOL_BACKGROUND_BLENDING:SetConsoleBackGroudBlendingState(true);break;
01086 case DISABLE_CONSOL_BACKGROUND_BLENDING:SetConsoleBackGroudBlendingState(false);break;
01087 case SET_CONSOL_BACKGROUND_BLENDING:
01088 try
01089 {
01090 SetConsoleBackGroudBlending(atof(Action.m_Param.data()));
01091 }catch(...)
01092 {
01093 *Consol<<"Enter a float value"<<std::endl;
01094 }
01095 break;
01096 }
01097 if(Action.m_NextAction){return *Action.m_NextAction;}
01098 else{return NOTHING;}
01099 UnGuard
01100 }
01101