Main Page   Namespace List   Class Hierarchy   Alphabetical List   Data Structures   File List   Data Fields   Globals  

ExManagerCommand.cpp

Go to the documentation of this file.
00001 /*
00002  * ExNihilo 3D Engine
00003  * 
00004  *  This program is free software; you can redistribute it and/or modify
00005  *  it under the terms of the GNU General Public License as published by
00006  *  the Free Software Foundation; either version 2 of the License, or
00007  *  (at your option) any later version.
00008  *
00009  *  This program is distributed in the hope that it will be useful,
00010  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  *  GNU Library General Public License for more details.
00013  *
00014  *  You should have received a copy of the GNU General Public License
00015  *  along with this program; if not, write to the Free Software
00016  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00017  *
00018  * Please read AUTHORS file !!!
00019  * 
00020  * $Id: ExManagerCommand.cpp,v 1.33 2002/08/02 18:55:14 data Exp $
00021  *
00022  */
00023 
00024 #include "ExManagerCommand.h"
00025 
00026 ExManagerCommand::ExManagerCommand(void)
00027 {
00028         LogCommand = true;
00029         #ifdef UNIX_SRC
00030         logfilecommand.open("/tmp/logCommand.txt",ios::out);
00031         #else
00032         logfilecommand.open("logCommand.txt",ios::out);
00033         #endif
00034 }
00035 
00036 ExManagerCommand::~ExManagerCommand(void)
00037 {
00038 }
00039 
00040 bool ExManagerCommand::LoadCommandFile(const char *FileName)
00041 {
00042 Guard(bool ExManagerCommand::LoadCommandFile(const char *FileName))
00043         char buffer[255];
00044         
00045 #ifdef UNIX_SRC
00046         sprintf(buffer, PREFIX "/ExNihilo/Data/Command/%s", FileName);
00047 #else
00048         sprintf(buffer, "../Data/Command/%s",FileName);
00049 #endif
00050     
00051         ExCFileReader my_file (buffer);
00052         if (! my_file.exist()) 
00053         {
00054                 *Consol<<"File not found: "<<buffer<<std::endl;
00055                 return false;
00056         } else 
00057         {
00058                 *Consol<<"Loading Command File: "<<FileName<<std::endl; 
00059                 ExCFileData _data = my_file.getContent();
00060                 
00061                 if (_data.getType() != FILE_COMMAND) 
00062                 {
00063                         *Consol<<FileName<<" is not a valide command file"<<std::endl;
00064                         return false;
00065                 } else 
00066                 {
00067                         vector<ExCFileDataAction> dd = _data.getContent();
00068                         vector<ExCFileDataAction>::iterator i = dd.begin ();
00069                         ExCFileDataAction f;
00070                         while (i != dd.end ()) 
00071                         {
00072                                 f = *i++;
00073                                 AddCommandAction (f);
00074                         }
00075                 }
00076                 return true;
00077         }
00078         
00079 UnGuard
00080 }
00081 
00082 
00083 void ExManagerCommand::InputCommand(int command)
00084 {
00085 Guard(void ExManagerCommand::InputCommand(int command))
00086         SAction com;
00087         //cout<<"command :"<<command<<endl;
00088         //1 check if menu ,console ,interface,or game;
00089         if(ManagerWindow->GetConsoleState()) {
00090                 com=ManagerConsole->InputCommand(command,m_MousePosX,m_MousePosY);
00091                 //std::cout<<"Action :"<<com.m_Action<<" Param :"<<com.m_Param<<std::endl;
00092                 AddAction(com);
00093         } else if(ManagerWindow->GetMenuState()) {
00094                 //ProcessCommand(ManagerMenu->InputCommand());
00095         } else {
00096                 ProcessCommand(command);
00097         }
00098         if(ManagerWindow->GetInterfaceState()) {
00099                 com=ManagerInterface->InputCommand(command,m_MousePosX,m_MousePosY);
00100                 //cout<<"Action :"<<com.m_Action<<" Param :"<<com.m_Param<<endl;
00101                 AddAction(com);
00102         }
00103 UnGuard
00104 }
00105 
00106 void ExManagerCommand::ProcessCommand(int command)
00107 {
00108 Guard(void ExManagerCommand::ProcessCommand(int command))
00109         //cout<<"Process command :"<<command<<endl;
00110         for(m_ItVecCommand=m_VecCommand.begin();m_ItVecCommand!=m_VecCommand.end();m_ItVecCommand++)
00111         {
00112                 if(m_ItVecCommand->first==command)
00113                 {
00114                         AddAction(m_ItVecCommand->second);
00115                 }
00116         }
00117 UnGuard
00118 }
00119 
00120 void ExManagerCommand::AddAction(SAction action)
00121 {
00122 Guard(void ExManagerCommand::AddAction(SAction action)) 
00123         //cout<<"Add Action"<<action<<endl;
00124         if(action.m_Action!=NOTHING)
00125         {
00126                 m_VecAction.push_back(action);
00127         }
00128 UnGuard
00129 }
00130 
00131 void ExManagerCommand::AddNewAction(SAction action)
00132 {
00133 Guard(void ExManagerCommand::AddAction(SAction action)) 
00134         //cout<<"Add Action"<<action<<endl;
00135         if(action.m_Action!=NOTHING)
00136         {
00137                 m_VecTempAction.push_back(action);
00138         }
00139 UnGuard
00140 }
00141 
00142 void ExManagerCommand::RemoveRepAction(SAction action)
00143 {
00144 Guard(void ExManagerCommand::RemoveRepAction(SAction action))   
00145         int i=0;
00146         for(m_ItVecRepAction=m_VecRepAction.begin();m_ItVecRepAction!=m_VecRepAction.end();m_ItVecRepAction++,i++)
00147         {
00148                 if(m_VecRepAction.at(i).m_Action==action.m_Action)
00149                 {
00150                         m_VecRepAction.erase(m_ItVecRepAction); break;
00151                 }
00152         }
00153 UnGuard
00154 }
00155 
00156 void ExManagerCommand::AddRepAction(SAction action)
00157 {
00158 Guard(void ExManagerCommand::AddRepAction(SAction action))      
00159         bool already=false;
00160         int i=0;
00161         for(m_ItVecRepAction=m_VecRepAction.begin();m_ItVecRepAction!=m_VecRepAction.end();m_ItVecRepAction++,i++)
00162         {
00163                 if(m_VecRepAction.at(i).m_Action==action.m_Action)
00164                 {
00165                         already=true;
00166                 }
00167         }  
00168         if(!already)
00169         {  
00170                 m_VecRepAction.push_back(action);
00171         }
00172 UnGuard
00173 }
00174 
00175 void ExManagerCommand::ApplyAction(void)
00176 {
00177 Guard(void ExManagerCommand::ApplyAction(void))
00178         int i;
00179         std::vector<SAction>                    TmpVecAction;
00180         for(m_ItVecAction=m_VecAction.begin();m_ItVecAction!=m_VecAction.end();m_ItVecAction++,i++)
00181         {
00182                 //cout<<"Aplly Action :"<<m_VecAction.at(i)<<endl;
00183                 if(!ProcessAction(*m_ItVecAction))
00184                 {
00185                         AddNewAction(*m_ItVecAction);
00186                 }
00187         }
00188         
00189         //Remove executed action
00190         /*for(m_ItVecAction=m_VecAction.begin();m_ItVecAction!=m_VecAction.end();m_ItVecAction++)
00191         {
00192                 
00193                 if(!m_ItVecAction->AllActionDone())
00194                 {
00195                         TmpVecAction.push_back(*m_ItVecAction);
00196                 }else
00197                 {
00198                         std::cout<<"action not done :"<<m_ItVecAction->m_Action<<std::endl;
00199                 }
00200         }*/
00201         m_VecAction.clear();
00202         //m_VecAction=TmpVecAction;
00203         for(i=0; (unsigned)i<m_VecTempAction.size();i++)
00204         {
00205                 AddAction(m_VecTempAction.at(i));
00206         }
00207         m_VecTempAction.clear();
00208         i=0;
00209         for(m_ItVecRepAction=m_VecRepAction.begin();m_ItVecRepAction!=m_VecRepAction.end();m_ItVecRepAction++,i++)
00210         {
00211                 ProcessAction(m_VecRepAction.at(i));
00212         }
00213         
00214 UnGuard
00215 }
00216 
00217 void ExManagerCommand::AddCommandAction (ExCFileDataAction e) {
00218 Guard(void ExManagerCommand::AddCommandAction(ExCFileDataAction e))
00219         CommandAction ComAct;
00220         ComAct.first = atoi (e.getAction ().data());
00221         ComAct.second.m_Action = e.getCommand ();
00222         ComAct.second.m_Param = new char [e.getParam ().length()];
00223         sprintf (ComAct.second.m_Param, "%s", e.getParam().data());
00224         m_VecCommand.push_back (ComAct);
00225 UnGuard
00226 }
00227 
00228 void ExManagerCommand::AddCommandAction(int command,SAction action)
00229 {
00230 Guard(void ExManagerCommand::AddCommandAction(int command,SAction action))
00231         CommandAction ComAct;   
00232         ComAct.first=command;
00233         ComAct.second.m_Action=action.m_Action;
00234         ComAct.second.m_Param= new char[strlen(action.m_Param)];
00235         sprintf(ComAct.second.m_Param,"%s",action.m_Param);
00236         m_VecCommand.push_back(ComAct);
00237 UnGuard
00238 }
00239 
00240 void ExManagerCommand::AddCommandAction(CommandAction ComAct)
00241 {
00242 Guard(void ExManagerCommand::AddCommandAction(CommandAction ComAct))
00243         m_VecCommand.push_back(ComAct);
00244 UnGuard
00245 }
00246 
00247 void ExManagerCommand::AddCommandAction(int command,int action,char *param)
00248 {
00249 Guard(void ExManagerCommand::AddCommandAction(int command,int action,char *param))
00250         CommandAction ComAct;
00251         ComAct.first=command;
00252         ComAct.second.m_Action=action;
00253         ComAct.second.m_Param= new char[strlen(param)];
00254         sprintf(ComAct.second.m_Param,"%s",param);
00255         m_VecCommand.push_back(ComAct); 
00256 UnGuard
00257 }
00258 
00259 void ExManagerCommand::Init(void)
00260 {
00261 Guard(void ExManagerCommand::Init(void))
00262         AddCommandAction(KEYBOARD_UP_ESC,               QUIT,"NULL");
00263         AddCommandAction(KEYBOARD_DOWN_4,               SAction(CAMERA_CURRENT_START_ROTATEY_DOWN));
00264         AddCommandAction(KEYBOARD_UP_4,                 SAction(CAMERA_CURRENT_STOP_ROTATEY_DOWN));
00265         AddCommandAction(KEYBOARD_UP_5,                 SAction(CAMERA_CURRENT_INCREASE_SPEED));
00266         AddCommandAction(KEYBOARD_UP_0,                 SAction(CAMERA_CURRENT_DECREASE_SPEED));
00267         AddCommandAction(KEYBOARD_DOWN_6,               SAction(CAMERA_CURRENT_START_ROTATEY_UP));
00268         AddCommandAction(KEYBOARD_UP_6,                 SAction(CAMERA_CURRENT_STOP_ROTATEY_UP));
00269         AddCommandAction(KEYBOARD_DOWN_2,               SAction(CAMERA_CURRENT_START_ROTATEX_UP));
00270         AddCommandAction(KEYBOARD_UP_2,                 SAction(CAMERA_CURRENT_STOP_ROTATEX_UP));
00271         AddCommandAction(KEYBOARD_DOWN_8,               SAction(CAMERA_CURRENT_START_ROTATEX_DOWN));
00272         AddCommandAction(KEYBOARD_UP_8,                 SAction(CAMERA_CURRENT_STOP_ROTATEX_DOWN));
00273         AddCommandAction(KEYBOARD_DOWN_1,               SAction(CAMERA_CURRENT_START_ROTATEZ_UP));
00274         AddCommandAction(KEYBOARD_UP_1,                 SAction(CAMERA_CURRENT_STOP_ROTATEZ_UP));
00275         AddCommandAction(KEYBOARD_DOWN_3,               SAction(CAMERA_CURRENT_START_ROTATEZ_DOWN));
00276         AddCommandAction(KEYBOARD_UP_3,                 SAction(CAMERA_CURRENT_STOP_ROTATEZ_DOWN));
00277         AddCommandAction(KEYBOARD_UP_F1,                SAction(STAR_ALL_PARTICULESYSTEME));
00278         AddCommandAction(KEYBOARD_UP_F2,                SAction(PAUSE_ALL_PARTICULESYSTEME));
00279         AddCommandAction(KEYBOARD_UP_F3,                SAction(ENABLE_ANTIALIASING));
00280         AddCommandAction(KEYBOARD_UP_F4,                SAction(DISABEL_ANTIALIASING));
00281         AddCommandAction(KEYBOARD_UP_F5,                SAction(SET_NEXT_ENTITE_CURRENT));
00282         AddCommandAction(KEYBOARD_UP_F6,                SAction(SET_RENDERMODE_TEXTURES_LIGHT));
00283         AddCommandAction(KEYBOARD_UP_F7,                SAction(SET_RENDERMODE_TEXTURES));
00284         AddCommandAction(KEYBOARD_UP_F8,                SAction(SET_RENDERMODE_TRIANGLES_LIGHT));
00285         AddCommandAction(KEYBOARD_UP_F9,                SAction(SET_RENDERMODE_TRIANGLES));
00286         AddCommandAction(KEYBOARD_UP_F10,               SAction(SET_RENDERMODE_POINTS));
00287         AddCommandAction(KEYBOARD_UP_F11,               SAction(SET_RENDERMODE_LINES));
00288         AddCommandAction(KEYBOARD_UP_F12,               SAction(SET_RENDERMODE_NO));
00289         AddCommandAction(KEYBOARD_UP_PAGE_UP,   SAction(CONSOL_LINE_UP));
00290         AddCommandAction(KEYBOARD_UP_PAGE_DOWN, SAction(CONSOL_LINE_DOWN));
00291         AddCommandAction(KEYBOARD_DOWN_EXP,             SAction(CONSOL_NEXT_AVIABLE_STATE));
00292         AddCommandAction(KEYBOARD_UP_G,                 SAction(SWITCH_GRIDE));
00293 
00294         AddCommandAction(KEYBOARD_DOWN_U,               SAction(ENTITE_CURRENT_START_ROTATE_X_DOWN));
00295         AddCommandAction(KEYBOARD_UP_U,                 SAction(ENTITE_CURRENT_STOP_ROTATE_X_DOWN));
00296         AddCommandAction(KEYBOARD_DOWN_J,               SAction(ENTITE_CURRENT_START_ROTATE_X_UP));
00297         AddCommandAction(KEYBOARD_UP_J,                 SAction(ENTITE_CURRENT_STOP_ROTATE_X_UP));
00298 
00299         AddCommandAction(KEYBOARD_DOWN_Y,               SAction(ENTITE_CURRENT_START_ROTATE_Y_DOWN));
00300         AddCommandAction(KEYBOARD_UP_Y,                 SAction(ENTITE_CURRENT_STOP_ROTATE_Y_DOWN));
00301         AddCommandAction(KEYBOARD_DOWN_I,               SAction(ENTITE_CURRENT_START_ROTATE_Y_UP));
00302         AddCommandAction(KEYBOARD_UP_I,                 SAction(ENTITE_CURRENT_STOP_ROTATE_Y_UP));
00303         
00304         AddCommandAction(KEYBOARD_DOWN_H,               SAction(ENTITE_CURRENT_START_ROTATE_Z_DOWN));
00305         AddCommandAction(KEYBOARD_UP_H,                 SAction(ENTITE_CURRENT_STOP_ROTATE_Z_DOWN));
00306         AddCommandAction(KEYBOARD_DOWN_K,               SAction(ENTITE_CURRENT_START_ROTATE_Z_UP));
00307         AddCommandAction(KEYBOARD_UP_K,                 SAction(ENTITE_CURRENT_STOP_ROTATE_Z_UP));
00308          
00309 
00310 UnGuard
00311 }
00312 
00313 void ExManagerCommand::LoadSetOfFile(const char *FileName)
00314 {
00315 Guard(void ExManagerCommand::LoadSetOfFile(const char *FileName))
00316         char                    ch;
00317         int                             RetVal;
00318         int                             FileSize;
00319         FILE                    *MyFile;
00320         bool                    endfile=false;
00321         //int                           tmp=0; // not used
00322         std::string             StBuffer;
00323         std::string             StType;
00324     char                        buffer[255];
00325 
00326 #ifdef UNIX_SRC
00327         sprintf(buffer, PREFIX "/ExNihilo/Data/%s",FileName);
00328 #else
00329         sprintf(buffer, "../Data/%s",FileName);
00330 #endif
00331     
00332         MyFile=fopen (buffer,"r");
00333         if(!MyFile)
00334         {
00335                 *Consol<<"File not found:"<<buffer<<std::endl;
00336         }else
00337         {
00338                 *Consol<<"Loading set File :"<<FileName<<std::endl;
00339 
00340                 fseek(MyFile,0,SEEK_END);
00341                 FileSize=ftell(MyFile);
00342                 //Start of file
00343                 fseek(MyFile,0,SEEK_SET);
00344                 do
00345                 {
00346                         RetVal=fread(&ch,sizeof(char),1,MyFile);
00347                 }while(ch!='#');
00348                 //reading file type;
00349                 do
00350                 {
00351                         RetVal=fread(&ch,sizeof(char),1,MyFile);
00352                         StBuffer=StBuffer+ch;   
00353                 }while(ch!='#');
00354                 if(strcmp(StBuffer.data(),"set#")==0)
00355                 {
00356                         
00357                         do
00358                         {
00359                                 
00360                                 StBuffer.erase(StBuffer.begin(),StBuffer.end());
00361                                 do
00362                                 {
00363                                         RetVal=fread(&ch,sizeof(char),1,MyFile);
00364                                         StBuffer=StBuffer+ch;
00365                                 }while(ch!='#');
00366                                 StBuffer.erase(StBuffer.end()-1,StBuffer.end());
00367                                 StBuffer.erase(StBuffer.begin(),StBuffer.begin()+1);
00368                                 if(StBuffer.find("end of set file") != (unsigned)-1)
00369                                 {
00370                                         endfile=true;
00371                                 }else
00372                                 {
00373                                         StType=StBuffer;
00374                                         StBuffer.erase(StBuffer.begin(),StBuffer.end());
00375                                         do
00376                                         {
00377                                                 RetVal=fread(&ch,sizeof(char),1,MyFile);
00378                                                 StBuffer=StBuffer+ch;
00379                                         }while(ch!='#');
00380                                         StBuffer.erase(StBuffer.end()-1,StBuffer.end());
00381                                         
00382                                         if(strcmp(StType.data(),"command")==0)
00383                                         {
00384                                                 std::cout<<"Load command file :"<<StBuffer.data()<<std::endl;
00385                                                 LoadCommandFile(StBuffer.data());
00386                                         }
00387                                         if(strcmp(StType.data(),"console")==0)
00388                                         {
00389                                                 std::cout<<"Load console file :"<<StBuffer.data()<<std::endl;
00390                                                 ManagerConsole->LoadStringActionFile(StBuffer.data());  
00391                                         }
00392                                         if(strcmp(StType.data(),"interface")==0)
00393                                         {
00394                                                 std::cout<<"Load interface file :"<<StBuffer.data()<<std::endl;
00395                                                 ManagerInterface->LoadInterface(StBuffer.data());       
00396                                         }
00397                                         if(strcmp(StType.data(),"modele")==0)
00398                                         {
00399                                                 std::cout<<"Load asc file :"<<StBuffer.data()<<std::endl;
00400                                                 ManagerEntite->LoadAsc(StBuffer.data());        
00401                                         }
00402                                         if(strcmp(StType.data(),"sound")==0)
00403                                         {
00404                                                 std::cout<<"Load sound file :"<<StBuffer.data()<<std::endl;
00405                                                 ManagerSound->LoadSound(StBuffer.data());       
00406                                         }
00407                                         if(strcmp(StType.data(),"set")==0)
00408                                         {
00409                                                 std::cout<<"Load set file :"<<StBuffer.data()<<std::endl;
00410                                                 LoadSetOfFile(StBuffer.data()); 
00411                                         }
00412                                         if(strcmp(StType.data(),"exec")==0)
00413                                         {
00414                                                 std::cout<<"Load set file :"<<StBuffer.data()<<std::endl;
00415                                                 
00416                                                 SAction action;
00417                                                 action.SetParam(StBuffer.data());
00418                                                 LoadExecFile(&action);  
00419                                         }
00420                                         if(strcmp(StType.data(),"map")==0)
00421                                         {
00422                                                 std::cout<<"Load map file :"<<StBuffer.data()<<std::endl;
00423                                                 ManagerMap->LoadMap(StBuffer.data());   
00424                                         }
00425                                         
00426                                 }
00427                         }while(!endfile);
00428                         fclose(MyFile);
00429                 }else
00430                 {
00431                         *Consol<<FileName<<" is not a valide console file"<<std::endl;
00432                 }
00433     }
00434 UnGuard
00435 }
00436 
00437 bool ExManagerCommand::LoadExecFile(SAction *action)
00438 {
00439 Guard(bool ExManagerCommand::LoadExecFile(SAction *action))
00440         char                    ch;
00441         int                             RetVal;
00442         int                             FileSize;
00443         FILE                    *MyFile;
00444         bool                    endfile=false;
00445         std::string             StBuffer;
00446         char                    buffer[255];
00447         char                    *FileName;
00448         SAction                 NewActionA;
00449         
00450         FileName= new char[strlen(action->m_Param)];
00451         sprintf(FileName,"%s",(action->m_Param)+1);
00452         
00453         sprintf(buffer,"../Data/Command/%s",FileName);
00454     
00455         MyFile=fopen (buffer,"r");
00456         if(!MyFile)
00457         {
00458                 *Consol<<"File not found:"<<buffer<<std::endl;
00459                 return false;
00460         }else
00461         {
00462                 *Consol<<"Loading Exec File :"<<FileName<<std::endl;
00463                         
00464                 fseek(MyFile,0,SEEK_END);
00465                 FileSize=ftell(MyFile);
00466                 
00467                 //Start of file
00468                 fseek(MyFile,0,SEEK_SET);
00469                 do
00470                 {
00471                         RetVal=fread(&ch,sizeof(char),1,MyFile);
00472                 }while(ch!='#');
00473                 //reading file type;
00474                 do
00475                 {
00476                         RetVal=fread(&ch,sizeof(char),1,MyFile);
00477                         StBuffer=StBuffer+ch;   
00478                 }while(ch!='#');
00479                 if(strcmp(StBuffer.data(),"exec#")==0)
00480                 {
00481                         do
00482                         {
00483                                 StBuffer.erase(StBuffer.begin(),StBuffer.end());
00484                                 do
00485                                 {
00486                                         RetVal=fread(&ch,sizeof(char),1,MyFile);
00487                                         StBuffer=StBuffer+ch;
00488                                 }while(ch!='#');
00489                                 StBuffer.erase(StBuffer.end()-1,StBuffer.end());
00490                                 StBuffer.erase(StBuffer.begin(),StBuffer.begin()+1);
00491                                 
00492                                 if(StBuffer.find("end of exec file")!= (unsigned)-1)
00493                                 {
00494                                         endfile=true;
00495                                 }else
00496                                 {
00497                                         std::cout<<StBuffer<<std::endl;
00498                                         //read action
00499                                         try
00500                                         {
00501                                                 NewActionA.m_Action=atoi(StBuffer.data());
00502                                         }catch(...)
00503                                         {
00504                                                 NewActionA.m_Action=NOTHING;    
00505                                         }
00506                                         StBuffer.erase(StBuffer.begin(),StBuffer.end());
00507                                         //read param
00508                                         do
00509                                         {
00510                                                 RetVal=fread(&ch,sizeof(char),1,MyFile);
00511                                                 StBuffer=StBuffer+ch;
00512                                         }while(ch!='#');
00513                                         StBuffer.erase(StBuffer.end()-1,StBuffer.end());
00514                                         std::cout<<StBuffer<<std::endl;
00515                     NewActionA.SetParam(StBuffer.data());
00516                                         StBuffer.erase(StBuffer.begin(),StBuffer.end());
00517                                         //read time to execute
00518                                         do
00519                                         {
00520                                                 RetVal=fread(&ch,sizeof(char),1,MyFile);
00521                                                 StBuffer=StBuffer+ch;
00522                                         }while(ch!='#');
00523                                         StBuffer.erase(StBuffer.end()-1,StBuffer.end());
00524                                         std::cout<<StBuffer<<std::endl;
00525                                         try
00526                                         {
00527                                                 NewActionA.m_ExecutingLife=atof(StBuffer.data());
00528                                         }catch(...)
00529                                         {
00530                                                 NewActionA.m_ExecutingLife=-1;  
00531                                         }       
00532                                         std::cout<<"time to exec"<<NewActionA.m_ExecutingLife<<std::endl;                                       
00533                                         
00534                                         AddNewAction(NewActionA);
00535                                 }
00536                         }while(!endfile);
00537                         fclose(MyFile);
00538                         return true;
00539                 }else
00540                 {
00541                         *Consol<<FileName<<" is not a valide exec file"<<std::endl;
00542                         return false;
00543                 }
00544         }
00545         
00546 UnGuard
00547 }
00548 
00549 bool ExManagerCommand::LoadFile(const char *FileName)
00550 {
00551         SAction action;
00552         action.SetParam(FileName);
00553         action.m_Action=30038;
00554     AddNewAction(action);
00555         return true;
00556 }
00557 //-----------------------------------------------------------
00558 // ici taper ce que fait l action
00559 //-----------------------------------------------------------
00560 bool ExManagerCommand::ProcessAction(SAction action)
00561 {
00562 Guard(bool ExManagerCommand::ProcessAction(SAction action))
00563         //cout<<"Process Action :"<<action<<endl;
00564         char *Param;
00565         float ParamFloat;
00566         Param= new char[strlen(action.m_Param)];
00567         sprintf(Param,"%s",(action.m_Param)+1);
00568         std::string Sparam(Param);
00569 
00570         
00571         //check if is time to execute action
00572         double ctime;
00573         ctime=(double)((double)glutGet(GLUT_ELAPSED_TIME)/1000);
00574 
00575         if(action.m_ExecutingLife<0||(double)ctime-action.m_ExecutingLife>=(action.m_StartingLife))
00576         {
00577                 logfilecommand<<"Process Action :"<<action.m_Action<<" Param :"<<action.m_Param<<std::endl;
00578                 //time to execute action
00579                 //-------------------------------------------------
00580                 //CONSOL ACTION
00581                 //-------------------------------------------------
00582                 if(action.m_Action>START_CONSOL_ACTION_MAP && action.m_Action<END_CONSOL_ACTION_MAP) 
00583                 {
00584                         
00585                         switch(action.m_Action)
00586                         {
00587                         case CONSOL_LINE_UP:                                            
00588                                 ManagerConsole->LineUp();
00589                                 break;
00590                         case CONSOL_LINE_DOWN:                                          
00591                                 ManagerConsole->LineDown();
00592                                 break;
00593             case SHOW_HALF_CONSOL:                                              
00594                                 if (! ManagerConsole->isConsoleMove ()) {
00595                                         ManagerConsole->ConsoleMove (true);
00596                                         ManagerConsole->SetConsoleState(HALF);
00597                                 }
00598                                 break;
00599                         case SHOW_FULL_CONSOL:
00600                                 if (! ManagerConsole->isConsoleMove ()) {
00601                                         ManagerConsole->ConsoleMove (true);
00602                                         ManagerConsole->SetConsoleState(FULL);
00603                                 }
00604                                         
00605                                 break;
00606                         
00607                         case HIDE_CONSOL:       
00608                                 if (! ManagerConsole->isConsoleMove ()) {
00609                                         ManagerConsole->ConsoleMove (true);
00610                                         ManagerConsole->SetConsoleState(HIDE);
00611                                 }
00612                                 break;
00613                         
00614                         case CONSOL_NEXT_AVIABLE_STATE:
00615                                 switch(ManagerConsole->NextAviableState())
00616                                 {
00617                                 case HIDE:
00618                                 case FULLTOHIDE:
00619                                 case HALFTOHIDE:
00620                                         ProcessAction(HIDE_CONSOL);
00621                     break;
00622                                 case HALF:
00623                                 case HIDETOHALF:
00624                                 case FULLTOHALF:
00625                                         ProcessAction(SHOW_HALF_CONSOL);
00626                                         break;
00627                                 case FULL:
00628                                 case HIDETOFULL:
00629                                 case HALFTOFULL:
00630                                         ProcessAction(SHOW_FULL_CONSOL);
00631                                         break;
00632                                 }
00633                                 break;
00634 
00635                         case SET_CONSOL_BACKGROUND_TEXURE:
00636                                 ManagerConsole->SetConsoleBackGroudTexture(Param);
00637                                 break;
00638                         case ENABLE_CONSOL_BACKGROUND_TEXTURE:
00639                                 ManagerConsole->SetConsoleBackGroudTextureState(true);
00640                                 break;
00641                         case DISABLE_CONSOL_BACKGROUND_TEXTURE:
00642                                 ManagerConsole->SetConsoleBackGroudTextureState(false);
00643                                 break;
00644                         case SET_CONSOL_BACKGROUND_COLOR:
00645 
00646                                 break;
00647                         case SET_CONSOL_BACKGROUND_COLOR_BLUE:
00648                                 try
00649                                 {
00650                                         ParamFloat=atof(Sparam.data());
00651                                         ManagerConsole->SetConsoleBackGroudColorBlue(ParamFloat);
00652                                 }catch(...)
00653                                 {
00654                                         *Consol<<"Enter a float value"<<std::endl;
00655                                 }
00656                                 break;
00657                         case SET_CONSOL_BACKGROUND_COLOR_GREEN:
00658                                 try
00659                                 {
00660                                         ParamFloat=atof(Sparam.data());
00661                                         ManagerConsole->SetConsoleBackGroudColorGreen(ParamFloat);
00662                                 }catch(...)
00663                                 {
00664                                         *Consol<<"Enter a float value"<<std::endl;
00665                                 }
00666                                 break;
00667                         case SET_CONSOL_BACKGROUND_COLOR_RED:
00668                                 try
00669                                 {
00670                                         ParamFloat=atof(Sparam.data());
00671                                         ManagerConsole->SetConsoleBackGroudColorRed(ParamFloat);
00672                                 }catch(...)
00673                                 {
00674                                         *Consol<<"Enter a float value"<<std::endl;
00675                                 }
00676                         case ENABLE_CONSOL_BACKGROUND_BLENDING:
00677                                 ManagerConsole->SetConsoleBackGroudBlendingState(true);
00678                                 break;
00679                         case DISABLE_CONSOL_BACKGROUND_BLENDING:
00680                                 ManagerConsole->SetConsoleBackGroudBlendingState(false);
00681                                 break;
00682                         case SET_CONSOL_BACKGROUND_BLENDING:
00683                                 try
00684                                 {
00685                                         ParamFloat=atof(Sparam.data());
00686                                         ManagerConsole->SetConsoleBackGroudBlending(ParamFloat);
00687                                 }catch(...)
00688                                 {
00689                                         *Consol<<"Enter a float value"<<std::endl;
00690                                 }
00691                                 break;
00692                         }
00693 
00694                 }
00695                 //-------------------------------------------------
00696                 //BASIC ACTION
00697                 //-------------------------------------------------
00698                 if(action.m_Action>=START_BASIC_ACTION_MAP && action.m_Action<END_BASIC_ACTION_MAP) 
00699                 {
00700                         switch(action.m_Action)
00701                         {
00702                         case NOTHING:
00703                                 break;
00704 
00705                         case QUIT:
00706                                 exit(0);
00707                                 break;
00708 
00709                         case SET_RENDERMODE_TEXTURES_LIGHT:
00710                                 if(ManagerEntite->GetNumberEntite()>0)
00711                                 {
00712                                         ManagerEntite->GetCurrentEntite()->SetRenderMode(RENDER_TEXTURES_LIGHT);
00713                                 }
00714                                 break;
00715                         
00716                         case SET_RENDERMODE_TEXTURES:
00717                                 if(ManagerEntite->GetNumberEntite()>0)
00718                                 {
00719                                         ManagerEntite->GetCurrentEntite()->SetRenderMode(RENDER_TEXTURES);
00720                                 }
00721                                 break;
00722                         
00723                         case SET_RENDERMODE_TRIANGLES_LIGHT     :
00724                                 if(ManagerEntite->GetNumberEntite()>0)
00725                                 {
00726                                         ManagerEntite->GetCurrentEntite()->SetRenderMode(RENDER_TRIANGLES_LIGHT);
00727                                 }
00728                                 break;
00729 
00730                         case SET_RENDERMODE_TRIANGLES:
00731                                 if(ManagerEntite->GetNumberEntite()>0)
00732                                 {
00733                                         ManagerEntite->GetCurrentEntite()->SetRenderMode(RENDER_TRIANGLES);
00734                                 }
00735                                 break;
00736                         
00737                         case SET_RENDERMODE_POINTS:
00738                                 if(ManagerEntite->GetNumberEntite()>0)
00739                                 {
00740                                         ManagerEntite->GetCurrentEntite()->SetRenderMode(RENDER_POINTS);
00741                                 }
00742                                 break;
00743                         
00744                         case SET_RENDERMODE_LINES:
00745                                 if(ManagerEntite->GetNumberEntite()>0)
00746                                 {
00747                                         ManagerEntite->GetCurrentEntite()->SetRenderMode(RENDER_LINES);
00748                                 }
00749                                 break;
00750                         
00751                         case SET_RENDERMODE_NO:
00752                                 if(ManagerEntite->GetNumberEntite()>0)
00753                                 {
00754                                         ManagerEntite->GetCurrentEntite()->SetRenderMode(RENDER_NO);
00755                                 }
00756                                 break;
00757 
00758                         case ENABLE_ANTIALIASING:
00759                                 ManagerWindow->SetAntialliasingState(true);
00760                                 break;
00761 
00762                         case DISABEL_ANTIALIASING:
00763                                 ManagerWindow->SetAntialliasingState(false);
00764                                 break;
00765 
00766                         case ENABLE_GRIDE:
00767                                 ManagerWindow->SetGrilleState(true);
00768                                 break;
00769 
00770                         case DISABLE_GRIDE:
00771                                 ManagerWindow->SetGrilleState(false);
00772                                 break;
00773 
00774                         case SWITCH_GRIDE:
00775                                 if(ManagerWindow->GetGrilleState())
00776                                 {
00777                                         ProcessAction(DISABLE_GRIDE);   
00778                                 }else
00779                                 {
00780                                         ProcessAction(ENABLE_GRIDE);
00781                                 }
00782                                 break;
00783                                                 
00784 
00785 
00786                         case SET_RESOLUTION_800_600_16:
00787                                 ManagerWindow->SetResolution(800,600);
00788                                 ManagerWindow->SetBits(16);
00789                                 ManagerWindow->SetFullScreen(true);
00790                                 ManagerWindow->Apply();
00791                                 break;
00792                         
00793                         case SET_RESOLUTION_800_600_24:
00794                                 ManagerWindow->SetResolution(800,600);
00795                                 ManagerWindow->SetBits(24);
00796                                 ManagerWindow->SetFullScreen(true);
00797                                 ManagerWindow->Apply();
00798                                 break;
00799 
00800                         case SET_RESOLUTION_800_600_32:
00801                                 ManagerWindow->SetResolution(800,600);
00802                                 ManagerWindow->SetBits(32);
00803                                 ManagerWindow->SetFullScreen(true);
00804                                 ManagerWindow->Apply();
00805                                 break;
00806 
00807                         case SET_RESOLUTION_1024_768_16:
00808                                 ManagerWindow->SetResolution(1024,768);
00809                                 ManagerWindow->SetBits(16);
00810                                 ManagerWindow->SetFullScreen(true);
00811                                 ManagerWindow->Apply();
00812                                 break;
00813                         
00814                         case SET_RESOLUTION_1024_768_24:
00815                                 ManagerWindow->SetResolution(1024,768);
00816                                 ManagerWindow->SetBits(24);
00817                                 ManagerWindow->SetFullScreen(true);
00818                                 ManagerWindow->Apply();
00819                                 break;
00820                         
00821                         case SET_RESOLUTION_1024_768_32:
00822                                 ManagerWindow->SetResolution(1024,768);
00823                                 ManagerWindow->SetBits(32);
00824                                 ManagerWindow->SetFullScreen(true);
00825                                 ManagerWindow->Apply();
00826                                 break;
00827                         
00828                         case SET_RESOLUTION_1600_1200_16:
00829                                 ManagerWindow->SetResolution(1600,1200);
00830                                 ManagerWindow->SetBits(16);
00831                                 ManagerWindow->SetFullScreen(true);
00832                                 ManagerWindow->Apply();
00833                                 break;
00834                         
00835                         case SET_RESOLUTION_1600_1200_24:
00836                                 ManagerWindow->SetResolution(1600,1200);
00837                                 ManagerWindow->SetBits(24);
00838                                 ManagerWindow->SetFullScreen(true);
00839                                 ManagerWindow->Apply();
00840                                 break;
00841                         
00842                         case SET_RESOLUTION_1600_1200_32:
00843                                 ManagerWindow->SetResolution(1600,1200);
00844                                 ManagerWindow->SetBits(32);
00845                                 ManagerWindow->SetFullScreen(true);
00846                                 ManagerWindow->Apply();
00847                                 break;
00848                         case LOAD_FILE:
00849                                 char Buffext[255];
00850                                 memset(Buffext,0,255);
00851                                 
00852                                 std::cout<<"file to load :"<<Param<<std::endl;
00853                         if(Sparam.find_first_of(".",0) != (unsigned)-1)
00854                                 {
00855                                         Sparam.copy(Buffext,Sparam.size()-Sparam.find_first_of(".",0)-1,Sparam.find_first_of(".",0)+1);
00856                                         if(strcmp(Buffext,"csl")==0)
00857                                         {
00858                                                 ManagerConsole->LoadStringActionFile(Param);
00859                                                 break;
00860                                         }else
00861                                         if(strcmp(Buffext,"comd")==0)
00862                                         {
00863                                                 LoadCommandFile(Param);
00864                                                 break;
00865                                         }else
00866                                         if(strcmp(Buffext,"wav")==0||strcmp(Buffext,"mid")==0)
00867                                         {
00868                                                 ManagerSound->LoadSound(Param);
00869                                                 break;                          
00870                                         }else
00871                                         if(strcmp(Buffext,"asc")==0
00872                                                 ||strcmp(Buffext,"ase")==0
00873                                                 ||strcmp(Buffext,"3ds")==0
00874                                                 ||strcmp(Buffext,"md2")==0
00875                                                 ||strcmp(Buffext,"md3")==0
00876                                                 ||strcmp(Buffext,"obj")==0)
00877                                         {
00878                                                 ManagerEntite->LoadAsc(Param);
00879                                                 ManagerEntite->LoadModel(Param);
00880                                                 break;
00881                                         }else
00882                                         if(strcmp(Buffext,"map")==0
00883                                                 ||strcmp(Buffext,"bsp")==0)
00884                                         {
00885                                                 ManagerMap->LoadMap(Param);
00886                                                 break;
00887                                         }else
00888                                         if(strcmp(Buffext,"int")==0)
00889                                         {
00890                                                 ManagerInterface->LoadInterface(Param);
00891                                                 break;
00892                                         }else
00893                                         if(strcmp(Buffext,"set")==0)
00894                                         {
00895                                                 LoadSetOfFile(Param);
00896                                                 break;
00897                                         }else
00898                                         if(strcmp(Buffext,"exec")==0)
00899                                         {
00900                                                 LoadExecFile(&action);
00901                                                 break;
00902                                         }
00903                                         else
00904                                         if(strcmp(Buffext,"part")==0)
00905                                         {
00906                                                 ManagerParticuleSystem->LoadParticuleSysteme(Param);
00907                                                 break;
00908                                         }
00909                                 }
00910                                 *Consol<<"*------------------------------------------------------------------------------------------------*"<<std::endl;
00911                                 *Consol<<"|                                Extension file supported by Exnihilo                            |"<<std::endl;
00912                                 *Consol<<"|------------------------------------------------------------------------------------------------|"<<std::endl;
00913                                 *Consol<<"|Description                 | Extension |  Status  |  Comment                                   |"<<std::endl;
00914                                 *Consol<<"|------------------------------------------------------------------------------------------------|"<<std::endl;                               
00915                                 *Consol<<"|Console configuration file  |  .csl     | Aviable  | Asign consol command to action             |"<<std::endl;
00916                                 *Consol<<"|Command configuration file  |  .comd    | Aviable  | Asign input (keyboard,mouse,...)to action  |"<<std::endl;
00917                                 *Consol<<"|------------------------------------------------------|-----------------------------------------|"<<std::endl;                               
00918                                 *Consol<<"|ExNihilo map file           |  .map     | Aviable  | Create map file with AscToMap converter    |"<<std::endl;
00919                                 *Consol<<"|Quake map file              |  .bsp     |          |                                            |"<<std::endl;
00920                                 *Consol<<"|------------------------------------------------------------------------------------------------|"<<std::endl;                               
00921                                 *Consol<<"|ASC model  file             |  .asc     | Aviable  | Create a 3d model and export him to *.asc  |"<<std::endl;
00922                                 *Consol<<"|MD2 (quake 2) model  file   |  .md2     |          |                                            |"<<std::endl;
00923                 *Consol<<"|MD3 (quake 3) model  file   |  .md3     |          |                                            |"<<std::endl;
00924                                 *Consol<<"|ASE model  file             |  .ase     |          |                                            |"<<std::endl;
00925                                 *Consol<<"|3d studio max model  file   |  .3ds     |          |                                            |"<<std::endl;
00926                                 *Consol<<"|OBJ model  file             |  .obj     |          |                                            |"<<std::endl;
00927                                 *Consol<<"|------------------------------------------------------------------------------------------------|"<<std::endl;                               
00928                                 *Consol<<"|Wave sound file             |  .wav     |          |                                            |"<<std::endl;
00929                 *Consol<<"|Midi sound file             |  .mid     |          |                                            |"<<std::endl;
00930                                 *Consol<<"|Mp3 sound file              |  .mp3     |          |                                            |"<<std::endl;
00931                                 *Consol<<"|------------------------------------------------------------------------------------------------|"<<std::endl;
00932                                 *Consol<<"|Particule system  file      |  .part    | Aviable  |                                            |"<<std::endl;
00933                                 *Consol<<"|Interface file              |  .int     | Aviable  |                                            |"<<std::endl;
00934                                 *Consol<<"|------------------------------------------------------------------------------------------------|"<<std::endl;                               
00935                                 *Consol<<"|Groupe of file              |  .set     | Aviable  |                                            |"<<std::endl;
00936                                 *Consol<<"|Groupe of action            |  .exec    | Aviable  |                                            |"<<std::endl;
00937                                 *Consol<<"*------------------------------------------------------------------------------------------------*"<<std::endl;
00938                                 break;
00939 
00940                         case LOAD_SET_OF_FILE:
00941                                 LoadSetOfFile(Param);
00942                                 break;
00943 
00944                         case SHOW_NET_STAT:
00945                                 ManagerWindow->SetNetstatState(true);
00946                                 break;
00947 
00948                         case HIDE_NET_STAT:
00949                                 ManagerWindow->SetNetstatState(false);
00950                                 break;
00951 
00952                         case SHOW_FPS_STAT:
00953                                 ManagerWindow->SetFpsState(true);
00954                                 break;
00955 
00956                         case HIDE_FPS_STAT:
00957                                 ManagerWindow->SetFpsState(true);
00958                                 break;
00959 
00960                         case RESET:
00961                                 //ManagerMenu->Reset();
00962                                 ManagerId->Reset();
00963                                 ManagerPVS->Reset();
00964                                 ManagerCollision->Reset();
00965                                 ManagerAnim->Reset();
00966                                 ManagerMap->Reset();    
00967                                 ManagerFog->Reset();
00968                                 ManagerEntite->Reset();
00969                                 ManagerGizmo->Reset();
00970                                 ManagerLight->Reset();
00971                                 ManagerCam->Reset();
00972                                 //ManagerParticuleSystem->Reset();
00973                                 ManagerTexture->Reset();
00974                                 ManagerInterface->Reset();
00975                                 ManagerConsole->Reset();
00976                                 ManagerSpirit->Reset();
00977                                 ManagerSound->Reset();
00978                                 ManagerConsole->ClearConsol();
00979                                 *Consol<<"Engine reseted"<<std::endl;
00980                                 break;
00981 
00982                         case ENABLE_MULTIVIEW:
00983                                 ManagerCam->m_multiview=true;
00984                                 break;
00985 
00986                         case DISABLE_MULTIVIEW:
00987                                 ManagerCam->m_multiview=false;
00988                                 break;
00989 
00990                         case LIST_TEXTURE:
00991                                 ManagerTexture->ListAllTexture();
00992                                 break;
00993                         
00994                         case SET_SPECIAL_EFFECT:
00995                                 try
00996                                 {
00997                                         ManagerWindow->SetSpecialEffect(atoi(Param));
00998                                 }catch(...)
00999                                 {
01000                                         ManagerWindow->SetSpecialEffect(NON_EFFECT);
01001                                 }
01002 
01003                                 break;
01004                         default:
01005                                 *Consol<<"Can not file action in BASIC_ACTION_MAP"<<std::endl;
01006                                 break;
01007                         }
01008 
01009                 }
01010 
01011                 //-------------------------------------------------
01012                 //CAMERA ACTION
01013                 //-------------------------------------------------
01014                 if(action.m_Action>START_CAMERA_ACTION_MAP && action.m_Action<END_CAMERA_ACTION_MAP) 
01015                 {
01016                         switch(action.m_Action)
01017                         {
01018                         case CAMERA_CURRENT_START_GOTO_TARGET:
01019                                 AddRepAction(CAMERA_CURRENT_GOTO_TARGET);
01020                                 break;
01021                         
01022                         case CAMERA_CURRENT_STOP_GOTO_TARGET:
01023                                 RemoveRepAction(CAMERA_CURRENT_GOTO_TARGET);
01024                                 break;
01025                         
01026                         case CAMERA_CURRENT_GOTO_TARGET:
01027                                 ManagerCam->GetCurrentCam()->GoToView(true);
01028                                 break;
01029 
01030                         case CAMERA_CURRENT_START_INCREASE_SPEED:
01031                                 AddRepAction(CAMERA_CURRENT_INCREASE_SPEED);
01032                                 break;
01033                         
01034                         case CAMERA_CURRENT_STOP_INCREASE_SPEED:
01035                                 RemoveRepAction(CAMERA_CURRENT_INCREASE_SPEED);
01036                                 break;
01037                         
01038                         case CAMERA_CURRENT_INCREASE_SPEED:
01039                                 ManagerCam->GetCurrentCam()->m_speed++;
01040                                 //std::cout<<"Camera Speed"<<ManagerCam->GetCurrentCam()->m_speed<<std::endl;
01041                                 break;
01042                         
01043                         case CAMERA_CURRENT_START_DECREASE_SPEED:
01044                                 AddRepAction(CAMERA_CURRENT_DECREASE_SPEED);
01045                                 break;
01046                         
01047                         case CAMERA_CURRENT_STOP_DECREASE_SPEED:
01048                                 RemoveRepAction(CAMERA_CURRENT_DECREASE_SPEED);
01049                                 break;
01050                         
01051                         case CAMERA_CURRENT_DECREASE_SPEED:
01052                                 if(ManagerCam->GetCurrentCam()->m_speed>0)
01053                                 {
01054                                         ManagerCam->GetCurrentCam()->m_speed--;
01055                                 }
01056                                 //std::cout<<"Camera Speed"<<ManagerCam->GetCurrentCam()->m_speed<<std::endl;
01057                                 break;
01058 
01059                         case CAMERA_CURRENT_FULL_STOP:
01060                                 ManagerCam->GetCurrentCam()->m_speed=0;
01061                                 //std::cout<<"Camera Speed"<<ManagerCam->GetCurrentCam()->m_speed<<std::endl;
01062                                 break;
01063 
01064 
01065                         case CAMERA_CURRENT_START_ROTATEX_UP:
01066                                 AddRepAction(CAMERA_CURRENT_ROTATEX_UP);
01067                                 break;
01068                         
01069                         case CAMERA_CURRENT_STOP_ROTATEX_UP:
01070                                 RemoveRepAction(CAMERA_CURRENT_ROTATEX_UP);
01071                                 break;
01072                         
01073                         case CAMERA_CURRENT_ROTATEX_UP:
01074                                 ManagerCam->GetCurrentCam()->m_AngleX++;
01075                                 ManagerCam->GetCurrentCam()->m_AngleX++;
01076                                 break;
01077                         
01078                         case CAMERA_CURRENT_START_ROTATEX_DOWN:
01079                                 AddRepAction(CAMERA_CURRENT_ROTATEX_DOWN);
01080                                 break;
01081                         
01082                         case CAMERA_CURRENT_STOP_ROTATEX_DOWN:
01083                                 RemoveRepAction(CAMERA_CURRENT_ROTATEX_DOWN);
01084                                 break;
01085                         
01086                         case CAMERA_CURRENT_ROTATEX_DOWN:
01087                                 ManagerCam->GetCurrentCam()->m_AngleX--;
01088                                 ManagerCam->GetCurrentCam()->m_AngleX--;
01089                                 break;
01090 
01091                         case CAMERA_CURRENT_START_ROTATEZ_UP:
01092                                 AddRepAction(CAMERA_CURRENT_ROTATEZ_UP);
01093                                 break;
01094                         
01095                         case CAMERA_CURRENT_STOP_ROTATEZ_UP:
01096                                 RemoveRepAction(CAMERA_CURRENT_ROTATEZ_UP);
01097                                 break;
01098                         
01099                         case CAMERA_CURRENT_ROTATEZ_UP:
01100                                 ManagerCam->GetCurrentCam()->m_AngleZ++;
01101                                 ManagerCam->GetCurrentCam()->m_AngleZ++;
01102                                 break;
01103                         
01104                         case CAMERA_CURRENT_START_ROTATEZ_DOWN:
01105                                 AddRepAction(CAMERA_CURRENT_ROTATEZ_DOWN);
01106                                 break;
01107                         
01108                         case CAMERA_CURRENT_STOP_ROTATEZ_DOWN:
01109                                 RemoveRepAction(CAMERA_CURRENT_ROTATEZ_DOWN);
01110                                 break;
01111                         
01112                         case CAMERA_CURRENT_ROTATEZ_DOWN:
01113                                 ManagerCam->GetCurrentCam()->m_AngleZ--;
01114                                 ManagerCam->GetCurrentCam()->m_AngleZ--;
01115                                 break;
01116 
01117                         case CAMERA_CURRENT_START_ROTATEY_UP:
01118                                 AddRepAction(CAMERA_CURRENT_ROTATEY_UP);
01119                                 break;
01120                         
01121                         case CAMERA_CURRENT_STOP_ROTATEY_UP:
01122                                 RemoveRepAction(CAMERA_CURRENT_ROTATEY_UP);
01123                                 break;
01124                         
01125                         case CAMERA_CURRENT_ROTATEY_UP:
01126                                 ManagerCam->GetCurrentCam()->m_AngleY++;
01127                                 ManagerCam->GetCurrentCam()->m_AngleY++;
01128                                 break;
01129                         
01130                         case CAMERA_CURRENT_START_ROTATEY_DOWN:
01131                                 AddRepAction(CAMERA_CURRENT_ROTATEY_DOWN);
01132                                 break;
01133                         
01134                         case CAMERA_CURRENT_STOP_ROTATEY_DOWN:
01135                                 RemoveRepAction(CAMERA_CURRENT_ROTATEY_DOWN);
01136                                 break;
01137                         
01138                         case CAMERA_CURRENT_ROTATEY_DOWN:
01139                                 ManagerCam->GetCurrentCam()->m_AngleY--;
01140                                 ManagerCam->GetCurrentCam()->m_AngleY--;
01141                                 break;
01142 
01143                         case CAMERA_CURRENT_ROTATEY_UP_TO:
01144                                         if(ManagerCam->GetCurrentCam()->m_AngleY<atoi(Param))
01145                                         {
01146                                                 ManagerCam->GetCurrentCam()->m_AngleY++;
01147                                                 ManagerCam->GetCurrentCam()->m_AngleY++;
01148                                                 char *nparam;
01149                                                 nparam= new char[strlen(Param)+1];
01150                                                 sprintf(nparam," %s",Param);
01151                                                 SAction action;
01152                                                 action.m_ExecutingLife=0.05f;
01153                                                 action.SetParam(nparam);
01154                                                 action.m_Action=CAMERA_CURRENT_ROTATEY_UP_TO;
01155                                                 AddNewAction(action);
01156                                         }
01157                                 break;
01158 
01159                         case CAMERA_CURRENT_ROTATEY_DOWN_TO:
01160                                         if(ManagerCam->GetCurrentCam()->m_AngleY>atoi(Param))
01161                                         {
01162                                                 ManagerCam->GetCurrentCam()->m_AngleY--;
01163                                                 ManagerCam->GetCurrentCam()->m_AngleY--;
01164                                                 char *nparam;
01165                                                 nparam= new char[strlen(Param)+1];
01166                                                 sprintf(nparam," %s",Param);
01167                                                 SAction action;
01168                                                 action.m_ExecutingLife=0.05f;
01169                                                 action.SetParam(nparam);
01170                                                 action.m_Action=CAMERA_CURRENT_ROTATEY_UP_TO;
01171                                                 AddNewAction(action);
01172                                         }
01173                                 break;
01174 
01175                         case CAMERA_CURRENT_ROTATEX_UP_TO:
01176                                         if(ManagerCam->GetCurrentCam()->m_AngleX<atoi(Param))
01177                                         {
01178                                                 ManagerCam->GetCurrentCam()->m_AngleX++;
01179                                                 ManagerCam->GetCurrentCam()->m_AngleX++;
01180                                                 char *nparam;
01181                                                 nparam= new char[strlen(Param)+1];
01182                                                 sprintf(nparam," %s",Param);
01183                                                 SAction action;
01184                                                 action.SetParam(nparam);
01185                                                 action.m_Action=CAMERA_CURRENT_ROTATEX_UP_TO;
01186                                                 AddNewAction(action);
01187                                         }
01188                                 break;
01189 
01190                         case CAMERA_CURRENT_ROTATEX_DOWN_TO:
01191                                         if(ManagerCam->GetCurrentCam()->m_AngleX>atoi(Param))
01192                                         {
01193                                                 ManagerCam->GetCurrentCam()->m_AngleX--;
01194                                                 ManagerCam->GetCurrentCam()->m_AngleX--;
01195                                                 char *nparam;
01196                                                 nparam= new char[strlen(Param)+1];
01197                                                 sprintf(nparam," %s",Param);
01198                                                 SAction action;
01199                                                 action.SetParam(nparam);
01200                                                 action.m_Action=CAMERA_CURRENT_ROTATEX_UP_TO;
01201                                                 AddNewAction(action);
01202                                         }
01203                                 break;
01204 
01205                         case CAMERA_CURRENT_ROTATEZ_UP_TO:
01206                                         if(ManagerCam->GetCurrentCam()->m_AngleZ<atoi(Param))
01207                                         {
01208                                                 ManagerCam->GetCurrentCam()->m_AngleZ++;
01209                                                 ManagerCam->GetCurrentCam()->m_AngleZ++;
01210                                                 char *nparam;
01211                                                 nparam= new char[strlen(Param)+1];
01212                                                 sprintf(nparam," %s",Param);
01213                                                 SAction action;
01214                                                 action.SetParam(nparam);
01215                                                 action.m_Action=CAMERA_CURRENT_ROTATEZ_UP_TO;
01216                                                 AddNewAction(action);
01217                                         }
01218                                 break;
01219 
01220                         case CAMERA_CURRENT_ROTATEZ_DOWN_TO:
01221                                         if(ManagerCam->GetCurrentCam()->m_AngleZ>atoi(Param))
01222                                         {
01223                                                 ManagerCam->GetCurrentCam()->m_AngleZ--;
01224                                                 ManagerCam->GetCurrentCam()->m_AngleZ--;
01225                                                 char *nparam;
01226                                                 nparam= new char[strlen(Param)+1];
01227                                                 sprintf(nparam," %s",Param);
01228                                                 SAction action;
01229                                                 action.SetParam(nparam);
01230                                                 action.m_Action=CAMERA_CURRENT_ROTATEZ_UP_TO;
01231                                                 AddNewAction(action);
01232                                         }
01233                                 break;
01234 
01235                         case CAMERA_NEXT_CAM:
01236                                 ManagerCam->NextCam();
01237                                 break;
01238                         case CAMERA_PREV_CAM:
01239                                 ManagerCam->PrevCam();
01240                                 break;
01241                         default:
01242                                 *Consol<<"Can not file action in CAMERA_ACTION_MAP"<<std::endl;
01243                                 break;
01244                         }
01245 
01246                 }
01247 
01248 
01249                 //-------------------------------------------------
01250                 //FOG ACTION
01251                 //-------------------------------------------------
01252                 if(action.m_Action>START_FOG_ACTION_MAP && action.m_Action<END_FOG_ACTION_MAP) 
01253                 {
01254                         switch(action.m_Action)
01255                         {
01256                         case ENABLE_FOG:
01257                                 ManagerFog->EnableFog();
01258                                 break;
01259 
01260                         case DISABEL_FOG:
01261                                 ManagerFog->DisableFog();
01262                                 break;
01263                         
01264                         case SET_FOG_COLOR_R:
01265                                 try
01266                                 {
01267                                         ParamFloat=atof(Sparam.data());
01268                                         ManagerFog->SetFogColorR(ParamFloat);
01269                                 }catch(...)
01270                                 {
01271                                         *Consol<<"Enter a float value"<<std::endl;
01272                                 }
01273                                 break;
01274 
01275                         case SET_FOG_COLOR_G:
01276                                 try
01277                                 {
01278                                         ParamFloat=atof(Sparam.data());
01279                                         ManagerFog->SetFogColorG(ParamFloat);
01280                                 }catch(...)
01281                                 {
01282                                         *Consol<<"Enter a float value"<<std::endl;
01283                                 }
01284                                 break;
01285                                 
01286                         case SET_FOG_COLOR_B:
01287                                 try
01288                                 {
01289                                         ParamFloat=atof(Sparam.data());
01290                                         ManagerFog->SetFogColorB(ParamFloat);
01291                                 }catch(...)
01292                                 {
01293                                         *Consol<<"Enter a float value"<<std::endl;
01294                                 }
01295                                 break;
01296                                                 
01297                         case SET_FOG_START_POINT:
01298                                 try
01299                                 {
01300                                         ParamFloat=atof(Sparam.data());
01301                                         ManagerFog->SetStartPoint(ParamFloat);
01302                                 }catch(...)
01303                                 {
01304                                         *Consol<<"Enter a float value"<<std::endl;
01305                                 }
01306                                 break;
01307                                 
01308                         case SET_FOG_END_POINT:
01309                                 try
01310                                 {
01311                                         ParamFloat=atof(Sparam.data());
01312                                         ManagerFog->SetEndPoint(ParamFloat);
01313                                 }catch(...)
01314                                 {
01315                                         *Consol<<"Enter a float value"<<std::endl;
01316                                 }
01317                                 break;
01318 
01319                         case SET_FOG_DENSITY:
01320                                 try
01321                                 {
01322                                         ParamFloat=atof(Sparam.data());
01323                                         ManagerFog->SetDensity(ParamFloat);
01324                                 }catch(...)
01325                                 {
01326                                         *Consol<<"Enter a float value"<<std::endl;
01327                                 }
01328                                 break;
01329 
01330                         case SET_FOG_ALGO_LINEAR:
01331                                 ManagerFog->SetAlgo(GL_LINEAR);
01332                                 break;
01333 
01334                         case SET_FOG_ALGO_EXP:
01335                                 ManagerFog->SetAlgo(GL_EXP);
01336                                 break;
01337 
01338                         case SET_FOG_ALGO_EXP2:
01339                                 ManagerFog->SetAlgo(GL_LINEAR);
01340                                 break;
01341 
01342                         default:
01343                                 *Consol<<"Can not file action in FOG_ACTION_MAP"<<std::endl;
01344                                 break;
01345                         }
01346 
01347                 }
01348 
01349                 //-------------------------------------------------
01350                 //INTERFACE ACTION
01351                 //-------------------------------------------------
01352                 if(action.m_Action>START_INTERFACE_ACTION_MAP && action.m_Action<END_INTERFACE_ACTION_MAP) 
01353                 {
01354                         switch(action.m_Action)
01355                         {
01356                         case ENABLE_INTERFACE:
01357                                 if(ManagerInterface->EnableInterface(Param)>0)
01358                                 {
01359                                         ManagerWindow->SetInterfaceState(true);
01360                                 }
01361                                 break;
01362                 
01363                         case DISABLE_INTERFACE:
01364                                 if(ManagerInterface->DisableInterface(Param)==0)
01365                                 {
01366                                         ManagerWindow->SetInterfaceState(false);
01367                                 }
01368                                 break;
01369 
01370                         case ENABLE_ALL_INTERFACE:
01371                                 if(ManagerInterface->EnableAllInterface()>0)
01372                                 {
01373                                         ManagerWindow->SetInterfaceState(true);
01374                                 }
01375                                 break;
01376                 
01377                         case DISABLE_ALL_INTERFACE:
01378                                 ManagerInterface->DisableAllInterface();
01379                                 ManagerWindow->SetInterfaceState(false);
01380                                 break;
01381 
01382                         case LIST_INTERFACE:
01383                                 ManagerInterface->ListInterface();
01384                                 break;
01385 
01386                         case ADD_INTERFACE:
01387                                 ManagerInterface->LoadInterface(Param);
01388                                 break;
01389 
01390                         case SHOW_INTERFACE_REGION:
01391                                 ManagerInterface->ShowRegion();
01392                                 break;
01393 
01394                         case HIDE_INTERFACE_REGION:
01395                                 ManagerInterface->HideRegion();
01396                                 break;
01397                                 
01398                         default:
01399                                 *Consol<<"Can not file action in INTERFACE_ACTION_MAP"<<std::endl;
01400                                 break;
01401 
01402                         }
01403 
01404                 }
01405 
01406 
01407                 //-------------------------------------------------
01408                 //SOUND ACTION
01409                 //-------------------------------------------------
01410                 if(action.m_Action>START_SOUND_ACTION_MAP && action.m_Action<END_SOUND_ACTION_MAP) 
01411                 {
01412                         switch(action.m_Action)
01413                         {
01414                         case LIST_SOUND:
01415                                 ManagerSound->ListAllSound();
01416                                 break;
01417 
01418                         case REMOVE_SOUND:
01419                                 ManagerSound->RemoveSound(Param);
01420                                 break;
01421 
01422                         case PLAY_SOUND:
01423                                 ManagerSound->PlaySound(Param);
01424                                 break;
01425 
01426                         case STOP_SOUND:
01427                                 ManagerSound->StopSound(Param);
01428                                 break;
01429 
01430                         case ADD_SOUND:
01431                                 ManagerSound->LoadSound(Param);
01432                                 break;
01433 
01434                         case SET_REPEATS_SOUND:
01435                                 //ManagerSound->SetRepeats(Param);
01436                                 break;
01437 
01438                         case GET_REPEATS_SOUND:
01439                                 //ManagerSound->GetRepeats(Param);
01440                                 break;
01441                         
01442                         default:
01443                                 *Consol<<"Can not file action in SOUND_ACTION_MAP"<<std::endl;
01444                                 break;
01445                         }
01446 
01447                 }
01448 
01449                 //-------------------------------------------------
01450                 //MAP ACTION
01451                 //-------------------------------------------------
01452                 if(action.m_Action>START_MAP_ACTION_MAP && action.m_Action<END_MAP_ACTION_MAP) 
01453                 {
01454                         switch(action.m_Action)
01455                         {
01456 
01457                         case SHOW_MAP_SKY_BOX:
01458                                 ManagerMap->ShowSkybox();
01459                                 break;
01460 
01461                         case HIDE_MAP_SKY_BOX:
01462                                 ManagerMap->HideSkybox();
01463                                 break;
01464 
01465                         case SHOW_MAP_MESH:
01466                                 ManagerMap->ShowMesh();
01467                                 break;
01468 
01469                         case HIDE_MAP_MESH:
01470                                 ManagerMap->HideMesh();
01471                                 break;
01472 
01473                         case ENABLE_MAP_OCTREE:
01474                                 ManagerMap->EnableOctree();
01475                                 break;
01476 
01477                         case DISABLE_MAP_OCTREE:
01478                                 ManagerMap->DisableOctree();
01479                                 break;
01480 
01481                         case SHOW_MAP_OCTREE_SUBDIVISON:
01482                                 ManagerMap->ShowOctreeSubdivision();
01483                                 break;
01484 
01485                         case HIDE_MAP_OCTREE_SUBDIVISON:
01486                                 ManagerMap->HideOctreeSubdivision();
01487                                 break;
01488 
01489                         default:
01490                                 *Consol<<"Can not file action in MAP_ACTION_MAP"<<std::endl;
01491                                 break;
01492                         }
01493 
01494                 }
01495 
01496                 //-------------------------------------------------
01497                 //PARTICULESYSTEME ACTION
01498                 //-------------------------------------------------
01499                 if(action.m_Action>START_PARTICULESYSTEME_ACTION_MAP && action.m_Action<END_PARTICULESYSTEME_ACTION_MAP) 
01500                 {
01501                         switch(action.m_Action)
01502                         {
01503                         case LOAD_PARTICULESYSTEME:
01504                                 ManagerParticuleSystem->LoadParticuleSysteme(Param);
01505                                 break;
01506 
01507                         case STAR_PARTICULESYSTEME:
01508                                 ManagerParticuleSystem->StartParticuleSysteme(Param);
01509                                 break;
01510 
01511                         case STOP_PARTICULESYSTEME:
01512                                 ManagerParticuleSystem->StopParticuleSysteme(Param);
01513                                 break;
01514 
01515                         case PAUSE_PARTICULESYSTEME:
01516                                 ManagerParticuleSystem->PauseParticuleSysteme(Param);
01517                                 break;
01518 
01519                         case STAR_ALL_PARTICULESYSTEME:
01520                                 ManagerParticuleSystem->StartAllParticuleSysteme();
01521                                 break;
01522 
01523                         case STOP_ALL_PARTICULESYSTEME:
01524                                 ManagerParticuleSystem->StopAllParticuleSysteme();
01525                                 break;
01526 
01527                         case PAUSE_ALL_PARTICULESYSTEME:
01528                                 ManagerParticuleSystem->PauseAllParticuleSysteme();
01529                                 break;
01530 
01531                         case LIST_PARTICULESYSTEME:
01532                                 ManagerParticuleSystem->ListParticuleSysteme();
01533                                 break;
01534 
01535                         default:
01536                                 *Consol<<"Can not file action in PARTICULESYSTEME_ACTION_MAP"<<std::endl;
01537                                 break;
01538                         }
01539 
01540                 }
01541 
01542         //-------------------------------------------------
01543         //ENTITE ACTION
01544         //-------------------------------------------------
01545         if(action.m_Action>START_ENTITE_ACTION_MAP && action.m_Action<END_ENTITE_ACTION_MAP) 
01546         {
01547                 SAction EntiteAction;
01548                 
01549                 switch(action.m_Action)
01550                 {
01551                 case LIST_ENTITE:
01552                         ManagerEntite->ListEntite();
01553                         break;
01554 
01555                 case SET_NEXT_ENTITE_CURRENT:
01556                         if(ManagerEntite->GetNumberEntite()>0)
01557                         {
01558                                 ManagerEntite->NextEntite();
01559                         }
01560                 break;
01561 
01562                 case SET_CURRENT_ENTITE:
01563                         if(ManagerEntite->GetNumberEntite()>0)
01564                         {
01565                                 try
01566                                 {
01567                                         ManagerEntite->SetCurrentEntite(atoi(Sparam.data()));
01568                                 }
01569                                 catch(...)
01570                                 {
01571                                         ManagerEntite->SetCurrentEntite(ManagerId->GetObjectIdByName((char *)Sparam.data()));   
01572                                 }
01573                                 
01574                         }
01575                 break;
01576 
01577                 case SET_CURRENT_ENTITE_NAME:
01578                         if(ManagerEntite->GetNumberEntite()>0)
01579                         {
01580                                 ManagerEntite->SetCurrentEntiteName(Sparam.data());
01581                         }
01582                         break;
01583 
01584                 case ENTITE_CURRENT_INCREASE_VELOCITY_X:
01585                         break;
01586 
01587                 case ENTITE_CURRENT_DECREASE_VELOCITY_X:
01588                         break;
01589 
01590                 case ENTITE_CURRENT_START_INCREASE_VELOCITY_X:
01591                         break;
01592 
01593                 case ENTITE_CURRENT_STOP_INCREASE_VELOCITY_X:
01594                         break;
01595 
01596                 case ENTITE_CURRENT_START_DECREASE_VELOCITY_X:
01597                         break;
01598 
01599                 case ENTITE_CURRENT_STOP_DECREASE_VELOCITY_X:
01600                         break;
01601 
01602                 case ENTITE_CURRENT_INCREASE_VELOCITY_Y:
01603                         if(ManagerEntite->GetNumberEntite()>0)
01604                         {
01605                                 ManagerEntite->GetCurrentEntite();
01606                         }
01607                         break;
01608 
01609                 case ENTITE_CURRENT_DECREASE_VELOCITY_Y:
01610                         if(ManagerEntite->GetNumberEntite()>0)
01611                         {
01612                                 ManagerEntite->GetCurrentEntite();
01613                         }
01614                         break;
01615 
01616                 case ENTITE_CURRENT_START_INCREASE_VELOCITY_Y:
01617                         break;
01618 
01619                 case ENTITE_CURRENT_STOP_INCREASE_VELOCITY_Y:
01620                         break;
01621 
01622                 case ENTITE_CURRENT_START_DECREASE_VELOCITY_Y:
01623                         break;
01624 
01625                 case ENTITE_CURRENT_STOP_DECREASE_VELOCITY_Y:
01626                         break;
01627 
01628                 case ENTITE_CURRENT_INCREASE_VELOCITY_Z:
01629                         break;
01630 
01631                 case ENTITE_CURRENT_DECREASE_VELOCITY_Z:
01632                         break;
01633 
01634                 case ENTITE_CURRENT_START_INCREASE_VELOCITY_Z:
01635                         break;
01636 
01637                 case ENTITE_CURRENT_STOP_INCREASE_VELOCITY_Z:
01638                         break;
01639 
01640                 case ENTITE_CURRENT_START_DECREASE_VELOCITY_Z:
01641                         break;
01642 
01643                 case ENTITE_CURRENT_STOP_DECREASE_VELOCITY_Z:
01644                         break;
01645 
01646                 case ENTITE_CURRENT_SET_VELOCITY_X:
01647                         break;
01648 
01649                 case ENTITE_CURRENT_SET_VELOCITY_Y:
01650                         break;
01651 
01652                 case ENTITE_CURRENT_SET_VELOCITY_Z:
01653                         break;
01654 
01655                 case ENTITE_CURRENT_START_ROTATE_X_UP:
01656                         EntiteAction.m_Action=ENTITE_CURRENT_ROTATE_X_UP;
01657                         AddRepAction(EntiteAction);
01658                         break;
01659 
01660                 case ENTITE_CURRENT_STOP_ROTATE_X_UP:
01661                         RemoveRepAction(ENTITE_CURRENT_ROTATE_X_UP);
01662                         break;
01663 
01664                 case ENTITE_CURRENT_ROTATE_X_UP:
01665                         if(ManagerEntite->GetNumberEntite()>0)
01666                         {
01667                                 ManagerEntite->GetCurrentEntite()->m_AngleX++;
01668                                 ManagerEntite->GetCurrentEntite()->Rotate();
01669                         }
01670                         break;
01671 
01672                 case ENTITE_CURRENT_START_ROTATE_Y_UP:
01673                         EntiteAction.m_Action=ENTITE_CURRENT_ROTATE_Y_UP;
01674                         AddRepAction(EntiteAction);
01675                         break;
01676 
01677                 case ENTITE_CURRENT_STOP_ROTATE_Y_UP:
01678                         RemoveRepAction(ENTITE_CURRENT_ROTATE_Y_UP);
01679                         break;
01680 
01681                 case ENTITE_CURRENT_ROTATE_Y_UP:
01682                         if(ManagerEntite->GetNumberEntite()>0)
01683                         {
01684                                 ManagerEntite->GetCurrentEntite()->m_AngleY++;
01685                                 ManagerEntite->GetCurrentEntite()->Rotate();
01686                         }
01687                         break;
01688 
01689                 case ENTITE_CURRENT_START_ROTATE_Z_UP:
01690                         EntiteAction.m_Action=ENTITE_CURRENT_ROTATE_Z_UP;
01691                         AddRepAction(EntiteAction);
01692                         break;
01693 
01694                 case ENTITE_CURRENT_STOP_ROTATE_Z_UP:
01695                         RemoveRepAction(ENTITE_CURRENT_ROTATE_Z_UP);
01696                         break;
01697 
01698                 case ENTITE_CURRENT_ROTATE_Z_UP:
01699                         if(ManagerEntite->GetNumberEntite()>0)
01700                         {
01701                                 ManagerEntite->GetCurrentEntite()->m_AngleZ++;
01702                                 ManagerEntite->GetCurrentEntite()->Rotate();
01703                         }
01704                         break;
01705 
01706                 case ENTITE_CURRENT_START_ROTATE_X_DOWN:
01707                         EntiteAction.m_Action=ENTITE_CURRENT_ROTATE_X_DOWN;
01708                         AddRepAction(EntiteAction);
01709                         break;
01710 
01711                 case ENTITE_CURRENT_STOP_ROTATE_X_DOWN:
01712                         RemoveRepAction(ENTITE_CURRENT_ROTATE_X_DOWN);
01713                         break;
01714 
01715                 case ENTITE_CURRENT_ROTATE_X_DOWN:
01716                         if(ManagerEntite->GetNumberEntite()>0)
01717                         {
01718                                 ManagerEntite->GetCurrentEntite()->m_AngleX--;
01719                                 ManagerEntite->GetCurrentEntite()->Rotate();
01720                         }
01721                         break;
01722 
01723                 case ENTITE_CURRENT_START_ROTATE_Y_DOWN:
01724                         EntiteAction.m_Action=ENTITE_CURRENT_ROTATE_Y_DOWN;
01725                         AddRepAction(EntiteAction);
01726                         break;
01727 
01728                 case ENTITE_CURRENT_STOP_ROTATE_Y_DOWN:
01729                         RemoveRepAction(ENTITE_CURRENT_ROTATE_Y_DOWN);
01730                         break;
01731 
01732                 case ENTITE_CURRENT_ROTATE_Y_DOWN:
01733                         if(ManagerEntite->GetNumberEntite()>0)
01734                         {
01735                                 ManagerEntite->GetCurrentEntite()->m_AngleY--;
01736                                 ManagerEntite->GetCurrentEntite()->Rotate();
01737                         }
01738                         break;
01739 
01740                 case ENTITE_CURRENT_START_ROTATE_Z_DOWN:
01741                         EntiteAction.m_Action=ENTITE_CURRENT_ROTATE_Z_DOWN;
01742                         AddRepAction(EntiteAction);
01743                         break;
01744 
01745                 case ENTITE_CURRENT_STOP_ROTATE_Z_DOWN:
01746                         RemoveRepAction(ENTITE_CURRENT_ROTATE_Z_DOWN);
01747                         break;
01748 
01749                 case ENTITE_CURRENT_ROTATE_Z_DOWN:
01750                         if(ManagerEntite->GetNumberEntite()>0)
01751                         {
01752                                 ManagerEntite->GetCurrentEntite()->m_AngleZ--;
01753                                 ManagerEntite->GetCurrentEntite()->Rotate();
01754                         }
01755                         break;
01756                 case ENTITE_CURRENT_SET_ROTATE_X:
01757                         break;
01758 
01759                 case ENTITE_CURRENT_SET_ROTATE_Y:
01760                         break;
01761 
01762                 case ENTITE_CURRENT_SET_ROTATE_Z:
01763                         break;
01764                         }
01765                 }
01766         
01767 
01768 
01769                 action.m_executed=true;
01770                 if(action.m_NextAction!=NULL)
01771                 {
01772                         ProcessAction(*action.m_NextAction);
01773                 }
01774                 return true;
01775         }
01776         action.m_executed=false;
01777         if(action.m_NextAction!=NULL)
01778         {
01779                 ProcessAction(*action.m_NextAction);
01780         }
01781         return false;
01782         
01783         
01784 UnGuard
01785 }
01786 
01787 

Generated on Tue Aug 6 20:27:12 2002 for ExNihilo by doxygen1.2.17