src/common__object_stage.cpp

   1 /*
   2  * object_game.cpp
   3  *
   4  *  Created on: 24 avr. 2009
   5  *      Author: pat
   6  */
   7
   8 #include "wx/wxprec.h"
   9 #ifndef WX_PRECOMP
  10     #include "wx/wx.h"
  11 #endif
  12
  13 #include <map>
  14
  15 #include "common__tools.h"
  16 #include "common__object_stage.h"
  17
  18
  19 using namespace std;
  20
  21 /*\internal*********************************************
  22 ********        OBJECT RELATED TO THE STAGE FILES
  23 ******************************************************/
  24
  25 //**********************************************
  26 //**********************************************
  27 //**********************************************
  28 /**
  29  * The object which hold the datas about a stage of a game
  30  */
  31
  32 /*
  33  * STAGE FILE ORGANISATION
  34  * - HEADERS
  35  * - Background layer
  36  * - Front layer
  37  * - Panels
  38  * - Walls/Holes
  39  * - Spawns
  40  */
  41
  42 wxString stageHeaderTags[] = {
  43         wxT("loadingbg"),
  44         wxT("music"),
  45         wxT("allowselect"),
  46         wxT("direction"),
  47         wxT("facing"),
  48         wxT("rock"),
  49         wxT("bgspeed"),
  50         wxT("mirror"),
  51         wxT("bossmusic"),
  52         wxT("settime"),
  53         wxT("setweap"),
  54         wxT("notime"),
  55         wxT("noreset"),
  56         wxT("noslow"),
  57         wxT("type"),
  58         wxT("nohit"),
  59         wxT("gravity"),
  60         wxT("maxfallspeed"),
  61         wxT("maxtossspeed"),
  62         wxT("cameratype"),
  63         wxT("stagenumber"),
  64         wxT("palette"),
  65         wxT("updatescript"),
  66         wxT("updatedscript"),
  67         wxT("keyscript"),
  68         wxT("levelscript"),
  69         wxT("endlevelscript"),
  70         wxT("blocked"),
  71         wxT("endhole")
  72 };
  73
  74
  75 bool ob_stage::IsHeaderTag( const wxString& _name )
  76 {
  77         for( size_t i =0; i< t_size_of(stageHeaderTags); i++ )
  78         {
  79                 if( _name.Upper() == stageHeaderTags[i].Upper() )
  80                         return true;
  81         }
  82         return false;
  83 }
  84
  85
  86 //**********************************************
  87
  88 int stage_at_types[] =  {
  89         OB_TYPE_STAGE_AT,
  90         };
  91
  92 bool ob_stage::Is_Stage_At_Type( ob_object* _obj )
  93 {
  94         if(  ob_stage::Is_Stage_Spawn_Type( _obj ) )
  95                 return true;
  96
  97         for( size_t i =0; i< t_size_of(stage_at_types); i++ )
  98         {
  99                 if( _obj->type == stage_at_types[i] )
 100                         return true;
 101         }
 102         return false;
 103 }
 104
 105
 106 int stage_spawn_types[] =  {
 107         OB_TYPE_SPAWN,
 108         OB_TYPE_SPAWN_HEALTHY,
 109         OB_TYPE_SPAWN_ITEM,
 110         };
 111
 112 bool ob_stage::Is_Stage_Spawn_Type( ob_object* _obj )
 113 {
 114         for( size_t i =0; i< t_size_of(stage_spawn_types); i++ )
 115         {
 116                 if( _obj->type == stage_spawn_types[i] )
 117                         return true;
 118         }
 119         return false;
 120 }
 121
 122
 123
 124 //**********************************************
 125
 126 ob_stage::ob_stage()
 127 :ob_object_container()
 128 {
 129         type = OB_TYPE_STAGE;
 130         direction = STAGE_RIGHT;
 131 }
 132
 133 //-----------------------------------------------------------------
 134 void
 135 ob_stage::pClone(ob_object*& res )
 136 {
 137         if( res == NULL )
 138                 res = new ob_stage();
 139         ob_object_container::pClone( res );
 140         ((ob_stage*)res)->direction = direction;
 141 }
 142
 143 //**********************************************
 144
 145 ob_stage::~ob_stage()
 146 {
 147 }
 148
 149 //---------------------------------------------------------------------
 150 bool
 151 ob_stage::Add_SubObj( ob_object* temp )
 152 {
 153         if( ob_object_container::Add_SubObj( temp ) == true )
 154         {
 155                 if( temp->name.Upper() == wxT("DIRECTION") )
 156                         Direction_ComputeAndCache();
 157                 return true;
 158         }
 159         return false;
 160 }
 161
 162
 163 //---------------------------------------------------------------------
 164 int
 165 ob_stage::Direction_ComputeAndCache()
 166 {
 167         wxString str_dir =  GetSubObject_Token( wxT("direction"), 0 ).Upper();
 168
 169         if(        str_dir == wxString()    || str_dir == wxT("RIGHT")
 170                 ||str_dir == wxT("BOTH") || str_dir == wxT("RIGHTLEFT")
 171                 )
 172                 direction = STAGE_RIGHT;
 173
 174         else if( str_dir == wxT("LEFT") || str_dir == wxT("LEFTRIGHT") )
 175                 direction = STAGE_LEFT;
 176
 177         else if( str_dir == wxT("UP") )
 178                 direction = STAGE_UP;
 179
 180         else if( str_dir == wxT("DOWN") )
 181                 direction = STAGE_DOWN;
 182
 183         else if( str_dir == wxT("IN")  || str_dir == wxT("INOUT") )
 184                 direction = STAGE_IN;
 185
 186         else if( str_dir == wxT("OUT") || str_dir == wxT("OUTIN") )
 187                 direction = STAGE_OUT;
 188         else
 189                 direction = STAGE_RIGHT;
 190         return direction;
 191 }
 192
 193
 194 //---------------------------------------------------------------------
 195 wxSize
 196 ob_stage::GetDefScrollzBounds( ob_object* st_declar )
 197 {
 198         if( st_declar == NULL )
 199                 return wxSize(0,0);
 200
 201         if( direction == STAGE_IN || direction == STAGE_OUT )
 202                 return wxSize(0,0);
 203
 204         return ((ob_StageDeclaration*)st_declar)->GetDefScrollzBounds();
 205 }
 206
 207 //**********************************************
 208 ob_stage_panel**
 209 ob_stage::Get_Panels( size_t& nb_panels )
 210 {
 211         nb_panels = 0;
 212
 213         // Get the panels order
 214         wxString curr_order = Get_Panels_Order();
 215
 216         if( curr_order.Len() == 0 )
 217                 return NULL;
 218
 219         // Get the panels refs
 220         size_t nb_unik_panels = 0;
 221         ob_stage_panel** oPanels = (ob_stage_panel**)
 222                         GetSubObjectS_ofType( OB_TYPE_STAGE_PANEL, nb_unik_panels );
 223         if( nb_unik_panels == 0 )
 224                 return NULL;
 225
 226         int tay_panels_map = curr_order.Len();
 227         ob_stage_panel** res = new ob_stage_panel*[tay_panels_map];
 228
 229
 230         for( int i = 0; i < tay_panels_map; i++ )
 231         {
 232                 if( curr_order[i] < 'a' || curr_order[i] >= 'a' + tay_panels_map )
 233                         continue;
 234                 res[nb_panels] = oPanels[curr_order[i] - 'a'];
 235                 nb_panels++;
 236         }
 237
 238         delete[] oPanels;
 239         return res;
 240 }
 241
 242 //**********************************************
 243 ob_object*
 244 ob_stage::Get_LastHeaderObj()
 245 {
 246         ob_object * t = first_subobj;
 247
 248         // Get the first one
 249         bool b_found = false;
 250         while( ! b_found )
 251         {
 252                 if( IsHeaderTag(t->name ) )
 253                         b_found = true;
 254                 t = t->next;
 255         }
 256
 257         // Get the last one
 258         while( t != NULL )
 259         {
 260                 if( ! IsHeaderTag(t->name ) && ! t->Is_EmptyOrComment() )
 261                         return t->prev;
 262                 t = t->next;
 263         }
 264         return NULL;
 265 }
 266
 267
 268 //**********************************************
 269
 270 ob_object* ob_stage::Get_First_AT_Obj()
 271 {
 272         ob_object * t = first_subobj;
 273         while( t != NULL )
 274         {
 275                 if( ! ob_stage::Is_Stage_At_Type( t ) )
 276                         break;
 277                 t = t->next;
 278         }
 279         return t;
 280 }
 281
 282 //---------------------------------------------------------------------
 283 list<ob_stage_object*>*
 284 ob_stage::Get_SubObj_With_StageType( const int stage_type )
 285 {
 286         list<ob_stage_object*>* res = new list<ob_stage_object*>;
 287
 288         size_t tot_subobj_count;
 289         ob_object** arr_subobj = GetAllSubObjS( tot_subobj_count );
 290         if( arr_subobj == NULL )
 291                 return res;
 292
 293         for( size_t i = 0; i < tot_subobj_count; i++ )
 294         {
 295                 if( arr_subobj[i]->Is_Ob_Stage_Object() == true )
 296                 {
 297                         ob_stage_object* t = (ob_stage_object*) arr_subobj[i];
 298                         if( t->object_type == stage_type )
 299                                 res->push_back( t );
 300                 }
 301         }
 302         return res;
 303 }
 304
 305 //---------------------------------------------------------------------
 306 wxString
 307 ob_stage::Get_Panels_Order()
 308 {
 309         wxString res = wxString();
 310         size_t nb_orders;
 311         ob_object** orders = GetSubObjectS( wxT("order"),nb_orders );
 312         if( orders == NULL )
 313                 return res;
 314         else
 315                 for( size_t i = 0; i < nb_orders; i++ )
 316                         res += orders[i]->GetToken( 0 );
 317
 318         delete[] orders;
 319         return res;
 320 }
 321
 322
 323 //**********************************************
 324
 325 bool ob_stage::Add_SubObj_Header( ob_object* _obj, bool b_after )
 326 {
 327         ob_object* t = Get_LastHeaderObj();
 328         // No non header tag in the object
 329         if( t == NULL )
 330                 return Prepend_SubObj( _obj );
 331         else
 332         {
 333                 if( b_after )
 334                         return t->InsertObject_After( _obj );
 335                 else
 336                         return t->InsertObject_Before( _obj );
 337         }
 338 }
 339
 340
 341 //**********************************************
 342 //
 343 // BGS
 344 //
 345
 346 bool ob_stage::Add_SubObj_BGs( ob_object* _obj, bool b_after )
 347 {
 348         size_t nb;
 349         ob_object** l_obj = GetSubObjectS_ofType( OB_TYPE_BG_LAYER, nb );
 350
 351         if( nb == 0 )
 352                 return Add_SubObj_Header( _obj, true );
 353         else
 354         {
 355                 ob_object* t;
 356                 if( b_after )
 357                 {
 358                         t = l_obj[nb-1];
 359                         delete[] l_obj;
 360                         return t->InsertObject_After( _obj );
 361                 }
 362                 else
 363                 {
 364                         t = l_obj[0];
 365                         delete[] l_obj;
 366                         return t->InsertObject_Before( _obj );
 367                 }
 368         }
 369
 370 }
 371
 372
 373 //**********************************************
 374
 375 bool ob_stage::Add_SubObj_FrontLayer( ob_object* _obj, bool b_after )
 376 {
 377         size_t nb;
 378         ob_object** l_obj = GetSubObjectS_ofType( OB_TYPE_FRONT_PANEL, nb );
 379
 380         if( nb == 0 )
 381         {
 382                 return Add_SubObj_BGs( _obj, true );
 383         }
 384         else
 385         {
 386                 ob_object* t;
 387                 if( b_after )
 388                 {
 389                         t = l_obj[nb-1];
 390                         delete[] l_obj;
 391                         return t->InsertObject_After( _obj );
 392                 }
 393                 else
 394                 {
 395                         t = l_obj[0];
 396                         delete[] l_obj;
 397                         return t->InsertObject_Before( _obj );
 398                 }
 399         }
 400 }
 401
 402
 403 //**********************************************
 404
 405 bool ob_stage::Add_SubObj_Panel( ob_object* _obj, bool b_after )
 406 {
 407         size_t nb;
 408         ob_object** l_obj = GetSubObjectS_ofType( OB_TYPE_STAGE_PANEL, nb );
 409
 410         if( nb == 0 )
 411         {
 412                 return Add_SubObj_FrontLayer( _obj, true );
 413         }
 414         else
 415         {
 416                 ob_object* t;
 417                 if( b_after )
 418                 {
 419                         t = l_obj[nb-1];
 420                         delete[] l_obj;
 421                         if( t->next->name.Upper() == wxT("ORDER") && _obj->type != OB_TYPE_STAGE_PANEL )
 422                                 t = t->next;
 423
 424                         return t->InsertObject_After( _obj );
 425                 }
 426                 else
 427                 {
 428                         t = l_obj[0];
 429                         delete[] l_obj;
 430                         if( t->prev->name.Upper() == wxT("ORDER") && _obj->type != OB_TYPE_STAGE_PANEL )
 431                                 t = t->prev;
 432                         return t->InsertObject_Before( _obj );
 433                 }
 434         }
 435 }
 436
 437
 438 //**********************************************
 439
 440 bool ob_stage::Add_SubObj_WallHole( ob_object* _obj, bool b_after )
 441 {
 442         size_t nb;
 443         ob_object** l_obj;
 444         ob_object* t;
 445
 446         if( b_after )
 447         {
 448                 l_obj = GetSubObjectS_ofType( OB_TYPE_WALL, nb );
 449                 if( nb > 0 )
 450                 {
 451                         t = l_obj[nb-1];
 452                         delete[] l_obj;
 453                         return t->InsertObject_After( _obj );
 454                 }
 455         }
 456
 457         l_obj = GetSubObjectS_ofType( OB_TYPE_HOLE, nb );
 458         if( nb > 0 )
 459         {
 460                 if( b_after )
 461                 {
 462                         t = l_obj[nb-1];
 463                         delete[] l_obj;
 464                         return t->InsertObject_After( _obj );
 465                 }
 466                 else
 467                 {
 468                         t = l_obj[0];
 469                         delete[] l_obj;
 470                         return t->InsertObject_Before( _obj );
 471                 }
 472         }
 473
 474         else
 475         {
 476                 return Add_SubObj_Panel( _obj, true );
 477         }
 478 }
 479
 480
 481 //**********************************************
 482 bool
 483 ob_stage::Add_SubObj_AT( ob_object* _obj, bool b_after )
 484 {
 485         if( b_after )
 486                 return Add_SubObj( _obj );
 487
 488         ob_object* t = Get_First_AT_Obj();
 489         if( t == NULL )
 490                 return Add_SubObj_WallHole( _obj, true );
 491         else
 492                 return t->InsertObject_Before( _obj );
 493 }
 494
 495 //----------------------------------------------------------------
 496 bool
 497 ob_stage::Insert_SubObj_AT( ob_object* _obj )
 498 {
 499         ob_object* t = Get_First_AT_Obj();
 500         if( t == NULL )
 501                 return Add_SubObj_WallHole( _obj, true );
 502         if( t->InsertObject_Before( _obj ) == false )
 503                 return false;
 504
 505         ((ob_stage_at*)_obj)->Reorder_At();
 506         return true;
 507 }
 508
 509
 510 //**********************************************
 511 bool
 512 ob_stage::Add_SubObj( ob_object* _obj, bool b_sort_at )
 513 {
 514         // Add a header tag
 515         if( IsHeaderTag(_obj->name ) )
 516                 return Add_SubObj_Header( _obj );
 517
 518
 519         // Add a background layer
 520         else if( _obj->name.Upper() == wxT("BACKGROUND") || _obj->name.Upper() == wxT("BGLAYER")
 521                                 || _obj->type  == OB_TYPE_BG_LAYER
 522                                 )
 523         {
 524                 return Add_SubObj_BGs( _obj );
 525         }
 526
 527         // Add a front panel object
 528         else if(   _obj->name.Upper() == wxT("FRONTPANEL") || _obj->type  == OB_TYPE_FRONT_PANEL )
 529         {
 530                 return Add_SubObj_FrontLayer( _obj );
 531         }
 532
 533         // Add a panel object
 534         else if(   _obj->name.Upper() == wxT("PANEL") || _obj->type  == OB_TYPE_STAGE_PANEL
 535                 || _obj->name.Upper() == wxT("ORDER") )
 536         {
 537                 return Add_SubObj_Panel( _obj );
 538         }
 539
 540         // Add a Wall/Hole object
 541         else if(   _obj->name.Upper() == wxT("WALL") || _obj->type  == OB_TYPE_WALL
 542                 || _obj->name.Upper() == wxT("HOLE") || _obj->type  == OB_TYPE_HOLE )
 543         {
 544                 return Add_SubObj_WallHole( _obj );
 545         }
 546
 547         else if( ob_stage::Is_Stage_At_Type( _obj ))
 548         {
 549                 if( b_sort_at == false )
 550                         return Add_SubObj_AT( _obj );
 551                 else
 552                         return Insert_SubObj_AT( _obj );
 553         }
 554
 555         else
 556         {
 557                 ObjectsLog( MYLOG_WARNING, -1,
 558                             wxT("ob_stage::Add_SubObj : Unknown object type : ") + _obj->name );
 559                 return Add_SubObj_Header( _obj );
 560         }
 561 }
 562
 563
 564
 565
 566 //**********************************************
 567
 568 ob_object* ob_stage::Guess_and_ConstructNewObject(MyLine* line, const int _num_line )
 569 {
 570         // if Empty Line
 571         if( line == NULL || line->GetTokensCount() <= 0 )
 572                 return new ob_object(line, _num_line);
 573
 574         wxString _name = *(line->GetToken(0)->data);
 575         wxString _token;
 576         if( line->GetToken(1) != NULL && line->GetToken(1)->data != NULL )
 577                 _token = *( line->GetToken(1)->data );
 578
 579         ob_object *temp;
 580
 581
 582         if( _name.Upper() == wxT("BACKGROUND") || _name.Upper() == wxT("BGLAYER") )
 583                 temp = new ob_BG_Layer(line,_num_line);
 584
 585         else if( _name.Upper() == wxT("FRONTPANEL") )
 586                 temp = new ob_front_panel(line,_num_line);
 587
 588         else if( _name.Upper() == wxT("PANEL") )
 589                 temp = new ob_stage_panel(line,_num_line);
 590
 591         else if( _name.Upper() == wxT("HOLE") )
 592                 temp = new ob_hole(line,_num_line);
 593
 594         else if( _name.Upper() == wxT("WALL") )
 595                 temp = new ob_wall(line,_num_line);
 596
 597         else if( ob_player_spawn::Get_StageObjectType(_name) != STAGETYPE_NONE )
 598                 temp = new ob_player_spawn(line,_num_line);
 599
 600         else if( ob_stage_at::Get_StageObjectType( _name ) != STAGETYPE_NONE )
 601                 temp = new ob_stage_at(line,_num_line);
 602
 603         else if( ob_spawn::Get_StageObjectType( _name, _token ) != STAGETYPE_NONE )
 604                 temp = new ob_spawn(line,_num_line);
 605
 606         else if(ob_spawn_healthy::Get_StageObjectType(_name, _token) != STAGETYPE_NONE )
 607                 temp = new ob_spawn_healthy(line,_num_line);
 608
 609         else if( ob_spawn_item::Get_StageObjectType( _name, _token ) != STAGETYPE_NONE )
 610                 temp = new ob_spawn_item(line,_num_line);
 611
 612         else
 613                 temp = new ob_stage_object( line, _num_line);
 614
 615 //      wxLogInfo( "At line " + IntToStr( _num_line +1) + ", object build :" + temp->name );
 616         return temp;
 617 }
 618
 619 //**********************************************
 620 ob_object*
 621 ob_stage::Guess_and_ConstructNewObject(const wxString& __name, const wxString& token0 )
 622 {
 623         ob_object *temp;
 624         wxString _name = __name;
 625         wxArrayString _tokens;
 626         _tokens.Add( token0 );
 627
 628         if( _name.Upper() == wxT("BACKGROUND") || _name.Upper() == wxT("BGLAYER") )
 629                 temp = new ob_BG_Layer(_name,_tokens);
 630
 631         else if( _name.Upper() == wxT("FRONTPANEL") )
 632                 temp = new ob_front_panel(_name,_tokens);
 633
 634         else if( _name.Upper() == wxT("PANEL") )
 635                 temp = new ob_stage_panel(_name,_tokens);
 636
 637         else if( _name.Upper() == wxT("HOLE"))
 638                 temp = new ob_hole(_name,_tokens);
 639
 640         else if( _name.Upper() == wxT("WALL") )
 641                 temp = new ob_wall(_name,_tokens);
 642
 643         else if( ob_player_spawn::Get_StageObjectType(_name) != STAGETYPE_NONE )
 644                 temp = new ob_player_spawn(_name,_tokens);
 645
 646         else if( ob_stage_at::Get_StageObjectType( _name ) != STAGETYPE_NONE )
 647                 temp = new ob_stage_at(_name,_tokens);
 648
 649         else if( ob_spawn::Get_StageObjectType( _name, token0 ) != STAGETYPE_NONE )
 650                 temp = new ob_spawn(_name,_tokens);
 651
 652         else if(ob_spawn_healthy::Get_StageObjectType(_name, token0) != STAGETYPE_NONE )
 653                 temp = new ob_spawn_healthy(_name,_tokens);
 654
 655         else if( ob_spawn_item::Get_StageObjectType( _name, token0 ) != STAGETYPE_NONE )
 656                 temp = new ob_spawn_item(_name,_tokens);
 657
 658         else
 659                 temp = new ob_stage_object(_name,_tokens);
 660
 661 //      wxLogInfo( "At line " + IntToStr( _num_line +1) + ", object build :" + temp->name );
 662         return temp;
 663 }
 664
 665 //**********************************************
 666 //**********************************************
 667 //**********************************************
 668 /**
 669  * An object holded by a stage object
 670  */
 671
 672 //**********************************************
 673
 674 ob_BG_Layer::ob_BG_Layer( MyLine* line, const int num_line )
 675 :ob_object( line, num_line ), Image_Holder()
 676 {
 677         type = OB_TYPE_BG_LAYER;
 678 }
 679
 680
 681 //**********************************************
 682
 683 ob_BG_Layer::ob_BG_Layer( const wxString& _name, wxArrayString& _tokens)
 684 :ob_object( _name, _tokens ), Image_Holder()
 685 {
 686         type = OB_TYPE_BG_LAYER;
 687 }
 688
 689
 690 //-----------------------------------------------------------------
 691 void
 692 ob_BG_Layer::pClone(ob_object*& res )
 693 {
 694         if( res == NULL )
 695                 res = new ob_BG_Layer();
 696         ob_object::pClone( res );
 697 }
 698
 699 //**********************************************
 700
 701 ob_BG_Layer::~ob_BG_Layer()
 702 {
 703 }
 704
 705
 706 //**********************************************
 707
 708 void ob_BG_Layer::Validate()
 709 {
 710 }
 711
 712
 713 //**********************************************
 714
 715 wxString ob_BG_Layer::GetName()
 716 {
 717         wxString path = GetToken( 0 );
 718         if( path == wxString() )
 719                 return wxT("NOFILE");
 720
 721         wxFileName fn = GetObFile( path );
 722         return fn.GetFullName();
 723
 724 }
 725
 726
 727 //**********************************************
 728
 729 wxFileName ob_BG_Layer::GetFileName()
 730 {
 731         return GetObFile( GetToken( 0 ));
 732 }
 733
 734
 735 //**********************************************
 736 void
 737 ob_BG_Layer::SetToDefault()
 738 {
 739         name = wxT("bglayer");
 740         SetAllTokenFromStr( wxT("data 0.5 0.5 0 0 0 0 5000 5000 0 0") );
 741 }
 742
 743 //**********************************************
 744 void
 745 ob_BG_Layer::FillMissings()
 746 {
 747         size_t i = 0;
 748         if( nb_tokens < i+1 )
 749                 SetToken( i, wxT("data") );
 750         i++;
 751
 752         if( nb_tokens < i+1 )
 753                 SetToken( i, wxT("0.5") );
 754         i++;
 755
 756         if( nb_tokens < i+1 )
 757                 SetToken( i, wxT("0.5") );
 758         i++;
 759
 760         if( nb_tokens < i+1 )
 761                 SetToken( i, wxT("0") );
 762         i++;
 763
 764         if( nb_tokens < i+1 )
 765                 SetToken( i, wxT("0") );
 766         i++;
 767
 768         if( nb_tokens < i+1 )
 769                 SetToken( i, wxT("0") );
 770         i++;
 771
 772         if( nb_tokens < i+1 )
 773                 SetToken( i, wxT("0") );
 774         i++;
 775
 776         if( nb_tokens < i+1 )
 777                 SetToken( i, wxT("5000") );
 778         i++;
 779
 780         if( nb_tokens < i+1 )
 781                 SetToken( i, wxT("5000") );
 782         i++;
 783
 784         if( nb_tokens < i+1 )
 785                 SetToken( i, wxT("0") );
 786         i++;
 787
 788         if( nb_tokens < i+1 )
 789                 SetToken( i, wxT("0") );
 790         i++;
 791 }
 792
 793 //------------------------------------------------------------
 794 int
 795 ob_BG_Layer::Get_RepeatingVal( int direction )
 796 {
 797         wxString res;
 798         switch( direction )
 799         {
 800                 case STAGE_RIGHT:
 801                 case STAGE_LEFT:
 802                         res = GetToken( 7 );
 803                         break;
 804                 case STAGE_UP:
 805                 case STAGE_DOWN:
 806                 case STAGE_IN:
 807                 case STAGE_OUT:
 808                         res = GetToken( 8 );
 809                         break;
 810         }
 811         if( res == wxString() )
 812                 res = wxT("5000");
 813         return StrToInt( res );
 814 }
 815
 816 //**********************************************
 817 bool
 818 ob_BG_Layer::Update_With( ob_BG_Layer* oLay )
 819 {
 820         if( oLay == NULL )
 821                 return false;
 822
 823         bool b_res = false;
 824         ob_BG_Layer* t0 = (ob_BG_Layer*) this->Clone();
 825         ob_BG_Layer* t1 = (ob_BG_Layer*) oLay->Clone();
 826
 827         t0->FillMissings();
 828         t1->FillMissings();
 829
 830         if( t0->arr_token_size != t1->arr_token_size )
 831                 b_res = true;
 832         else
 833         {
 834                 for( size_t i = 0; i < t0->arr_token_size; i++ )
 835                         if( t0->GetToken( i ) != t1->GetToken( i ) )
 836                         {
 837                                 b_res = true;
 838                                 break;
 839                         }
 840         }
 841
 842         delete t0;
 843         delete t1;
 844
 845         if( b_res == true )
 846                 SetData( oLay );
 847
 848         return b_res;
 849 }
 850
 851
 852 //**********************************************
 853 //**********************************************
 854 //**********************************************
 855 /**
 856  * The object which hold the datas about a stage of a game
 857  */
 858
 859 //**********************************************
 860
 861 ob_front_panel::ob_front_panel( MyLine* line, const int num_line )
 862 :ob_object( line, num_line ), Image_Holder()
 863 {
 864         type = OB_TYPE_FRONT_PANEL;
 865 }
 866
 867
 868 //**********************************************
 869
 870 ob_front_panel::ob_front_panel( const wxString& _name, wxArrayString& _tokens)
 871 :ob_object( _name, _tokens ), Image_Holder()
 872 {
 873         type = OB_TYPE_FRONT_PANEL;
 874 }
 875
 876
 877 //-----------------------------------------------------------------
 878 void
 879 ob_front_panel::pClone(ob_object*& res )
 880 {
 881         if( res == NULL )
 882                 res = new ob_front_panel();
 883         ob_object::pClone( res );
 884 }
 885
 886 //**********************************************
 887
 888 ob_front_panel::~ob_front_panel()
 889 {
 890 }
 891
 892
 893 //**********************************************
 894
 895 void ob_front_panel::Validate()
 896 {
 897 }
 898
 899
 900 //**********************************************
 901
 902 wxFileName ob_front_panel::GetFileName()
 903 {
 904         return GetObFile( GetToken( 0 ));
 905 }
 906
 907 //**********************************************
 908 wxString
 909 ob_front_panel::GetName()
 910 {
 911         wxString path = GetToken( 0 );
 912         if( path == wxString() )
 913                 return wxT("NOFILE");
 914
 915         wxFileName fn = GetObFile( path );
 916         return fn.GetFullName();
 917
 918 }
 919
 920 //**********************************************
 921 bool
 922 ob_front_panel::Update_With( ob_front_panel* oPan )
 923 {
 924         if( oPan == NULL )
 925                 return false;
 926
 927         if( oPan->GetToken( 0 ) != this->GetToken( 0 ) )
 928         {
 929                 SetToken( 0, oPan->GetToken( 0 ) );
 930                 return true;
 931         }
 932
 933         return false;
 934 }
 935
 936
 937 //**********************************************
 938 //**********************************************
 939 //**********************************************
 940 /**
 941  * The object which hold the datas about a stage of a game
 942  */
 943
 944 //**********************************************
 945
 946 ob_stage_panel::ob_stage_panel( MyLine* line, const int num_line )
 947 :ob_object( line, num_line ), Image_Holder()
 948 {
 949         type = OB_TYPE_STAGE_PANEL;
 950 }
 951
 952
 953 //**********************************************
 954
 955 ob_stage_panel::ob_stage_panel( const wxString& _name, wxArrayString& _tokens)
 956 :ob_object( _name, _tokens ), Image_Holder()
 957 {
 958         type = OB_TYPE_STAGE_PANEL;
 959 }
 960
 961
 962 //-----------------------------------------------------------------
 963 void
 964 ob_stage_panel::pClone(ob_object*& res )
 965 {
 966         if( res == NULL )
 967                 res = new ob_stage_panel();
 968         ob_object::pClone( res );
 969 }
 970
 971 //**********************************************
 972
 973 ob_stage_panel::~ob_stage_panel()
 974 {
 975 }
 976
 977
 978 //**********************************************
 979
 980 void ob_stage_panel::Validate()
 981 {
 982 }
 983
 984
 985 //**********************************************
 986
 987 wxString ob_stage_panel::GetName()
 988 {
 989         wxString path = GetToken( 0 );
 990         if( path == wxString() )
 991                 return wxT("NOFILE");
 992
 993         wxFileName fn = GetObFile( path );
 994         return fn.GetFullName();
 995 }
 996
 997
 998 //**********************************************
 999
1000 void ob_stage_panel::SetToDefault()
1001 {
1002         name = wxT("panel");
1003         SetToken( 0, wxT("none" ));
1004         SetToken( 1, wxT("none" ));
1005         SetToken( 2, wxT("none" ));
1006 }
1007
1008
1009 //**********************************************
1010
1011 wxFileName ob_stage_panel::GetFileName()
1012 {
1013         wxString ob_path = GetToken( 0 );
1014         if( ob_path == wxString() )
1015                 return wxFileName();
1016
1017         return GetObFile( ob_path );
1018 }
1019
1020
1021 //**********************************************
1022 //**********************************************
1023 //**********************************************
1024 /**
1025  * An object holded by a stage object
1026  */
1027
1028 ob_stage_object::ob_stage_object( MyLine* line, const int num_line )
1029 :ob_object( line, num_line )
1030 {
1031         type = OB_STAGE_OBJECT;
1032         object_type = STAGETYPE_NONE;
1033 }
1034
1035
1036 //**********************************************
1037
1038 ob_stage_object::ob_stage_object(const wxString& _name, wxArrayString& _tokens)
1039 :ob_object( _name, _tokens )
1040 {
1041         type = OB_STAGE_OBJECT;
1042         object_type = STAGETYPE_NONE;
1043 }
1044
1045
1046 //-----------------------------------------------------------------
1047 void
1048 ob_stage_object::pClone(ob_object*& res )
1049 {
1050         if( res == NULL )
1051                 res = new ob_stage_object();
1052         ob_object::pClone( res );
1053         ((ob_stage_object*)res)->object_type = object_type;
1054 }
1055
1056 //**********************************************
1057
1058 ob_stage_object::~ob_stage_object()
1059 {
1060 }
1061
1062
1063 //**********************************************
1064
1065 void ob_stage_object::Validate()
1066 {
1067 }
1068
1069
1070 //**********************************************
1071 wxString
1072 ob_stage_object::ToStr()
1073 {
1074 /*      wxString t = "++++++++++++++++\n";
1075         t += ob_object::ToStr();
1076         t += "--------------\n";
1077         return t;
1078         */
1079         return ob_object::ToStr();
1080 }
1081
1082 //-------------------------------------------------------------
1083 bool
1084 ob_stage_object::Get_Coords(int& x, int& y)
1085 {
1086         x = -1;
1087         y = -1;
1088         return false;
1089 }
1090
1091 //-------------------------------------------------------------
1092 // used for object which use coords for screen name
1093 wxString
1094 ob_stage_object::CoordsToStr()
1095 {
1096         int x,y;
1097         if( Get_Coords(x,y) == false )
1098                 return wxT("NO Coords");
1099         return IntToStr(x) + wxT(" , ") + IntToStr(y);
1100 }
1101
1102
1103 //-------------------------------------------------------------
1104 void
1105 ob_stage_object::Coords_Decal( const wxSize& _decal )
1106 {
1107         return;
1108 }
1109
1110 //-------------------------------------------------------------
1111 void
1112 ob_stage_object::Init_and_Center( wxSize& _here )
1113 {
1114         return;
1115 }
1116
1117
1118 //**********************************************
1119 //**********************************************
1120 //**********************************************
1121 /**
1122  * A Wall
1123  */
1124
1125 //**********************************************
1126
1127 ob_wall::ob_wall( MyLine* line, const int num_line )
1128 :ob_stage_object( line, num_line )
1129 {
1130         type = OB_TYPE_WALL;
1131         object_type = SOBJ_WALL;
1132 }
1133
1134
1135 //**********************************************
1136
1137 ob_wall::ob_wall(const wxString& _name, wxArrayString& _tokens)
1138 :ob_stage_object( _name, _tokens )
1139 {
1140         type = OB_TYPE_WALL;
1141         object_type = SOBJ_WALL;
1142 }
1143
1144
1145 //-----------------------------------------------------------------
1146 void
1147 ob_wall::pClone(ob_object*& res )
1148 {
1149         if( res == NULL )
1150                 res = new ob_wall();
1151         ob_stage_object::pClone( res );
1152 }
1153
1154 //**********************************************
1155
1156 ob_wall::~ob_wall()
1157 {
1158 }
1159
1160
1161 //**********************************************
1162 void
1163 ob_wall::Validate()
1164 {
1165 }
1166
1167
1168 //-------------------------------------------------------------
1169 bool
1170 ob_wall::Get_Coords(int& x, int& y)
1171 {
1172         x = -1;
1173         y = -1;
1174         wxString t;
1175         t = GetToken( 0 );
1176         if( t == wxString() )
1177                 return false;
1178         x = StrToInt( t );
1179
1180         t = GetToken( 1 );
1181         if( t == wxString() )
1182                 return false;
1183         y = StrToInt( t );
1184
1185         return true;
1186 }
1187
1188 //-------------------------------------------------------------
1189 void
1190 ob_wall::Coords_Decal( const wxSize& _decal )
1191 {
1192         int x = StrToInt( GetToken(0));
1193         int z = StrToInt( GetToken(1));
1194         SetToken(0, IntToStr( x + _decal.x ));
1195         SetToken(1, IntToStr( z + _decal.y ));
1196 }
1197
1198 //-------------------------------------------------------------
1199 void
1200 ob_wall::Init_and_Center( wxSize& _here )
1201 {
1202         SetToken(0,wxT("0"));   //X
1203         SetToken(1,wxT("0"));   //Z
1204         SetToken(2,wxT("10"));//ul
1205         SetToken(3,wxT("0"));//ll
1206         SetToken(4,wxT("40"));//ur
1207         SetToken(5,wxT("30"));//lr
1208         SetToken(6,wxT("30"));//depth
1209         SetToken(7,wxT("20"));//alt
1210
1211         SetToken(0,IntToStr(_here.x - 20) );    //X
1212         SetToken(1,IntToStr(_here.y + 25) );    //Z
1213 }
1214
1215
1216
1217 //**********************************************
1218 //**********************************************
1219 //**********************************************
1220 /**
1221  * A Hole
1222  */
1223 //**********************************************
1224
1225 ob_hole::ob_hole( MyLine* line, const int num_line )
1226 :ob_stage_object( line, num_line )
1227 {
1228         type = OB_TYPE_HOLE;
1229         object_type = SOBJ_HOLE;
1230 }
1231
1232
1233 //**********************************************
1234
1235 ob_hole::ob_hole(const wxString& _name, wxArrayString& _tokens)
1236 :ob_stage_object( _name, _tokens )
1237 {
1238         type = OB_TYPE_HOLE;
1239         object_type = SOBJ_HOLE;
1240 }
1241
1242
1243 //-----------------------------------------------------------------
1244 void
1245 ob_hole::pClone(ob_object*& res )
1246 {
1247         if( res == NULL )
1248                 res = new ob_hole();
1249         ob_stage_object::pClone( res );
1250 }
1251
1252 //**********************************************
1253
1254 ob_hole::~ob_hole()
1255 {
1256 }
1257
1258
1259 //-------------------------------------------------------------
1260 void
1261 ob_hole::Validate()
1262 {
1263 }
1264
1265 //-------------------------------------------------------------
1266 bool
1267 ob_hole::Get_Coords(int& x, int& y)
1268 {
1269         x = -1;
1270         y = -1;
1271         wxString t;
1272         t = GetToken( 0 );
1273         if( t == wxString() )
1274                 return false;
1275         x = StrToInt( t );
1276
1277         t = GetToken( 1 );
1278         if( t == wxString() )
1279                 return false;
1280         y = StrToInt( t );
1281
1282         return true;
1283 }
1284
1285 //-------------------------------------------------------------
1286 void
1287 ob_hole::Coords_Decal( const wxSize& _decal )
1288 {
1289         int x = StrToInt( GetToken(0));
1290         int z = StrToInt( GetToken(1));
1291         SetToken(0, IntToStr( x + _decal.x ));
1292         SetToken(1, IntToStr( z + _decal.y ));
1293 }
1294
1295 //-------------------------------------------------------------
1296 void
1297 ob_hole::Init_and_Center( wxSize& _here )
1298 {
1299         SetToken(0,wxT("0"));   //X
1300         SetToken(1,wxT("0"));   //Z
1301         SetToken(2,wxT("10"));//ul
1302         SetToken(3,wxT("0"));//ll
1303         SetToken(4,wxT("40"));//ur
1304         SetToken(5,wxT("30"));//lr
1305         SetToken(6,wxT("30"));//depth
1306
1307         SetToken(0,IntToStr(_here.x - 20) );    //X
1308         SetToken(1,IntToStr(_here.y + 15) );    //Z
1309 }
1310
1311
1312
1313 //**********************************************
1314 //**********************************************
1315 //**********************************************
1316 /**
1317  * The object which hold the datas about a stage of a game
1318  */
1319
1320
1321 int ob_player_spawn::Get_StageObjectType( const wxString& _name )
1322 {
1323         if( _name.Upper() == wxT("SPAWN1") || _name.Upper() == wxT("SPAWN2")
1324                 || _name.Upper() == wxT("SPAWN3") || _name.Upper() == wxT("SPAWN4") )
1325                 return SOBJ_PLAYER_SPAWN;
1326         else
1327                 return STAGETYPE_NONE;
1328 }
1329
1330 //**********************************************
1331
1332 ob_player_spawn::ob_player_spawn( MyLine* line, const int num_line )
1333 :ob_stage_object( line, num_line )
1334 {
1335         type = OB_TYPE_PLAYER_SPAWN;
1336         if( line != NULL )
1337                 object_type =  Get_StageObjectType( *(line->GetToken(0)->data) );
1338 }
1339
1340
1341 //**********************************************
1342
1343 ob_player_spawn::ob_player_spawn(const wxString& _name, wxArrayString& _tokens)
1344 :ob_stage_object( _name, _tokens )
1345 {
1346         type = OB_TYPE_PLAYER_SPAWN;
1347         object_type =  Get_StageObjectType( _name );
1348 }
1349
1350
1351 //-----------------------------------------------------------------
1352 void
1353 ob_player_spawn::pClone(ob_object*& res )
1354 {
1355         if( res == NULL )
1356                 res = new ob_player_spawn();
1357         ob_stage_object::pClone( res );
1358 }
1359
1360 //**********************************************
1361
1362 ob_player_spawn::~ob_player_spawn()
1363 {
1364 }
1365
1366
1367 //-------------------------------------------------------------
1368 void
1369 ob_player_spawn::Validate()
1370 {
1371 }
1372
1373 //-------------------------------------------------------------
1374 bool
1375 ob_player_spawn::Get_Coords(int& x, int& y)
1376 {
1377         x = -1;
1378         y = -1;
1379         wxString t;
1380         t = GetToken( 0 );
1381         if( t == wxString() )
1382                 return false;
1383         x = StrToInt( t );
1384
1385         t = GetToken( 1 );
1386         if( t == wxString() )
1387                 return false;
1388         y = StrToInt( t );
1389
1390         return true;
1391 }
1392
1393 //-------------------------------------------------------------
1394 void
1395 ob_player_spawn::Coords_Decal( const wxSize& _decal )
1396 {
1397         SetToken( 0, IntToStr( StrToInt(GetToken(0)) + _decal.x ));
1398         SetToken( 1, IntToStr( StrToInt(GetToken(1)) + _decal.x ));
1399 }
1400
1401 //-------------------------------------------------------------
1402 void
1403 ob_player_spawn::Init_and_Center( wxSize& _here )
1404 {
1405         SetToken( 0, IntToStr( _here.x ));
1406         SetToken( 1, IntToStr( _here.y ));
1407 }
1408
1409
1410
1411 //**********************************************
1412 //**********************************************
1413 //**********************************************
1414 /**
1415  * The object which hold the datas about a stage of a game
1416  */
1417
1418
1419 int ob_stage_at::Get_StageObjectType( const wxString& _name )
1420 {
1421         if( _name.Upper() == wxT("SCROLLZ") || _name.Upper() == wxT("SCROLLX") )
1422                 return SOBJ_SCROLLZ;
1423
1424         else if( _name.Upper() == wxT("GROUP") )
1425                 return SOBJ_GROUP;
1426
1427         else if( _name.Upper() == wxT("LIGHT") )
1428                 return SOBJ_LIGHT;
1429
1430         else if( _name.Upper() == wxT("SHADOWCOLOR") )
1431                 return SOBJ_SHADOWCOLOR;
1432
1433         else if( _name.Upper() == wxT("SHADOWALPHA") )
1434                 return SOBJ_SHADOWALPHA;
1435
1436         else if( _name.Upper() == wxT("SETPALETTE") )
1437                 return SOBJ_SETPALETTE;
1438
1439         else if( _name.Upper() == wxT("BLOCKADE") )
1440                 return SOBJ_BLOCKADE;
1441
1442         else if( _name.Upper() == wxT("WAIT") )
1443                 return SOBJ_WAIT;
1444
1445         else if( _name.Upper() == wxT("NOJOIN") )
1446                 return SOBJ_NOJOIN;
1447
1448         else if( _name.Upper() == wxT("CANJOIN") )
1449                 return SOBJ_CANJOIN;
1450
1451         else
1452                 return STAGETYPE_NONE;
1453 }
1454
1455 //**********************************************
1456
1457 ob_stage_at::ob_stage_at( MyLine* line, const int num_line )
1458 :ob_stage_object( line, num_line )
1459 {
1460         type = OB_TYPE_STAGE_AT;
1461         if( line != NULL )
1462                 object_type =  Get_StageObjectType( *(line->GetToken(0)->data) );
1463         ungry = true;
1464 }
1465
1466
1467 //**********************************************
1468
1469 ob_stage_at::ob_stage_at(const wxString& _name, wxArrayString& _tokens)
1470 :ob_stage_object( _name, _tokens )
1471 {
1472         type = OB_TYPE_STAGE_AT;
1473         object_type =  Get_StageObjectType(  _name );
1474 }
1475
1476
1477 //-----------------------------------------------------------------
1478 void
1479 ob_stage_at::pClone(ob_object*& res )
1480 {
1481         if( res == NULL )
1482                 res = new ob_stage_at();
1483         ob_stage_object::pClone( res );
1484 }
1485
1486 //**********************************************
1487
1488 ob_stage_at::~ob_stage_at()
1489 {
1490 }
1491
1492
1493 //**********************************************
1494
1495 bool ob_stage_at::Eat(  MyLine* line, const int _num_line )
1496 {
1497         if( ! ungry )
1498                 return false;
1499
1500         if( line->IsComment() || line->IsEmpty()  )
1501         {
1502                 Add_SubObj( new ob_object( line, _num_line ) );
1503                 return true;
1504         }
1505
1506
1507         wxString _name = *(line->GetToken(0)->data);
1508
1509         // MUST BE followed by a  <AT> Tag, or there is a problem
1510         if( _name.Upper() != wxT("AT") )
1511         {
1512                 ObjectsLog( MYLOG_ERROR, _num_line + 1,
1513                             wxT("The upper object <") + name + wxT("> require a tag <AT> which is not present !") );
1514                 ungry = false;
1515                 return false;
1516         }
1517
1518         // Good, a <AT> tag close the thing !
1519         Add_SubObj( new ob_object( line, _num_line ) );
1520         ungry = false;
1521         return true;
1522 }
1523
1524
1525 //**********************************************
1526 void
1527 ob_stage_at::Validate()
1528 {
1529 }
1530
1531 //---------------------------------------------------------
1532 bool
1533 ob_stage_at::Get_Coords(int& x, int& y)
1534 {
1535         x = -1;
1536         y = -1;
1537         ob_object* o = GetSubObject( wxT("AT") );
1538         if( o == NULL )
1539                 return false;
1540
1541         wxString _tok = o->GetToken( 0 );
1542         if( _tok == wxString() )
1543                 return false;
1544
1545         x = StrToInt( _tok );
1546         y = 0;
1547         return true;
1548 }
1549
1550 //-------------------------------------------------------------
1551 int
1552 ob_stage_at::GetAt()
1553 {
1554         ob_object* subobj = GetSubObject( wxT("at") );
1555         if( subobj == NULL )
1556                 return 0;
1557         return StrToInt( subobj->GetToken(0 ));
1558 }
1559
1560 //-------------------------------------------------------------
1561 void
1562 ob_stage_at::SetAt(int _here)
1563 {
1564         ob_object* subobj = GetSubObject( wxT("at") );
1565         if( subobj == NULL )
1566         {
1567                 subobj = new ob_object(wxT("at"));
1568                 Add_SubObj( subobj );
1569         }
1570         subobj->SetToken( 0, IntToStr(_here));
1571 }
1572
1573 //-------------------------------------------------------------
1574 void
1575 ob_stage_at::Coords_Decal( const wxSize& _decal )
1576 {
1577         SetAt( GetAt() + _decal.x );
1578 }
1579
1580 //-------------------------------------------------------------
1581 void
1582 ob_stage_at::Init_and_Center( wxSize& _here )
1583 {
1584         SetAt( _here.x );
1585 }
1586
1587 //-------------------------------------------------------------
1588 void
1589 ob_stage_at::Reorder_At()
1590 {
1591         int at_val = GetAt();
1592
1593         // Must move the AT object at his new right place
1594         ob_object* sibling = this->next;
1595         ob_object* last_obj;
1596         int found_res = 0;
1597
1598         while( sibling != NULL )
1599         {
1600                 if( ob_stage::Is_Stage_At_Type( sibling ) == false )
1601                 {
1602                         sibling = sibling->next;
1603                         continue;
1604                 }
1605
1606                 ob_object* subobj = sibling->GetSubObject( wxT("AT") );
1607                 if( subobj != NULL )
1608                 {
1609                         if( StrToInt( subobj->GetToken(0)) > at_val )
1610                                 break;
1611                         found_res = 1;
1612                         last_obj = sibling;
1613                 }
1614                 sibling = sibling->next;
1615         }
1616
1617         // If no better place upper  ==>> try lower
1618         if( sibling == this->next || (sibling == NULL && found_res == 0) )
1619         {
1620                 sibling = this->prev;
1621                 while( sibling != NULL )
1622                 {
1623                         if( ob_stage::Is_Stage_At_Type( sibling ) == false )
1624                         {
1625                                 sibling = sibling->prev;
1626                                 continue;
1627                         }
1628
1629                         ob_object* subobj = sibling->GetSubObject( wxT("AT") );
1630                         if( subobj != NULL )
1631                         {
1632                                 if( StrToInt( subobj->GetToken(0)) < at_val )
1633                                         break;
1634                                 found_res = 2;
1635                                 last_obj = sibling;
1636                         }
1637
1638                         sibling = sibling->prev;
1639                 }
1640
1641                 // no better Lower place neither
1642                 if( sibling == this->prev || (sibling == NULL && found_res == 0) )
1643                 {
1644                         sibling = NULL;
1645                 }
1646         }
1647
1648         // Must replace the object next to the sibling found
1649         if( found_res > 0 )
1650         {
1651                 // Front or back case
1652                 if( sibling == NULL )
1653                 {
1654                         // front case  ==>> must be an insert before
1655                         if( found_res == 2 )
1656                                 found_res = 1;
1657                         // back case  ==>> must be an insert after
1658                         else
1659                                 found_res = 2;
1660                         sibling = last_obj;
1661                 }
1662
1663                 // Must place it before
1664                 if( found_res == 1 )
1665                         sibling->InsertObject_Before( this );
1666                 else
1667                         sibling->InsertObject_After( this );
1668         }
1669 }
1670
1671 //-------------------------------------------------------------
1672 bool
1673 ob_stage_at::Add_SubObj( ob_object* temp )
1674 {
1675         if( temp == NULL )
1676                 return false;
1677         if( temp->name.Upper() == wxT("AT") )
1678                 return ob_stage_object::Add_SubObj( temp );
1679
1680         if( last_subobj == NULL )
1681                 return ob_stage_object::Add_SubObj( temp );
1682
1683         if( last_subobj->name.Upper() == wxT("AT") )
1684                 return last_subobj->InsertObject_Before( temp );
1685
1686         return ob_stage_object::Add_SubObj( temp );
1687 }
1688
1689
1690 //**********************************************
1691 //**********************************************
1692 //**********************************************
1693 /**
1694  * The object which hold the datas about a game (mod)
1695  */
1696
1697 int ob_spawn::Get_StageObjectType( const wxString& _name, const wxString& entity_name )
1698 {
1699         if( _name.Upper() != wxT("SPAWN") )
1700                 return STAGETYPE_NONE;
1701
1702         obFileEntity* ent = obFileStage::GetEntity( entity_name );
1703         if( ent == NULL )
1704                 return STAGETYPE_NONE;
1705         wxString ent_type = ent->obj_container->GetSubObject_Token( wxT("type") );
1706
1707         if( ent_type.Upper() == wxT("NONE") )
1708                 return SOBJ_NONE;
1709
1710         if( ent_type.Upper() == wxT("STEAMER") )
1711                 return SOBJ_STEAMER;
1712
1713         if( ent_type.Upper() == wxT("PANEL") )
1714                 return SOBJ_PANEL;
1715
1716         if( ent_type.Upper() == wxT("TEXT") )
1717                 return SOBJ_TEXT;
1718
1719         if( ent_type.Upper() == wxT("TRAP") )
1720                 return SOBJ_TRAP;
1721
1722         if( ent_type.Upper() == wxT("PSHOT") || ent_type.Upper() == wxT("SHOT"))
1723                 return SOBJ_SHOT;
1724
1725         else
1726                 return STAGETYPE_NONE;
1727 }
1728
1729 //**********************************************
1730
1731 wxString obSpawnTags[] =
1732         {
1733                 wxT("at"),
1734                 wxT("2pspawn"),
1735                 wxT("3pspawn"),
1736                 wxT("4pspawn"),
1737                 wxT("flip"),
1738                 wxT("alias"),
1739                 wxT("map"),
1740                 wxT("spawnscript"),
1741                 wxT("coords"),
1742          };
1743
1744 bool
1745 ob_spawn::Is_AcceptedTag( const wxString& _name )
1746 {
1747         return IsInArray( _name, (wxString*) &obSpawnTags, t_size_of( obSpawnTags ) );
1748 }
1749
1750 //------------------------------------------------------------------------------
1751 int
1752 ob_spawn::Get_Entity_StageType( const wxString& ent_name )
1753 {
1754         int ent_stype = ob_spawn::Get_StageObjectType( wxT("SPAWN"), ent_name );
1755
1756         if( ent_stype == STAGETYPE_NONE )
1757                 ent_stype = ob_spawn_healthy::Get_StageObjectType( wxT("SPAWN"), ent_name );
1758
1759         if( ent_stype == STAGETYPE_NONE )
1760                 ent_stype = ob_spawn_item::Get_StageObjectType( wxT("SPAWN"), ent_name );
1761
1762         return ent_stype;
1763 }
1764
1765 //**********************************************
1766
1767 ob_spawn::ob_spawn( MyLine* line, const int num_line )
1768 :ob_stage_at( line, num_line )
1769 {
1770         type = OB_TYPE_SPAWN;
1771         if(  line == NULL || line->GetTokensCount() < 2 )
1772         {
1773                 object_type = STAGETYPE_NONE;
1774                 entity_ref = NULL;
1775         }
1776         else
1777         {
1778                 object_type =  Get_StageObjectType( *(line->GetToken(0)->data), *(line->GetToken(1)->data) );
1779                 entity_ref = obFileStage::GetEntity( *(line->GetToken(1)->data));
1780         }
1781 }
1782
1783
1784 //**********************************************
1785
1786 ob_spawn::ob_spawn(const wxString& _name, wxArrayString& _tokens)
1787 :ob_stage_at( _name, _tokens )
1788 {
1789         type = OB_TYPE_SPAWN;
1790         if(  _tokens.Count() < 1 )
1791         {
1792                 object_type = STAGETYPE_NONE;
1793                 entity_ref = NULL;
1794         }
1795         else
1796         {
1797                 object_type =  Get_StageObjectType(  _name , _tokens[0] );
1798                 entity_ref = obFileStage::GetEntity(_tokens[0] );
1799         }
1800 }
1801
1802
1803 //-----------------------------------------------------------------
1804 void
1805 ob_spawn::pClone(ob_object*& res )
1806 {
1807         if( res == NULL )
1808                 res = new ob_spawn();
1809         ob_stage_at::pClone( res );
1810         ((ob_spawn*)res)->entity_ref = entity_ref;
1811 }
1812
1813 //**********************************************
1814
1815 ob_spawn::~ob_spawn()
1816 {
1817 }
1818
1819
1820 //**********************************************
1821
1822 bool ob_spawn::Eat(  MyLine* line, const int _num_line )
1823 {
1824         if( ! ungry )
1825                 return false;
1826
1827         if( line->IsComment() || line->IsEmpty()  )
1828         {
1829                 Add_SubObj( new ob_object( line, _num_line ) );
1830                 return true;
1831         }
1832
1833
1834         wxString _name = *(line->GetToken(0)->data);
1835
1836         // Accepted !!
1837         if( Is_AcceptedTag( _name ) )
1838         {
1839                 wxString _name = *(line->GetToken(0)->data);
1840                 if( GetSubObject( _name ) != NULL )
1841                         ObjectsLog( MYLOG_ERROR, _num_line + 1,
1842                                     wxT("The object <") + name +wxT( "> contain two <") + _name +wxT("> tag !") );
1843
1844                 Add_SubObj( new ob_object( line, _num_line ) );
1845
1846                 // An <AT> close the stuff
1847                 if( _name.Upper() == wxT("AT") )
1848                 {
1849                         ungry = false;
1850                         Validate();
1851                 }
1852                 return true;
1853         }
1854
1855         // Not a tag for it anymore
1856         else
1857         {
1858                 ungry = false;
1859                 Validate();
1860                 return false;
1861         }
1862 }
1863
1864
1865 //-----------------------------------------------------------------
1866 void
1867 ob_spawn::Validate()
1868 {
1869         if( GetSubObject( wxT("AT") ) == NULL )
1870         {
1871                 ObjectsLog( MYLOG_ERROR, num_line + 1,
1872                             wxT("The object <") + name + wxT("> require a tag <AT> which is not present !" ));
1873         }
1874
1875         if( GetSubObject( wxT("COORDS") ) == NULL )
1876         {
1877                 ObjectsLog( MYLOG_ERROR, num_line + 1,
1878                             wxT("The object <") + name + wxT("> require a tag <COORDS> which is not present !") );
1879         }
1880 }
1881
1882 //-----------------------------------------------------------------
1883 wxString
1884 ob_spawn::Get_ScreenList_Name()
1885 {
1886         if( entity_ref == NULL )
1887                 return wxT("NO Entity");
1888         return entity_ref->Name();
1889 };
1890
1891 //-------------------------------------------------------------
1892 bool
1893 ob_spawn::Get_Coords(int& x, int& y)
1894 {
1895         if( ob_stage_at::Get_Coords(x,y) == false )
1896                 return false;
1897         y = -1;
1898
1899         ob_object* o = GetSubObject(wxT( "coords" ));
1900         if( o == NULL )
1901                 return false;
1902         wxString _tok = o->GetToken( 0 );
1903         if( _tok == wxString() )
1904                 return false;
1905         x += StrToInt( _tok );
1906
1907         _tok = o->GetToken( 1 );
1908         if( _tok == wxString() )
1909                 return false;
1910
1911         y = StrToInt( _tok );
1912         return true;
1913 }
1914
1915 //-------------------------------------------------------------
1916 void
1917 ob_spawn::Coords_Decal( const wxSize& _decal )
1918 {
1919         SetAt( GetAt() + _decal.x );
1920         ob_object* coords = GetSubObject(wxT( "coords" ));
1921         if( coords == NULL )
1922         {
1923                 coords = new ob_object(wxT("coords"));
1924                 coords->SetToken(0,wxT("0"));
1925                 Add_SubObj( coords );
1926         }
1927         coords->SetToken( 1, IntToStr(StrToInt(coords->GetToken(1)) + _decal.y) );
1928 }
1929
1930 //-------------------------------------------------------------
1931 void
1932 ob_spawn::Init_and_Center( wxSize& _here )
1933 {
1934         ob_stage_at::Init_and_Center( _here );
1935         ob_object* coords = GetSubObject( wxT("coords") );
1936         if( coords == NULL )
1937         {
1938                 coords = new ob_object(wxT("coords"));
1939                 coords->SetToken(0,wxT("0"));
1940                 Add_SubObj( coords );
1941         }
1942         coords->SetToken( 1, IntToStr(_here.y) );
1943 }
1944
1945
1946
1947 //**********************************************
1948 //**********************************************
1949 //**********************************************
1950 /**
1951  * The object which hold the datas about a game (mod)
1952  */
1953
1954 int ob_spawn_healthy::Get_StageObjectType( const wxString& _name,  const wxString& entity_name )
1955 {
1956         if( _name.Upper() != wxT("SPAWN") )
1957                 return STAGETYPE_NONE;
1958
1959         obFileEntity* ent = obFileStage::GetEntity( entity_name );
1960         if( ent == NULL )
1961                 return STAGETYPE_NONE;
1962         wxString ent_type = ent->obj_container->GetSubObject_Token( wxT("type") );
1963
1964         if( ent_type.Upper() == wxT("OBSTACLE") )
1965                 return SOBJ_OBSTACLE;
1966
1967         if( ent_type.Upper() == wxT("NPC") )
1968                 return SOBJ_NPC;
1969
1970         if( ent_type.Upper() == wxT("ENEMY") )
1971                 return SOBJ_ENEMY;
1972
1973         return STAGETYPE_NONE;
1974 }
1975
1976 //**********************************************
1977
1978 wxString obSpawnHealthyTags[] =
1979         {
1980                 wxT("boss"),
1981                 wxT("health"),
1982                 wxT("2phealth"),
1983                 wxT("3phealth"),
1984                 wxT("4phealth"),
1985                 wxT("score"),
1986                 wxT("nolife"),
1987                 wxT("dying"),
1988
1989                 wxT("weapon"),
1990                 wxT("aggression"),
1991
1992                 wxT("item"),
1993                 wxT("credit"),
1994                 wxT("2pitem"),
1995                 wxT("3pitem"),
1996                 wxT("4pitem"),
1997                 wxT("itemmap"),
1998                 wxT("itemhealth"),
1999                 wxT("itemalias"),
2000                 wxT("itemtrans"),
2001                 wxT("itemalpha"),
2002                 wxT("itemtrans"),
2003         };
2004
2005 bool ob_spawn_healthy::Is_AcceptedTag( const wxString& _name )
2006 {
2007         return IsInArray( _name, (wxString*) &obSpawnHealthyTags, t_size_of( obSpawnHealthyTags ) )
2008                 || ob_spawn::Is_AcceptedTag( _name );
2009 }
2010
2011 //----------------------------------------------------------------------
2012 wxString obItemHoldedTags[] =
2013         {
2014                 wxT("item"),
2015                 wxT("credit"),
2016                 wxT("2pitem"),
2017                 wxT("3pitem"),
2018                 wxT("4pitem"),
2019                 wxT("itemmap"),
2020                 wxT("itemhealth"),
2021                 wxT("itemalias"),
2022                 wxT("itemtrans"),
2023                 wxT("itemalpha"),
2024                 wxT("itemtrans"),
2025         };
2026
2027 bool
2028 ob_spawn_healthy::IsItemHoldedTag( const wxString& _tag )
2029 {
2030         return IsInArray( _tag, (wxString*) &obItemHoldedTags, t_size_of( obItemHoldedTags ) );
2031 }
2032
2033 //**********************************************
2034
2035 ob_spawn_healthy::ob_spawn_healthy( MyLine* line, const int num_line )
2036 :ob_spawn( line, num_line )
2037 {
2038         type = OB_TYPE_SPAWN_HEALTHY;
2039         if( line != NULL )
2040                 object_type =  Get_StageObjectType( *(line->GetToken(0)->data), *(line->GetToken(1)->data) );
2041 }
2042
2043
2044 //**********************************************
2045
2046 ob_spawn_healthy::ob_spawn_healthy(const wxString& _name, wxArrayString& _tokens)
2047 :ob_spawn( _name, _tokens )
2048 {
2049         type = OB_TYPE_SPAWN_HEALTHY;
2050         object_type =  Get_StageObjectType( _name, _tokens[0] );
2051 }
2052
2053
2054 //-----------------------------------------------------------------
2055 void
2056 ob_spawn_healthy::pClone(ob_object*& res )
2057 {
2058         if( res == NULL )
2059                 res = new ob_spawn_healthy();
2060         ob_spawn::pClone( res );
2061 }
2062
2063 //**********************************************
2064
2065 ob_spawn_healthy::~ob_spawn_healthy()
2066 {
2067 }
2068
2069
2070 //**********************************************
2071
2072 void ob_spawn_healthy::Validate()
2073 {
2074         ob_spawn::Validate();
2075 }
2076
2077
2078
2079 //**********************************************
2080 //**********************************************
2081 //**********************************************
2082 /**
2083  * An item spawned (not dropped)
2084  */
2085
2086 int ob_spawn_item::Get_StageObjectType( const wxString& _name,  const wxString& entity_name )
2087 {
2088         if( _name.Upper() != wxT("SPAWN" ))
2089                 return STAGETYPE_NONE;
2090
2091         obFileEntity* ent = obFileStage::GetEntity( entity_name );
2092         if( ent == NULL )
2093                 return STAGETYPE_NONE;
2094         wxString ent_type = ent->obj_container->GetSubObject_Token( wxT("type" ));
2095
2096         if( ent_type.Upper() == wxT("ITEM") )
2097                 return SOBJ_ITEM;
2098
2099         if( ent_type.Upper() == wxT("ENDLEVEL") )
2100                 return SOBJ_ENDLEVEL;
2101
2102         return STAGETYPE_NONE;
2103 }
2104
2105 //**********************************************
2106 wxString obSpawnItemTags[] =
2107   {
2108         wxT("mp"),
2109         wxT("credit"),
2110   };
2111
2112 bool ob_spawn_item::Is_AcceptedTag(const wxString& _name )
2113 {
2114         return IsInArray( _name, (wxString*) &obSpawnItemTags, t_size_of( obSpawnItemTags ) )
2115                 || ob_spawn::Is_AcceptedTag( _name );
2116 }
2117
2118
2119
2120 //**********************************************
2121
2122 ob_spawn_item::ob_spawn_item( MyLine* line, const int num_line )
2123 :ob_spawn( line, num_line )
2124 {
2125         type = OB_TYPE_SPAWN_ITEM;
2126         if( line != NULL )
2127                 object_type =  Get_StageObjectType( *(line->GetToken(0)->data), *(line->GetToken(1)->data) );
2128 }
2129
2130
2131 //**********************************************
2132
2133 ob_spawn_item::ob_spawn_item(const wxString& _name, wxArrayString& _tokens)
2134 :ob_spawn( _name, _tokens )
2135 {
2136         type = OB_TYPE_SPAWN_ITEM;
2137         object_type =  Get_StageObjectType( _name, _tokens[0] );
2138 }
2139
2140
2141 //-----------------------------------------------------------------
2142 void
2143 ob_spawn_item::pClone(ob_object*& res )
2144 {
2145         if( res == NULL )
2146                 res = new ob_spawn_item();
2147         ob_spawn::pClone( res );
2148 }
2149
2150 //**********************************************
2151
2152 ob_spawn_item::~ob_spawn_item()
2153 {
2154 }
2155
2156
2157 //**********************************************
2158
2159 void ob_spawn_item::Validate()
2160 {
2161         ob_spawn::Validate();
2162 }
2163
2164
2165 /**======================================================================
2166  * Types and Super Types helpers
2167  */
2168
2169 int  list_SST_OTHER__count;
2170 int *list_SST_OTHER;
2171 int  list_SST_GEOMETRY__count;
2172 int *list_SST_GEOMETRY;
2173 int  list_SST_CONTROL__count;
2174 int *list_SST_CONTROL;
2175 int  list_SST_VISUAL_FX__count;
2176 int *list_SST_VISUAL_FX;
2177 int  list_SST_STUFFS__count;
2178 int *list_SST_STUFFS;
2179 int  list_SST_DECORATION__count;
2180 int *list_SST_DECORATION;
2181 int  list_SST_LIVINGS__count;
2182 int *list_SST_LIVINGS;
2183
2184 map<int,int> assoc_type_supertype;
2185 void
2186 Init_SuperTypes()
2187 {
2188         if( assoc_type_supertype.size() > 0 )
2189                 return;
2190
2191         list_SST_OTHER__count = 0;
2192         list_SST_GEOMETRY__count = 0;
2193         list_SST_CONTROL__count = 0;
2194         list_SST_VISUAL_FX__count = 0;
2195         list_SST_STUFFS__count = 0;
2196         list_SST_DECORATION__count = 0;
2197         list_SST_LIVINGS__count = 0;
2198
2199         assoc_type_supertype[SOBJ_TEXT]                 = SST_OTHER;
2200         assoc_type_supertype[SOBJ_PLAYER_SPAWN]         = SST_OTHER;
2201         assoc_type_supertype[SOBJ_SETPALETTE]   = SST_OTHER;
2202
2203
2204         assoc_type_supertype[SOBJ_SCROLLZ]      = SST_GEOMETRY;
2205         assoc_type_supertype[SOBJ_WALL]         = SST_GEOMETRY;
2206         assoc_type_supertype[SOBJ_HOLE]         = SST_GEOMETRY;
2207
2208         assoc_type_supertype[SOBJ_WAIT]         = SST_CONTROL;
2209         assoc_type_supertype[SOBJ_NOJOIN]       = SST_CONTROL;
2210         assoc_type_supertype[SOBJ_CANJOIN]      = SST_CONTROL;
2211         assoc_type_supertype[SOBJ_BLOCKADE] = SST_CONTROL;
2212         assoc_type_supertype[SOBJ_GROUP]        = SST_CONTROL;
2213
2214         assoc_type_supertype[SOBJ_SHADOWCOLOR]  = SST_VISUAL_FX;
2215         assoc_type_supertype[SOBJ_SHADOWALPHA]  = SST_VISUAL_FX;
2216         assoc_type_supertype[SOBJ_LIGHT]                = SST_VISUAL_FX;
2217
2218         assoc_type_supertype[SOBJ_TRAP]         = SST_STUFFS;
2219         assoc_type_supertype[SOBJ_SHOT]         = SST_STUFFS;
2220         assoc_type_supertype[SOBJ_ITEM]         = SST_STUFFS;
2221         assoc_type_supertype[SOBJ_ENDLEVEL] = SST_STUFFS;
2222         assoc_type_supertype[SOBJ_OBSTACLE] = SST_STUFFS;
2223
2224         assoc_type_supertype[SOBJ_STEAMER]      = SST_DECORATION;
2225         assoc_type_supertype[SOBJ_NONE]         = SST_DECORATION;
2226         assoc_type_supertype[SOBJ_PANEL]        = SST_DECORATION;
2227
2228         assoc_type_supertype[SOBJ_NPC]  = SST_LIVINGS;
2229         assoc_type_supertype[SOBJ_ENEMY]        = SST_LIVINGS;
2230
2231         // fill the Members Arrays
2232         map<int,int>:: iterator it(assoc_type_supertype.begin())
2233                                 , it_end(assoc_type_supertype.end());
2234
2235
2236         for(;it!=it_end;it++)
2237         {
2238                 switch( it->second )
2239                 {
2240                         case SST_OTHER:
2241                                 list_SST_OTHER__count++;
2242                                 break;
2243                         case SST_GEOMETRY:
2244                                 list_SST_GEOMETRY__count++;
2245                                 break;
2246                         case SST_CONTROL:
2247                                 list_SST_CONTROL__count++;
2248                                 break;
2249                         case SST_VISUAL_FX:
2250                                 list_SST_VISUAL_FX__count++;
2251                                 break;
2252                         case SST_STUFFS:
2253                                 list_SST_STUFFS__count++;
2254                                 break;
2255                         case SST_DECORATION:
2256                                 list_SST_DECORATION__count++;
2257                                 break;
2258                         case SST_LIVINGS:
2259                                 list_SST_LIVINGS__count++;
2260                                 break;
2261                 }
2262         }
2263
2264         if( list_SST_OTHER__count > 0 )
2265                 list_SST_OTHER = new int[list_SST_OTHER__count];
2266         else
2267                 list_SST_OTHER = NULL;
2268         list_SST_OTHER__count=0;
2269
2270         if( list_SST_GEOMETRY__count > 0 )
2271                 list_SST_GEOMETRY = new int[list_SST_GEOMETRY__count];
2272         else
2273                 list_SST_GEOMETRY = NULL;
2274         list_SST_GEOMETRY__count=0;
2275
2276         if( list_SST_CONTROL__count > 0 )
2277                 list_SST_CONTROL = new int[list_SST_CONTROL__count];
2278         else
2279                 list_SST_CONTROL = NULL;
2280         list_SST_CONTROL__count=0;
2281
2282         if( list_SST_VISUAL_FX__count > 0 )
2283                 list_SST_VISUAL_FX = new int[list_SST_VISUAL_FX__count];
2284         else
2285                 list_SST_VISUAL_FX = NULL;
2286         list_SST_VISUAL_FX__count=0;
2287
2288         if( list_SST_STUFFS__count > 0 )
2289                 list_SST_STUFFS = new int[list_SST_STUFFS__count];
2290         else
2291                 list_SST_STUFFS = NULL;
2292         list_SST_STUFFS__count=0;
2293
2294         if( list_SST_DECORATION__count > 0 )
2295                 list_SST_DECORATION = new int[list_SST_DECORATION__count];
2296         else
2297                 list_SST_DECORATION = NULL;
2298         list_SST_DECORATION__count=0;
2299
2300         if( list_SST_LIVINGS__count > 0 )
2301                 list_SST_LIVINGS = new int[list_SST_LIVINGS__count];
2302         else
2303                 list_SST_LIVINGS = NULL;
2304         list_SST_LIVINGS__count=0;
2305
2306         it = assoc_type_supertype.begin();
2307         for(;it!=it_end;it++)
2308         {
2309                 switch( it->second )
2310                 {
2311                         case SST_OTHER:
2312                                 list_SST_OTHER[list_SST_OTHER__count] = it->first;
2313                                 list_SST_OTHER__count++;
2314                                 break;
2315                         case SST_GEOMETRY:
2316                                 list_SST_GEOMETRY[list_SST_GEOMETRY__count] = it->first;
2317                                 list_SST_GEOMETRY__count++;
2318                                 break;
2319                         case SST_CONTROL:
2320                                 list_SST_CONTROL[list_SST_CONTROL__count] = it->first;
2321                                 list_SST_CONTROL__count++;
2322                                 break;
2323                         case SST_VISUAL_FX:
2324                                 list_SST_VISUAL_FX[list_SST_VISUAL_FX__count] = it->first;
2325                                 list_SST_VISUAL_FX__count++;
2326                                 break;
2327                         case SST_STUFFS:
2328                                 list_SST_STUFFS[list_SST_STUFFS__count] = it->first;
2329                                 list_SST_STUFFS__count++;
2330                                 break;
2331                         case SST_DECORATION:
2332                                 list_SST_DECORATION[list_SST_DECORATION__count] = it->first;
2333                                 list_SST_DECORATION__count++;
2334                                 break;
2335                         case SST_LIVINGS:
2336                                 list_SST_LIVINGS[list_SST_LIVINGS__count] = it->first;
2337                                 list_SST_LIVINGS__count++;
2338                                 break;
2339                 }
2340         }
2341
2342 }
2343
2344
2345 //------------------------------------------------------------------
2346 wxString
2347 Stage__SuperType_ToStr( const int _sst )
2348 {
2349         switch( _sst )
2350         {
2351                 case SST_OTHER:
2352                         return wxT("Other");
2353                 case SST_GEOMETRY:
2354                         return wxT("Geometry");
2355                 case SST_CONTROL:
2356                         return wxT("Control");
2357                 case SST_VISUAL_FX:
2358                         return wxT("Visual Fx");
2359                 case SST_STUFFS:
2360                         return wxT("Stuff");
2361                 case SST_DECORATION:
2362                         return wxT("Decoration");
2363                 case SST_LIVINGS:
2364                         return wxT("Living");
2365                 default:
2366                         return wxT("NONE");
2367         }
2368 }
2369
2370 //------------------------------------------------------------------
2371 int
2372 Stage__SuperType_ToInt( const wxString& _sst )
2373 {
2374         if( _sst == wxT("Other" ))
2375                 return SST_OTHER;
2376         if( _sst == wxT("Geometry" ))
2377                 return SST_GEOMETRY;
2378         if( _sst == wxT("Control" ))
2379                 return SST_CONTROL;
2380         if( _sst == wxT("Visual Fx" ))
2381                 return SST_VISUAL_FX;
2382         if( _sst == wxT("Stuff" ))
2383                 return SST_STUFFS;
2384         if( _sst == wxT("Decoration" ))
2385                 return SST_DECORATION;
2386         if( _sst == wxT("Living" ))
2387                 return SST_LIVINGS;
2388         return SST_NONE;
2389 }
2390
2391 //------------------------------------------------------------------
2392 const int*
2393 Stage__SuperType_Get_Type_Array( const int _sst, size_t& arr_size )
2394 {
2395         Init_SuperTypes();
2396
2397         if( _sst == SST_OTHER )
2398         {
2399                 arr_size = list_SST_OTHER__count;
2400                 return list_SST_OTHER;
2401         }
2402         if( _sst == SST_GEOMETRY )
2403         {
2404                 arr_size = list_SST_GEOMETRY__count;
2405                 return list_SST_GEOMETRY;
2406         }
2407         if( _sst == SST_CONTROL )
2408         {
2409                 arr_size = list_SST_CONTROL__count;
2410                 return list_SST_CONTROL;
2411         }
2412         if( _sst == SST_VISUAL_FX )
2413         {
2414                 arr_size = list_SST_VISUAL_FX__count;
2415                 return list_SST_VISUAL_FX;
2416         }
2417         if( _sst == SST_STUFFS )
2418         {
2419                 arr_size = list_SST_STUFFS__count;
2420                 return list_SST_STUFFS;
2421         }
2422         if( _sst == SST_DECORATION )
2423         {
2424                 arr_size = list_SST_DECORATION__count;
2425                 return list_SST_DECORATION;
2426         }
2427         if( _sst == SST_LIVINGS )
2428         {
2429                 arr_size = list_SST_LIVINGS__count;
2430                 return list_SST_LIVINGS;
2431         }
2432
2433         arr_size = 0;
2434         return NULL;
2435 };
2436
2437 //------------------------------------------------------------------
2438 int
2439 Stage__Type__Get_SuperType( const int _sobj_type )
2440 {
2441         Init_SuperTypes();
2442
2443         map<int,int>::iterator it(assoc_type_supertype.find(_sobj_type));
2444         if( it == assoc_type_supertype.end() )
2445                 return SST_NONE;
2446
2447         return it->second;
2448 }
2449
2450 //------------------------------------------------------------------
2451 bool
2452 Stage__Type_Is_in_SuperType( const int _stype, const int _sst )
2453 {
2454         return (Stage__Type__Get_SuperType( _stype ) == _sst);
2455 }
2456
2457 //------------------------------------------------------------------
2458 int
2459 Stage__Type_ToInt( const wxString& _sst )
2460 {
2461         if( _sst == wxT("Text") )
2462                 return SOBJ_TEXT;
2463         if( _sst == wxT("EndLevel" ))
2464                 return SOBJ_ENDLEVEL;
2465         if( _sst == wxT("Player Spawn" ))
2466                 return SOBJ_PLAYER_SPAWN;
2467         if( _sst == wxT("SetPalette" ))
2468                 return SOBJ_SETPALETTE;
2469         if( _sst == wxT("Wall" ))
2470                 return SOBJ_WALL;
2471         if( _sst == wxT("Hole" ))
2472                 return SOBJ_HOLE;
2473         if( _sst == wxT("Wait" ))
2474                 return SOBJ_WAIT;
2475         if( _sst == wxT("NoJoin" ))
2476                 return SOBJ_NOJOIN;
2477         if( _sst == wxT("CanJoin" ))
2478                 return SOBJ_CANJOIN;
2479         if( _sst == wxT("Scroll[zx]" ))
2480                 return SOBJ_SCROLLZ;
2481         if( _sst == wxT("Blockade" ))
2482                 return SOBJ_BLOCKADE;
2483         if( _sst == wxT("Group" ))
2484                 return SOBJ_GROUP;
2485         if( _sst == wxT("ShadowColor" ))
2486                 return SOBJ_SHADOWCOLOR;
2487         if( _sst == wxT("ShadowAlpha" ))
2488                 return SOBJ_SHADOWALPHA;
2489         if( _sst == wxT("Light" ))
2490                 return SOBJ_LIGHT;
2491         if( _sst == wxT("Trap" ))
2492                 return SOBJ_TRAP;
2493         if( _sst == wxT("Shot" ))
2494                 return SOBJ_SHOT;
2495         if( _sst == wxT("Item" ))
2496                 return SOBJ_ITEM;
2497         if( _sst == wxT("Obstacle" ))
2498                 return SOBJ_OBSTACLE;
2499         if( _sst == wxT("Steamer" ))
2500                 return SOBJ_STEAMER;
2501         if( _sst == wxT("none" ))
2502                 return SOBJ_NONE;
2503         if( _sst == wxT("Panel" ))
2504                 return SOBJ_PANEL;
2505         if( _sst == wxT("Npc" ))
2506                 return SOBJ_NPC;
2507         if( _sst == wxT("Enemy" ))
2508                 return SOBJ_ENEMY;
2509         return STAGETYPE_NONE;
2510 }
2511
2512 //------------------------------------------------------------------
2513 wxString
2514 Stage__Type_ToStr( const int _sst )
2515 {
2516         switch( _sst )
2517         {
2518                 case SOBJ_TEXT:
2519                         return wxT("Text");
2520                 case SOBJ_ENDLEVEL:
2521                         return wxT("EndLevel");
2522                 case SOBJ_PLAYER_SPAWN:
2523                         return wxT("Player Spawn");
2524                 case SOBJ_SETPALETTE:
2525                         return wxT("SetPalette");
2526                 case SOBJ_WALL:
2527                         return wxT("Wall");
2528                 case SOBJ_HOLE:
2529                         return wxT("Hole");
2530                 case SOBJ_WAIT:
2531                         return wxT("Wait");
2532                 case SOBJ_NOJOIN:
2533                         return wxT("NoJoin");
2534                 case SOBJ_CANJOIN:
2535                         return wxT("CanJoin");
2536                 case SOBJ_SCROLLZ:
2537                         return wxT("Scroll[zx]");
2538                 case SOBJ_BLOCKADE:
2539                         return wxT("Blockade");
2540                 case SOBJ_GROUP:
2541                         return wxT("Group");
2542                 case SOBJ_SHADOWCOLOR:
2543                         return wxT("ShadowColor");
2544                 case SOBJ_SHADOWALPHA:
2545                         return wxT("ShadowAlpha");
2546                 case SOBJ_LIGHT:
2547                         return wxT("Light");
2548                 case SOBJ_TRAP:
2549                         return wxT("Trap");
2550                 case SOBJ_SHOT:
2551                         return wxT("Shot");
2552                 case SOBJ_ITEM:
2553                         return wxT("Item");
2554                 case SOBJ_OBSTACLE:
2555                         return wxT("Obstacle");
2556                 case SOBJ_STEAMER:
2557                         return wxT("Steamer");
2558                 case SOBJ_NONE:
2559                         return wxT("none");
2560                 case SOBJ_PANEL:
2561                         return wxT("Panel");
2562                 case SOBJ_NPC:
2563                         return wxT("Npc");
2564                 case SOBJ_ENEMY:
2565                         return wxT("Enemy");
2566                 default:
2567                         return wxT("NoType");
2568         }
2569 }
2570