src/scripting/wrapper.cpp

   1 /**
   2  * WARNING: This file is automatically generated from:
   3  *  'src/scripting/wrapper.interface.hpp'
   4  * DO NOT CHANGE
   5  */
   6
   7 #include <sstream>
   8
   9 #include "scripting/squirrel_error.hpp"
  10 #include "scripting/wrapper.interface.hpp"
  11
  12 namespace Scripting {
  13 namespace Wrapper {
  14
  15 static SQInteger AmbientSound_release_hook(SQUserPointer ptr, SQInteger )
  16 {
  17   Scripting::AmbientSound* _this = reinterpret_cast<Scripting::AmbientSound*> (ptr);
  18   delete _this;
  19   return 0;
  20 }
  21
  22 static SQInteger AmbientSound_set_pos_wrapper(HSQUIRRELVM vm)
  23 {
  24   SQUserPointer data;
  25   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
  26     sq_throwerror(vm, _SC("'set_pos' called without instance"));
  27     return SQ_ERROR;
  28   }
  29   Scripting::AmbientSound* _this = reinterpret_cast<Scripting::AmbientSound*> (data);
  30   SQFloat arg0;
  31   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
  32     sq_throwerror(vm, _SC("Argument 1 not a float"));
  33     return SQ_ERROR;
  34   }
  35   SQFloat arg1;
  36   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
  37     sq_throwerror(vm, _SC("Argument 2 not a float"));
  38     return SQ_ERROR;
  39   }
  40
  41   try {
  42     _this->set_pos(static_cast<float> (arg0), static_cast<float> (arg1));
  43
  44     return 0;
  45
  46   } catch(std::exception& e) {
  47     sq_throwerror(vm, e.what());
  48     return SQ_ERROR;
  49   } catch(...) {
  50     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_pos'"));
  51     return SQ_ERROR;
  52   }
  53
  54 }
  55
  56 static SQInteger AmbientSound_get_pos_x_wrapper(HSQUIRRELVM vm)
  57 {
  58   SQUserPointer data;
  59   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
  60     sq_throwerror(vm, _SC("'get_pos_x' called without instance"));
  61     return SQ_ERROR;
  62   }
  63   Scripting::AmbientSound* _this = reinterpret_cast<Scripting::AmbientSound*> (data);
  64
  65   try {
  66     float return_value = _this->get_pos_x();
  67
  68     sq_pushfloat(vm, return_value);
  69     return 1;
  70
  71   } catch(std::exception& e) {
  72     sq_throwerror(vm, e.what());
  73     return SQ_ERROR;
  74   } catch(...) {
  75     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_x'"));
  76     return SQ_ERROR;
  77   }
  78
  79 }
  80
  81 static SQInteger AmbientSound_get_pos_y_wrapper(HSQUIRRELVM vm)
  82 {
  83   SQUserPointer data;
  84   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
  85     sq_throwerror(vm, _SC("'get_pos_y' called without instance"));
  86     return SQ_ERROR;
  87   }
  88   Scripting::AmbientSound* _this = reinterpret_cast<Scripting::AmbientSound*> (data);
  89
  90   try {
  91     float return_value = _this->get_pos_y();
  92
  93     sq_pushfloat(vm, return_value);
  94     return 1;
  95
  96   } catch(std::exception& e) {
  97     sq_throwerror(vm, e.what());
  98     return SQ_ERROR;
  99   } catch(...) {
 100     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_y'"));
 101     return SQ_ERROR;
 102   }
 103
 104 }
 105
 106 static SQInteger Camera_release_hook(SQUserPointer ptr, SQInteger )
 107 {
 108   Scripting::Camera* _this = reinterpret_cast<Scripting::Camera*> (ptr);
 109   delete _this;
 110   return 0;
 111 }
 112
 113 static SQInteger Camera_reload_config_wrapper(HSQUIRRELVM vm)
 114 {
 115   SQUserPointer data;
 116   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 117     sq_throwerror(vm, _SC("'reload_config' called without instance"));
 118     return SQ_ERROR;
 119   }
 120   Scripting::Camera* _this = reinterpret_cast<Scripting::Camera*> (data);
 121
 122   try {
 123     _this->reload_config();
 124
 125     return 0;
 126
 127   } catch(std::exception& e) {
 128     sq_throwerror(vm, e.what());
 129     return SQ_ERROR;
 130   } catch(...) {
 131     sq_throwerror(vm, _SC("Unexpected exception while executing function 'reload_config'"));
 132     return SQ_ERROR;
 133   }
 134
 135 }
 136
 137 static SQInteger Camera_shake_wrapper(HSQUIRRELVM vm)
 138 {
 139   SQUserPointer data;
 140   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 141     sq_throwerror(vm, _SC("'shake' called without instance"));
 142     return SQ_ERROR;
 143   }
 144   Scripting::Camera* _this = reinterpret_cast<Scripting::Camera*> (data);
 145   SQFloat arg0;
 146   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 147     sq_throwerror(vm, _SC("Argument 1 not a float"));
 148     return SQ_ERROR;
 149   }
 150   SQFloat arg1;
 151   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
 152     sq_throwerror(vm, _SC("Argument 2 not a float"));
 153     return SQ_ERROR;
 154   }
 155   SQFloat arg2;
 156   if(SQ_FAILED(sq_getfloat(vm, 4, &arg2))) {
 157     sq_throwerror(vm, _SC("Argument 3 not a float"));
 158     return SQ_ERROR;
 159   }
 160
 161   try {
 162     _this->shake(static_cast<float> (arg0), static_cast<float> (arg1), static_cast<float> (arg2));
 163
 164     return 0;
 165
 166   } catch(std::exception& e) {
 167     sq_throwerror(vm, e.what());
 168     return SQ_ERROR;
 169   } catch(...) {
 170     sq_throwerror(vm, _SC("Unexpected exception while executing function 'shake'"));
 171     return SQ_ERROR;
 172   }
 173
 174 }
 175
 176 static SQInteger Camera_set_pos_wrapper(HSQUIRRELVM vm)
 177 {
 178   SQUserPointer data;
 179   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 180     sq_throwerror(vm, _SC("'set_pos' called without instance"));
 181     return SQ_ERROR;
 182   }
 183   Scripting::Camera* _this = reinterpret_cast<Scripting::Camera*> (data);
 184   SQFloat arg0;
 185   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 186     sq_throwerror(vm, _SC("Argument 1 not a float"));
 187     return SQ_ERROR;
 188   }
 189   SQFloat arg1;
 190   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
 191     sq_throwerror(vm, _SC("Argument 2 not a float"));
 192     return SQ_ERROR;
 193   }
 194
 195   try {
 196     _this->set_pos(static_cast<float> (arg0), static_cast<float> (arg1));
 197
 198     return 0;
 199
 200   } catch(std::exception& e) {
 201     sq_throwerror(vm, e.what());
 202     return SQ_ERROR;
 203   } catch(...) {
 204     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_pos'"));
 205     return SQ_ERROR;
 206   }
 207
 208 }
 209
 210 static SQInteger Camera_set_mode_wrapper(HSQUIRRELVM vm)
 211 {
 212   SQUserPointer data;
 213   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 214     sq_throwerror(vm, _SC("'set_mode' called without instance"));
 215     return SQ_ERROR;
 216   }
 217   Scripting::Camera* _this = reinterpret_cast<Scripting::Camera*> (data);
 218   const SQChar* arg0;
 219   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
 220     sq_throwerror(vm, _SC("Argument 1 not a string"));
 221     return SQ_ERROR;
 222   }
 223
 224   try {
 225     _this->set_mode(arg0);
 226
 227     return 0;
 228
 229   } catch(std::exception& e) {
 230     sq_throwerror(vm, e.what());
 231     return SQ_ERROR;
 232   } catch(...) {
 233     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_mode'"));
 234     return SQ_ERROR;
 235   }
 236
 237 }
 238
 239 static SQInteger Camera_scroll_to_wrapper(HSQUIRRELVM vm)
 240 {
 241   SQUserPointer data;
 242   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 243     sq_throwerror(vm, _SC("'scroll_to' called without instance"));
 244     return SQ_ERROR;
 245   }
 246   Scripting::Camera* _this = reinterpret_cast<Scripting::Camera*> (data);
 247   SQFloat arg0;
 248   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 249     sq_throwerror(vm, _SC("Argument 1 not a float"));
 250     return SQ_ERROR;
 251   }
 252   SQFloat arg1;
 253   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
 254     sq_throwerror(vm, _SC("Argument 2 not a float"));
 255     return SQ_ERROR;
 256   }
 257   SQFloat arg2;
 258   if(SQ_FAILED(sq_getfloat(vm, 4, &arg2))) {
 259     sq_throwerror(vm, _SC("Argument 3 not a float"));
 260     return SQ_ERROR;
 261   }
 262
 263   try {
 264     _this->scroll_to(static_cast<float> (arg0), static_cast<float> (arg1), static_cast<float> (arg2));
 265
 266     return 0;
 267
 268   } catch(std::exception& e) {
 269     sq_throwerror(vm, e.what());
 270     return SQ_ERROR;
 271   } catch(...) {
 272     sq_throwerror(vm, _SC("Unexpected exception while executing function 'scroll_to'"));
 273     return SQ_ERROR;
 274   }
 275
 276 }
 277
 278 static SQInteger Candle_release_hook(SQUserPointer ptr, SQInteger )
 279 {
 280   Scripting::Candle* _this = reinterpret_cast<Scripting::Candle*> (ptr);
 281   delete _this;
 282   return 0;
 283 }
 284
 285 static SQInteger Candle_get_burning_wrapper(HSQUIRRELVM vm)
 286 {
 287   SQUserPointer data;
 288   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 289     sq_throwerror(vm, _SC("'get_burning' called without instance"));
 290     return SQ_ERROR;
 291   }
 292   Scripting::Candle* _this = reinterpret_cast<Scripting::Candle*> (data);
 293
 294   try {
 295     bool return_value = _this->get_burning();
 296
 297     sq_pushbool(vm, return_value);
 298     return 1;
 299
 300   } catch(std::exception& e) {
 301     sq_throwerror(vm, e.what());
 302     return SQ_ERROR;
 303   } catch(...) {
 304     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_burning'"));
 305     return SQ_ERROR;
 306   }
 307
 308 }
 309
 310 static SQInteger Candle_set_burning_wrapper(HSQUIRRELVM vm)
 311 {
 312   SQUserPointer data;
 313   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 314     sq_throwerror(vm, _SC("'set_burning' called without instance"));
 315     return SQ_ERROR;
 316   }
 317   Scripting::Candle* _this = reinterpret_cast<Scripting::Candle*> (data);
 318   SQBool arg0;
 319   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
 320     sq_throwerror(vm, _SC("Argument 1 not a bool"));
 321     return SQ_ERROR;
 322   }
 323
 324   try {
 325     _this->set_burning(arg0 == SQTrue);
 326
 327     return 0;
 328
 329   } catch(std::exception& e) {
 330     sq_throwerror(vm, e.what());
 331     return SQ_ERROR;
 332   } catch(...) {
 333     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_burning'"));
 334     return SQ_ERROR;
 335   }
 336
 337 }
 338
 339 static SQInteger DisplayEffect_release_hook(SQUserPointer ptr, SQInteger )
 340 {
 341   Scripting::DisplayEffect* _this = reinterpret_cast<Scripting::DisplayEffect*> (ptr);
 342   delete _this;
 343   return 0;
 344 }
 345
 346 static SQInteger DisplayEffect_fade_out_wrapper(HSQUIRRELVM vm)
 347 {
 348   SQUserPointer data;
 349   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 350     sq_throwerror(vm, _SC("'fade_out' called without instance"));
 351     return SQ_ERROR;
 352   }
 353   Scripting::DisplayEffect* _this = reinterpret_cast<Scripting::DisplayEffect*> (data);
 354   SQFloat arg0;
 355   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 356     sq_throwerror(vm, _SC("Argument 1 not a float"));
 357     return SQ_ERROR;
 358   }
 359
 360   try {
 361     _this->fade_out(static_cast<float> (arg0));
 362
 363     return 0;
 364
 365   } catch(std::exception& e) {
 366     sq_throwerror(vm, e.what());
 367     return SQ_ERROR;
 368   } catch(...) {
 369     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fade_out'"));
 370     return SQ_ERROR;
 371   }
 372
 373 }
 374
 375 static SQInteger DisplayEffect_fade_in_wrapper(HSQUIRRELVM vm)
 376 {
 377   SQUserPointer data;
 378   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 379     sq_throwerror(vm, _SC("'fade_in' called without instance"));
 380     return SQ_ERROR;
 381   }
 382   Scripting::DisplayEffect* _this = reinterpret_cast<Scripting::DisplayEffect*> (data);
 383   SQFloat arg0;
 384   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 385     sq_throwerror(vm, _SC("Argument 1 not a float"));
 386     return SQ_ERROR;
 387   }
 388
 389   try {
 390     _this->fade_in(static_cast<float> (arg0));
 391
 392     return 0;
 393
 394   } catch(std::exception& e) {
 395     sq_throwerror(vm, e.what());
 396     return SQ_ERROR;
 397   } catch(...) {
 398     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fade_in'"));
 399     return SQ_ERROR;
 400   }
 401
 402 }
 403
 404 static SQInteger DisplayEffect_set_black_wrapper(HSQUIRRELVM vm)
 405 {
 406   SQUserPointer data;
 407   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 408     sq_throwerror(vm, _SC("'set_black' called without instance"));
 409     return SQ_ERROR;
 410   }
 411   Scripting::DisplayEffect* _this = reinterpret_cast<Scripting::DisplayEffect*> (data);
 412   SQBool arg0;
 413   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
 414     sq_throwerror(vm, _SC("Argument 1 not a bool"));
 415     return SQ_ERROR;
 416   }
 417
 418   try {
 419     _this->set_black(arg0 == SQTrue);
 420
 421     return 0;
 422
 423   } catch(std::exception& e) {
 424     sq_throwerror(vm, e.what());
 425     return SQ_ERROR;
 426   } catch(...) {
 427     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_black'"));
 428     return SQ_ERROR;
 429   }
 430
 431 }
 432
 433 static SQInteger DisplayEffect_is_black_wrapper(HSQUIRRELVM vm)
 434 {
 435   SQUserPointer data;
 436   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 437     sq_throwerror(vm, _SC("'is_black' called without instance"));
 438     return SQ_ERROR;
 439   }
 440   Scripting::DisplayEffect* _this = reinterpret_cast<Scripting::DisplayEffect*> (data);
 441
 442   try {
 443     bool return_value = _this->is_black();
 444
 445     sq_pushbool(vm, return_value);
 446     return 1;
 447
 448   } catch(std::exception& e) {
 449     sq_throwerror(vm, e.what());
 450     return SQ_ERROR;
 451   } catch(...) {
 452     sq_throwerror(vm, _SC("Unexpected exception while executing function 'is_black'"));
 453     return SQ_ERROR;
 454   }
 455
 456 }
 457
 458 static SQInteger DisplayEffect_sixteen_to_nine_wrapper(HSQUIRRELVM vm)
 459 {
 460   SQUserPointer data;
 461   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 462     sq_throwerror(vm, _SC("'sixteen_to_nine' called without instance"));
 463     return SQ_ERROR;
 464   }
 465   Scripting::DisplayEffect* _this = reinterpret_cast<Scripting::DisplayEffect*> (data);
 466   SQFloat arg0;
 467   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 468     sq_throwerror(vm, _SC("Argument 1 not a float"));
 469     return SQ_ERROR;
 470   }
 471
 472   try {
 473     _this->sixteen_to_nine(static_cast<float> (arg0));
 474
 475     return 0;
 476
 477   } catch(std::exception& e) {
 478     sq_throwerror(vm, e.what());
 479     return SQ_ERROR;
 480   } catch(...) {
 481     sq_throwerror(vm, _SC("Unexpected exception while executing function 'sixteen_to_nine'"));
 482     return SQ_ERROR;
 483   }
 484
 485 }
 486
 487 static SQInteger DisplayEffect_four_to_three_wrapper(HSQUIRRELVM vm)
 488 {
 489   SQUserPointer data;
 490   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 491     sq_throwerror(vm, _SC("'four_to_three' called without instance"));
 492     return SQ_ERROR;
 493   }
 494   Scripting::DisplayEffect* _this = reinterpret_cast<Scripting::DisplayEffect*> (data);
 495   SQFloat arg0;
 496   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 497     sq_throwerror(vm, _SC("Argument 1 not a float"));
 498     return SQ_ERROR;
 499   }
 500
 501   try {
 502     _this->four_to_three(static_cast<float> (arg0));
 503
 504     return 0;
 505
 506   } catch(std::exception& e) {
 507     sq_throwerror(vm, e.what());
 508     return SQ_ERROR;
 509   } catch(...) {
 510     sq_throwerror(vm, _SC("Unexpected exception while executing function 'four_to_three'"));
 511     return SQ_ERROR;
 512   }
 513
 514 }
 515
 516 static SQInteger FloatingImage_release_hook(SQUserPointer ptr, SQInteger )
 517 {
 518   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (ptr);
 519   delete _this;
 520   return 0;
 521 }
 522
 523 static SQInteger FloatingImage_constructor_wrapper(HSQUIRRELVM vm)
 524 {
 525   const SQChar* arg0;
 526   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
 527     sq_throwerror(vm, _SC("Argument 1 not a string"));
 528     return SQ_ERROR;
 529   }
 530
 531   try {
 532     Scripting::FloatingImage* _this = new Scripting::FloatingImage(arg0);
 533   if(SQ_FAILED(sq_setinstanceup(vm, 1, _this))) {
 534     sq_throwerror(vm, _SC("Couldn't setup instance of 'FloatingImage' class"));
 535     return SQ_ERROR;
 536   }
 537   sq_setreleasehook(vm, 1, FloatingImage_release_hook);
 538
 539     return 0;
 540
 541   } catch(std::exception& e) {
 542     sq_throwerror(vm, e.what());
 543     return SQ_ERROR;
 544   } catch(...) {
 545     sq_throwerror(vm, _SC("Unexpected exception while executing function 'constructor'"));
 546     return SQ_ERROR;
 547   }
 548
 549 }
 550
 551 static SQInteger FloatingImage_set_layer_wrapper(HSQUIRRELVM vm)
 552 {
 553   SQUserPointer data;
 554   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 555     sq_throwerror(vm, _SC("'set_layer' called without instance"));
 556     return SQ_ERROR;
 557   }
 558   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
 559   SQInteger arg0;
 560   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
 561     sq_throwerror(vm, _SC("Argument 1 not an integer"));
 562     return SQ_ERROR;
 563   }
 564
 565   try {
 566     _this->set_layer(static_cast<int> (arg0));
 567
 568     return 0;
 569
 570   } catch(std::exception& e) {
 571     sq_throwerror(vm, e.what());
 572     return SQ_ERROR;
 573   } catch(...) {
 574     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_layer'"));
 575     return SQ_ERROR;
 576   }
 577
 578 }
 579
 580 static SQInteger FloatingImage_get_layer_wrapper(HSQUIRRELVM vm)
 581 {
 582   SQUserPointer data;
 583   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 584     sq_throwerror(vm, _SC("'get_layer' called without instance"));
 585     return SQ_ERROR;
 586   }
 587   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
 588
 589   try {
 590     int return_value = _this->get_layer();
 591
 592     sq_pushinteger(vm, return_value);
 593     return 1;
 594
 595   } catch(std::exception& e) {
 596     sq_throwerror(vm, e.what());
 597     return SQ_ERROR;
 598   } catch(...) {
 599     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_layer'"));
 600     return SQ_ERROR;
 601   }
 602
 603 }
 604
 605 static SQInteger FloatingImage_set_pos_wrapper(HSQUIRRELVM vm)
 606 {
 607   SQUserPointer data;
 608   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 609     sq_throwerror(vm, _SC("'set_pos' called without instance"));
 610     return SQ_ERROR;
 611   }
 612   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
 613   SQFloat arg0;
 614   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 615     sq_throwerror(vm, _SC("Argument 1 not a float"));
 616     return SQ_ERROR;
 617   }
 618   SQFloat arg1;
 619   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
 620     sq_throwerror(vm, _SC("Argument 2 not a float"));
 621     return SQ_ERROR;
 622   }
 623
 624   try {
 625     _this->set_pos(static_cast<float> (arg0), static_cast<float> (arg1));
 626
 627     return 0;
 628
 629   } catch(std::exception& e) {
 630     sq_throwerror(vm, e.what());
 631     return SQ_ERROR;
 632   } catch(...) {
 633     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_pos'"));
 634     return SQ_ERROR;
 635   }
 636
 637 }
 638
 639 static SQInteger FloatingImage_get_pos_x_wrapper(HSQUIRRELVM vm)
 640 {
 641   SQUserPointer data;
 642   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 643     sq_throwerror(vm, _SC("'get_pos_x' called without instance"));
 644     return SQ_ERROR;
 645   }
 646   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
 647
 648   try {
 649     float return_value = _this->get_pos_x();
 650
 651     sq_pushfloat(vm, return_value);
 652     return 1;
 653
 654   } catch(std::exception& e) {
 655     sq_throwerror(vm, e.what());
 656     return SQ_ERROR;
 657   } catch(...) {
 658     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_x'"));
 659     return SQ_ERROR;
 660   }
 661
 662 }
 663
 664 static SQInteger FloatingImage_get_pos_y_wrapper(HSQUIRRELVM vm)
 665 {
 666   SQUserPointer data;
 667   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 668     sq_throwerror(vm, _SC("'get_pos_y' called without instance"));
 669     return SQ_ERROR;
 670   }
 671   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
 672
 673   try {
 674     float return_value = _this->get_pos_y();
 675
 676     sq_pushfloat(vm, return_value);
 677     return 1;
 678
 679   } catch(std::exception& e) {
 680     sq_throwerror(vm, e.what());
 681     return SQ_ERROR;
 682   } catch(...) {
 683     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_y'"));
 684     return SQ_ERROR;
 685   }
 686
 687 }
 688
 689 static SQInteger FloatingImage_set_anchor_point_wrapper(HSQUIRRELVM vm)
 690 {
 691   SQUserPointer data;
 692   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 693     sq_throwerror(vm, _SC("'set_anchor_point' called without instance"));
 694     return SQ_ERROR;
 695   }
 696   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
 697   SQInteger arg0;
 698   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
 699     sq_throwerror(vm, _SC("Argument 1 not an integer"));
 700     return SQ_ERROR;
 701   }
 702
 703   try {
 704     _this->set_anchor_point(static_cast<int> (arg0));
 705
 706     return 0;
 707
 708   } catch(std::exception& e) {
 709     sq_throwerror(vm, e.what());
 710     return SQ_ERROR;
 711   } catch(...) {
 712     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_anchor_point'"));
 713     return SQ_ERROR;
 714   }
 715
 716 }
 717
 718 static SQInteger FloatingImage_get_anchor_point_wrapper(HSQUIRRELVM vm)
 719 {
 720   SQUserPointer data;
 721   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 722     sq_throwerror(vm, _SC("'get_anchor_point' called without instance"));
 723     return SQ_ERROR;
 724   }
 725   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
 726
 727   try {
 728     int return_value = _this->get_anchor_point();
 729
 730     sq_pushinteger(vm, return_value);
 731     return 1;
 732
 733   } catch(std::exception& e) {
 734     sq_throwerror(vm, e.what());
 735     return SQ_ERROR;
 736   } catch(...) {
 737     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_anchor_point'"));
 738     return SQ_ERROR;
 739   }
 740
 741 }
 742
 743 static SQInteger FloatingImage_set_visible_wrapper(HSQUIRRELVM vm)
 744 {
 745   SQUserPointer data;
 746   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 747     sq_throwerror(vm, _SC("'set_visible' called without instance"));
 748     return SQ_ERROR;
 749   }
 750   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
 751   SQBool arg0;
 752   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
 753     sq_throwerror(vm, _SC("Argument 1 not a bool"));
 754     return SQ_ERROR;
 755   }
 756
 757   try {
 758     _this->set_visible(arg0 == SQTrue);
 759
 760     return 0;
 761
 762   } catch(std::exception& e) {
 763     sq_throwerror(vm, e.what());
 764     return SQ_ERROR;
 765   } catch(...) {
 766     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_visible'"));
 767     return SQ_ERROR;
 768   }
 769
 770 }
 771
 772 static SQInteger FloatingImage_get_visible_wrapper(HSQUIRRELVM vm)
 773 {
 774   SQUserPointer data;
 775   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 776     sq_throwerror(vm, _SC("'get_visible' called without instance"));
 777     return SQ_ERROR;
 778   }
 779   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
 780
 781   try {
 782     bool return_value = _this->get_visible();
 783
 784     sq_pushbool(vm, return_value);
 785     return 1;
 786
 787   } catch(std::exception& e) {
 788     sq_throwerror(vm, e.what());
 789     return SQ_ERROR;
 790   } catch(...) {
 791     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_visible'"));
 792     return SQ_ERROR;
 793   }
 794
 795 }
 796
 797 static SQInteger FloatingImage_set_action_wrapper(HSQUIRRELVM vm)
 798 {
 799   SQUserPointer data;
 800   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 801     sq_throwerror(vm, _SC("'set_action' called without instance"));
 802     return SQ_ERROR;
 803   }
 804   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
 805   const SQChar* arg0;
 806   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
 807     sq_throwerror(vm, _SC("Argument 1 not a string"));
 808     return SQ_ERROR;
 809   }
 810
 811   try {
 812     _this->set_action(arg0);
 813
 814     return 0;
 815
 816   } catch(std::exception& e) {
 817     sq_throwerror(vm, e.what());
 818     return SQ_ERROR;
 819   } catch(...) {
 820     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_action'"));
 821     return SQ_ERROR;
 822   }
 823
 824 }
 825
 826 static SQInteger FloatingImage_get_action_wrapper(HSQUIRRELVM vm)
 827 {
 828   SQUserPointer data;
 829   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 830     sq_throwerror(vm, _SC("'get_action' called without instance"));
 831     return SQ_ERROR;
 832   }
 833   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
 834
 835   try {
 836     std::string return_value = _this->get_action();
 837
 838     sq_pushstring(vm, return_value.c_str(), return_value.size());
 839     return 1;
 840
 841   } catch(std::exception& e) {
 842     sq_throwerror(vm, e.what());
 843     return SQ_ERROR;
 844   } catch(...) {
 845     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_action'"));
 846     return SQ_ERROR;
 847   }
 848
 849 }
 850
 851 static SQInteger FloatingImage_fade_in_wrapper(HSQUIRRELVM vm)
 852 {
 853   SQUserPointer data;
 854   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 855     sq_throwerror(vm, _SC("'fade_in' called without instance"));
 856     return SQ_ERROR;
 857   }
 858   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
 859   SQFloat arg0;
 860   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 861     sq_throwerror(vm, _SC("Argument 1 not a float"));
 862     return SQ_ERROR;
 863   }
 864
 865   try {
 866     _this->fade_in(static_cast<float> (arg0));
 867
 868     return 0;
 869
 870   } catch(std::exception& e) {
 871     sq_throwerror(vm, e.what());
 872     return SQ_ERROR;
 873   } catch(...) {
 874     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fade_in'"));
 875     return SQ_ERROR;
 876   }
 877
 878 }
 879
 880 static SQInteger FloatingImage_fade_out_wrapper(HSQUIRRELVM vm)
 881 {
 882   SQUserPointer data;
 883   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 884     sq_throwerror(vm, _SC("'fade_out' called without instance"));
 885     return SQ_ERROR;
 886   }
 887   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
 888   SQFloat arg0;
 889   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 890     sq_throwerror(vm, _SC("Argument 1 not a float"));
 891     return SQ_ERROR;
 892   }
 893
 894   try {
 895     _this->fade_out(static_cast<float> (arg0));
 896
 897     return 0;
 898
 899   } catch(std::exception& e) {
 900     sq_throwerror(vm, e.what());
 901     return SQ_ERROR;
 902   } catch(...) {
 903     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fade_out'"));
 904     return SQ_ERROR;
 905   }
 906
 907 }
 908
 909 static SQInteger LevelTime_release_hook(SQUserPointer ptr, SQInteger )
 910 {
 911   Scripting::LevelTime* _this = reinterpret_cast<Scripting::LevelTime*> (ptr);
 912   delete _this;
 913   return 0;
 914 }
 915
 916 static SQInteger LevelTime_start_wrapper(HSQUIRRELVM vm)
 917 {
 918   SQUserPointer data;
 919   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 920     sq_throwerror(vm, _SC("'start' called without instance"));
 921     return SQ_ERROR;
 922   }
 923   Scripting::LevelTime* _this = reinterpret_cast<Scripting::LevelTime*> (data);
 924
 925   try {
 926     _this->start();
 927
 928     return 0;
 929
 930   } catch(std::exception& e) {
 931     sq_throwerror(vm, e.what());
 932     return SQ_ERROR;
 933   } catch(...) {
 934     sq_throwerror(vm, _SC("Unexpected exception while executing function 'start'"));
 935     return SQ_ERROR;
 936   }
 937
 938 }
 939
 940 static SQInteger LevelTime_stop_wrapper(HSQUIRRELVM vm)
 941 {
 942   SQUserPointer data;
 943   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 944     sq_throwerror(vm, _SC("'stop' called without instance"));
 945     return SQ_ERROR;
 946   }
 947   Scripting::LevelTime* _this = reinterpret_cast<Scripting::LevelTime*> (data);
 948
 949   try {
 950     _this->stop();
 951
 952     return 0;
 953
 954   } catch(std::exception& e) {
 955     sq_throwerror(vm, e.what());
 956     return SQ_ERROR;
 957   } catch(...) {
 958     sq_throwerror(vm, _SC("Unexpected exception while executing function 'stop'"));
 959     return SQ_ERROR;
 960   }
 961
 962 }
 963
 964 static SQInteger LevelTime_get_time_wrapper(HSQUIRRELVM vm)
 965 {
 966   SQUserPointer data;
 967   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 968     sq_throwerror(vm, _SC("'get_time' called without instance"));
 969     return SQ_ERROR;
 970   }
 971   Scripting::LevelTime* _this = reinterpret_cast<Scripting::LevelTime*> (data);
 972
 973   try {
 974     float return_value = _this->get_time();
 975
 976     sq_pushfloat(vm, return_value);
 977     return 1;
 978
 979   } catch(std::exception& e) {
 980     sq_throwerror(vm, e.what());
 981     return SQ_ERROR;
 982   } catch(...) {
 983     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_time'"));
 984     return SQ_ERROR;
 985   }
 986
 987 }
 988
 989 static SQInteger LevelTime_set_time_wrapper(HSQUIRRELVM vm)
 990 {
 991   SQUserPointer data;
 992   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
 993     sq_throwerror(vm, _SC("'set_time' called without instance"));
 994     return SQ_ERROR;
 995   }
 996   Scripting::LevelTime* _this = reinterpret_cast<Scripting::LevelTime*> (data);
 997   SQFloat arg0;
 998   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 999     sq_throwerror(vm, _SC("Argument 1 not a float"));
1000     return SQ_ERROR;
1001   }
1002
1003   try {
1004     _this->set_time(static_cast<float> (arg0));
1005
1006     return 0;
1007
1008   } catch(std::exception& e) {
1009     sq_throwerror(vm, e.what());
1010     return SQ_ERROR;
1011   } catch(...) {
1012     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_time'"));
1013     return SQ_ERROR;
1014   }
1015
1016 }
1017
1018 static SQInteger Platform_release_hook(SQUserPointer ptr, SQInteger )
1019 {
1020   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (ptr);
1021   delete _this;
1022   return 0;
1023 }
1024
1025 static SQInteger Platform_goto_node_wrapper(HSQUIRRELVM vm)
1026 {
1027   SQUserPointer data;
1028   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1029     sq_throwerror(vm, _SC("'goto_node' called without instance"));
1030     return SQ_ERROR;
1031   }
1032   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (data);
1033   SQInteger arg0;
1034   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
1035     sq_throwerror(vm, _SC("Argument 1 not an integer"));
1036     return SQ_ERROR;
1037   }
1038
1039   try {
1040     _this->goto_node(static_cast<int> (arg0));
1041
1042     return 0;
1043
1044   } catch(std::exception& e) {
1045     sq_throwerror(vm, e.what());
1046     return SQ_ERROR;
1047   } catch(...) {
1048     sq_throwerror(vm, _SC("Unexpected exception while executing function 'goto_node'"));
1049     return SQ_ERROR;
1050   }
1051
1052 }
1053
1054 static SQInteger Platform_start_moving_wrapper(HSQUIRRELVM vm)
1055 {
1056   SQUserPointer data;
1057   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1058     sq_throwerror(vm, _SC("'start_moving' called without instance"));
1059     return SQ_ERROR;
1060   }
1061   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (data);
1062
1063   try {
1064     _this->start_moving();
1065
1066     return 0;
1067
1068   } catch(std::exception& e) {
1069     sq_throwerror(vm, e.what());
1070     return SQ_ERROR;
1071   } catch(...) {
1072     sq_throwerror(vm, _SC("Unexpected exception while executing function 'start_moving'"));
1073     return SQ_ERROR;
1074   }
1075
1076 }
1077
1078 static SQInteger Platform_stop_moving_wrapper(HSQUIRRELVM vm)
1079 {
1080   SQUserPointer data;
1081   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1082     sq_throwerror(vm, _SC("'stop_moving' called without instance"));
1083     return SQ_ERROR;
1084   }
1085   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (data);
1086
1087   try {
1088     _this->stop_moving();
1089
1090     return 0;
1091
1092   } catch(std::exception& e) {
1093     sq_throwerror(vm, e.what());
1094     return SQ_ERROR;
1095   } catch(...) {
1096     sq_throwerror(vm, _SC("Unexpected exception while executing function 'stop_moving'"));
1097     return SQ_ERROR;
1098   }
1099
1100 }
1101
1102 static SQInteger Player_release_hook(SQUserPointer ptr, SQInteger )
1103 {
1104   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (ptr);
1105   delete _this;
1106   return 0;
1107 }
1108
1109 static SQInteger Player_add_bonus_wrapper(HSQUIRRELVM vm)
1110 {
1111   SQUserPointer data;
1112   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1113     sq_throwerror(vm, _SC("'add_bonus' called without instance"));
1114     return SQ_ERROR;
1115   }
1116   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1117   const SQChar* arg0;
1118   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1119     sq_throwerror(vm, _SC("Argument 1 not a string"));
1120     return SQ_ERROR;
1121   }
1122
1123   try {
1124     bool return_value = _this->add_bonus(arg0);
1125
1126     sq_pushbool(vm, return_value);
1127     return 1;
1128
1129   } catch(std::exception& e) {
1130     sq_throwerror(vm, e.what());
1131     return SQ_ERROR;
1132   } catch(...) {
1133     sq_throwerror(vm, _SC("Unexpected exception while executing function 'add_bonus'"));
1134     return SQ_ERROR;
1135   }
1136
1137 }
1138
1139 static SQInteger Player_add_coins_wrapper(HSQUIRRELVM vm)
1140 {
1141   SQUserPointer data;
1142   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1143     sq_throwerror(vm, _SC("'add_coins' called without instance"));
1144     return SQ_ERROR;
1145   }
1146   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1147   SQInteger arg0;
1148   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
1149     sq_throwerror(vm, _SC("Argument 1 not an integer"));
1150     return SQ_ERROR;
1151   }
1152
1153   try {
1154     _this->add_coins(static_cast<int> (arg0));
1155
1156     return 0;
1157
1158   } catch(std::exception& e) {
1159     sq_throwerror(vm, e.what());
1160     return SQ_ERROR;
1161   } catch(...) {
1162     sq_throwerror(vm, _SC("Unexpected exception while executing function 'add_coins'"));
1163     return SQ_ERROR;
1164   }
1165
1166 }
1167
1168 static SQInteger Player_make_invincible_wrapper(HSQUIRRELVM vm)
1169 {
1170   SQUserPointer data;
1171   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1172     sq_throwerror(vm, _SC("'make_invincible' called without instance"));
1173     return SQ_ERROR;
1174   }
1175   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1176
1177   try {
1178     _this->make_invincible();
1179
1180     return 0;
1181
1182   } catch(std::exception& e) {
1183     sq_throwerror(vm, e.what());
1184     return SQ_ERROR;
1185   } catch(...) {
1186     sq_throwerror(vm, _SC("Unexpected exception while executing function 'make_invincible'"));
1187     return SQ_ERROR;
1188   }
1189
1190 }
1191
1192 static SQInteger Player_deactivate_wrapper(HSQUIRRELVM vm)
1193 {
1194   SQUserPointer data;
1195   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1196     sq_throwerror(vm, _SC("'deactivate' called without instance"));
1197     return SQ_ERROR;
1198   }
1199   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1200
1201   try {
1202     _this->deactivate();
1203
1204     return 0;
1205
1206   } catch(std::exception& e) {
1207     sq_throwerror(vm, e.what());
1208     return SQ_ERROR;
1209   } catch(...) {
1210     sq_throwerror(vm, _SC("Unexpected exception while executing function 'deactivate'"));
1211     return SQ_ERROR;
1212   }
1213
1214 }
1215
1216 static SQInteger Player_activate_wrapper(HSQUIRRELVM vm)
1217 {
1218   SQUserPointer data;
1219   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1220     sq_throwerror(vm, _SC("'activate' called without instance"));
1221     return SQ_ERROR;
1222   }
1223   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1224
1225   try {
1226     _this->activate();
1227
1228     return 0;
1229
1230   } catch(std::exception& e) {
1231     sq_throwerror(vm, e.what());
1232     return SQ_ERROR;
1233   } catch(...) {
1234     sq_throwerror(vm, _SC("Unexpected exception while executing function 'activate'"));
1235     return SQ_ERROR;
1236   }
1237
1238 }
1239
1240 static SQInteger Player_walk_wrapper(HSQUIRRELVM vm)
1241 {
1242   SQUserPointer data;
1243   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1244     sq_throwerror(vm, _SC("'walk' called without instance"));
1245     return SQ_ERROR;
1246   }
1247   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1248   SQFloat arg0;
1249   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
1250     sq_throwerror(vm, _SC("Argument 1 not a float"));
1251     return SQ_ERROR;
1252   }
1253
1254   try {
1255     _this->walk(static_cast<float> (arg0));
1256
1257     return 0;
1258
1259   } catch(std::exception& e) {
1260     sq_throwerror(vm, e.what());
1261     return SQ_ERROR;
1262   } catch(...) {
1263     sq_throwerror(vm, _SC("Unexpected exception while executing function 'walk'"));
1264     return SQ_ERROR;
1265   }
1266
1267 }
1268
1269 static SQInteger Player_set_visible_wrapper(HSQUIRRELVM vm)
1270 {
1271   SQUserPointer data;
1272   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1273     sq_throwerror(vm, _SC("'set_visible' called without instance"));
1274     return SQ_ERROR;
1275   }
1276   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1277   SQBool arg0;
1278   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1279     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1280     return SQ_ERROR;
1281   }
1282
1283   try {
1284     _this->set_visible(arg0 == SQTrue);
1285
1286     return 0;
1287
1288   } catch(std::exception& e) {
1289     sq_throwerror(vm, e.what());
1290     return SQ_ERROR;
1291   } catch(...) {
1292     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_visible'"));
1293     return SQ_ERROR;
1294   }
1295
1296 }
1297
1298 static SQInteger Player_get_visible_wrapper(HSQUIRRELVM vm)
1299 {
1300   SQUserPointer data;
1301   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1302     sq_throwerror(vm, _SC("'get_visible' called without instance"));
1303     return SQ_ERROR;
1304   }
1305   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1306
1307   try {
1308     bool return_value = _this->get_visible();
1309
1310     sq_pushbool(vm, return_value);
1311     return 1;
1312
1313   } catch(std::exception& e) {
1314     sq_throwerror(vm, e.what());
1315     return SQ_ERROR;
1316   } catch(...) {
1317     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_visible'"));
1318     return SQ_ERROR;
1319   }
1320
1321 }
1322
1323 static SQInteger Player_kill_wrapper(HSQUIRRELVM vm)
1324 {
1325   SQUserPointer data;
1326   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1327     sq_throwerror(vm, _SC("'kill' called without instance"));
1328     return SQ_ERROR;
1329   }
1330   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1331   SQBool arg0;
1332   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1333     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1334     return SQ_ERROR;
1335   }
1336
1337   try {
1338     _this->kill(arg0 == SQTrue);
1339
1340     return 0;
1341
1342   } catch(std::exception& e) {
1343     sq_throwerror(vm, e.what());
1344     return SQ_ERROR;
1345   } catch(...) {
1346     sq_throwerror(vm, _SC("Unexpected exception while executing function 'kill'"));
1347     return SQ_ERROR;
1348   }
1349
1350 }
1351
1352 static SQInteger Player_set_ghost_mode_wrapper(HSQUIRRELVM vm)
1353 {
1354   SQUserPointer data;
1355   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1356     sq_throwerror(vm, _SC("'set_ghost_mode' called without instance"));
1357     return SQ_ERROR;
1358   }
1359   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1360   SQBool arg0;
1361   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1362     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1363     return SQ_ERROR;
1364   }
1365
1366   try {
1367     _this->set_ghost_mode(arg0 == SQTrue);
1368
1369     return 0;
1370
1371   } catch(std::exception& e) {
1372     sq_throwerror(vm, e.what());
1373     return SQ_ERROR;
1374   } catch(...) {
1375     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_ghost_mode'"));
1376     return SQ_ERROR;
1377   }
1378
1379 }
1380
1381 static SQInteger Player_get_ghost_mode_wrapper(HSQUIRRELVM vm)
1382 {
1383   SQUserPointer data;
1384   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1385     sq_throwerror(vm, _SC("'get_ghost_mode' called without instance"));
1386     return SQ_ERROR;
1387   }
1388   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1389
1390   try {
1391     bool return_value = _this->get_ghost_mode();
1392
1393     sq_pushbool(vm, return_value);
1394     return 1;
1395
1396   } catch(std::exception& e) {
1397     sq_throwerror(vm, e.what());
1398     return SQ_ERROR;
1399   } catch(...) {
1400     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_ghost_mode'"));
1401     return SQ_ERROR;
1402   }
1403
1404 }
1405
1406 static SQInteger Player_do_cheer_wrapper(HSQUIRRELVM vm)
1407 {
1408   SQUserPointer data;
1409   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1410     sq_throwerror(vm, _SC("'do_cheer' called without instance"));
1411     return SQ_ERROR;
1412   }
1413   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1414
1415   try {
1416     _this->do_cheer();
1417
1418     return 0;
1419
1420   } catch(std::exception& e) {
1421     sq_throwerror(vm, e.what());
1422     return SQ_ERROR;
1423   } catch(...) {
1424     sq_throwerror(vm, _SC("Unexpected exception while executing function 'do_cheer'"));
1425     return SQ_ERROR;
1426   }
1427
1428 }
1429
1430 static SQInteger Player_do_duck_wrapper(HSQUIRRELVM vm)
1431 {
1432   SQUserPointer data;
1433   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1434     sq_throwerror(vm, _SC("'do_duck' called without instance"));
1435     return SQ_ERROR;
1436   }
1437   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1438
1439   try {
1440     _this->do_duck();
1441
1442     return 0;
1443
1444   } catch(std::exception& e) {
1445     sq_throwerror(vm, e.what());
1446     return SQ_ERROR;
1447   } catch(...) {
1448     sq_throwerror(vm, _SC("Unexpected exception while executing function 'do_duck'"));
1449     return SQ_ERROR;
1450   }
1451
1452 }
1453
1454 static SQInteger Player_do_standup_wrapper(HSQUIRRELVM vm)
1455 {
1456   SQUserPointer data;
1457   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1458     sq_throwerror(vm, _SC("'do_standup' called without instance"));
1459     return SQ_ERROR;
1460   }
1461   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1462
1463   try {
1464     _this->do_standup();
1465
1466     return 0;
1467
1468   } catch(std::exception& e) {
1469     sq_throwerror(vm, e.what());
1470     return SQ_ERROR;
1471   } catch(...) {
1472     sq_throwerror(vm, _SC("Unexpected exception while executing function 'do_standup'"));
1473     return SQ_ERROR;
1474   }
1475
1476 }
1477
1478 static SQInteger Player_do_backflip_wrapper(HSQUIRRELVM vm)
1479 {
1480   SQUserPointer data;
1481   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1482     sq_throwerror(vm, _SC("'do_backflip' called without instance"));
1483     return SQ_ERROR;
1484   }
1485   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1486
1487   try {
1488     _this->do_backflip();
1489
1490     return 0;
1491
1492   } catch(std::exception& e) {
1493     sq_throwerror(vm, e.what());
1494     return SQ_ERROR;
1495   } catch(...) {
1496     sq_throwerror(vm, _SC("Unexpected exception while executing function 'do_backflip'"));
1497     return SQ_ERROR;
1498   }
1499
1500 }
1501
1502 static SQInteger Player_do_jump_wrapper(HSQUIRRELVM vm)
1503 {
1504   SQUserPointer data;
1505   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1506     sq_throwerror(vm, _SC("'do_jump' called without instance"));
1507     return SQ_ERROR;
1508   }
1509   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1510   SQFloat arg0;
1511   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
1512     sq_throwerror(vm, _SC("Argument 1 not a float"));
1513     return SQ_ERROR;
1514   }
1515
1516   try {
1517     _this->do_jump(static_cast<float> (arg0));
1518
1519     return 0;
1520
1521   } catch(std::exception& e) {
1522     sq_throwerror(vm, e.what());
1523     return SQ_ERROR;
1524   } catch(...) {
1525     sq_throwerror(vm, _SC("Unexpected exception while executing function 'do_jump'"));
1526     return SQ_ERROR;
1527   }
1528
1529 }
1530
1531 static SQInteger Player_trigger_sequence_wrapper(HSQUIRRELVM vm)
1532 {
1533   SQUserPointer data;
1534   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1535     sq_throwerror(vm, _SC("'trigger_sequence' called without instance"));
1536     return SQ_ERROR;
1537   }
1538   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1539   const SQChar* arg0;
1540   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1541     sq_throwerror(vm, _SC("Argument 1 not a string"));
1542     return SQ_ERROR;
1543   }
1544
1545   try {
1546     _this->trigger_sequence(arg0);
1547
1548     return 0;
1549
1550   } catch(std::exception& e) {
1551     sq_throwerror(vm, e.what());
1552     return SQ_ERROR;
1553   } catch(...) {
1554     sq_throwerror(vm, _SC("Unexpected exception while executing function 'trigger_sequence'"));
1555     return SQ_ERROR;
1556   }
1557
1558 }
1559
1560 static SQInteger Player_use_scripting_controller_wrapper(HSQUIRRELVM vm)
1561 {
1562   SQUserPointer data;
1563   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1564     sq_throwerror(vm, _SC("'use_scripting_controller' called without instance"));
1565     return SQ_ERROR;
1566   }
1567   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1568   SQBool arg0;
1569   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1570     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1571     return SQ_ERROR;
1572   }
1573
1574   try {
1575     _this->use_scripting_controller(arg0 == SQTrue);
1576
1577     return 0;
1578
1579   } catch(std::exception& e) {
1580     sq_throwerror(vm, e.what());
1581     return SQ_ERROR;
1582   } catch(...) {
1583     sq_throwerror(vm, _SC("Unexpected exception while executing function 'use_scripting_controller'"));
1584     return SQ_ERROR;
1585   }
1586
1587 }
1588
1589 static SQInteger Player_do_scripting_controller_wrapper(HSQUIRRELVM vm)
1590 {
1591   SQUserPointer data;
1592   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1593     sq_throwerror(vm, _SC("'do_scripting_controller' called without instance"));
1594     return SQ_ERROR;
1595   }
1596   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1597   const SQChar* arg0;
1598   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1599     sq_throwerror(vm, _SC("Argument 1 not a string"));
1600     return SQ_ERROR;
1601   }
1602   SQBool arg1;
1603   if(SQ_FAILED(sq_getbool(vm, 3, &arg1))) {
1604     sq_throwerror(vm, _SC("Argument 2 not a bool"));
1605     return SQ_ERROR;
1606   }
1607
1608   try {
1609     _this->do_scripting_controller(arg0, arg1 == SQTrue);
1610
1611     return 0;
1612
1613   } catch(std::exception& e) {
1614     sq_throwerror(vm, e.what());
1615     return SQ_ERROR;
1616   } catch(...) {
1617     sq_throwerror(vm, _SC("Unexpected exception while executing function 'do_scripting_controller'"));
1618     return SQ_ERROR;
1619   }
1620
1621 }
1622
1623 static SQInteger ScriptedObject_release_hook(SQUserPointer ptr, SQInteger )
1624 {
1625   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (ptr);
1626   delete _this;
1627   return 0;
1628 }
1629
1630 static SQInteger ScriptedObject_set_action_wrapper(HSQUIRRELVM vm)
1631 {
1632   SQUserPointer data;
1633   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1634     sq_throwerror(vm, _SC("'set_action' called without instance"));
1635     return SQ_ERROR;
1636   }
1637   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
1638   const SQChar* arg0;
1639   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1640     sq_throwerror(vm, _SC("Argument 1 not a string"));
1641     return SQ_ERROR;
1642   }
1643
1644   try {
1645     _this->set_action(arg0);
1646
1647     return 0;
1648
1649   } catch(std::exception& e) {
1650     sq_throwerror(vm, e.what());
1651     return SQ_ERROR;
1652   } catch(...) {
1653     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_action'"));
1654     return SQ_ERROR;
1655   }
1656
1657 }
1658
1659 static SQInteger ScriptedObject_get_action_wrapper(HSQUIRRELVM vm)
1660 {
1661   SQUserPointer data;
1662   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1663     sq_throwerror(vm, _SC("'get_action' called without instance"));
1664     return SQ_ERROR;
1665   }
1666   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
1667
1668   try {
1669     std::string return_value = _this->get_action();
1670
1671     sq_pushstring(vm, return_value.c_str(), return_value.size());
1672     return 1;
1673
1674   } catch(std::exception& e) {
1675     sq_throwerror(vm, e.what());
1676     return SQ_ERROR;
1677   } catch(...) {
1678     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_action'"));
1679     return SQ_ERROR;
1680   }
1681
1682 }
1683
1684 static SQInteger ScriptedObject_move_wrapper(HSQUIRRELVM vm)
1685 {
1686   SQUserPointer data;
1687   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1688     sq_throwerror(vm, _SC("'move' called without instance"));
1689     return SQ_ERROR;
1690   }
1691   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
1692   SQFloat arg0;
1693   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
1694     sq_throwerror(vm, _SC("Argument 1 not a float"));
1695     return SQ_ERROR;
1696   }
1697   SQFloat arg1;
1698   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
1699     sq_throwerror(vm, _SC("Argument 2 not a float"));
1700     return SQ_ERROR;
1701   }
1702
1703   try {
1704     _this->move(static_cast<float> (arg0), static_cast<float> (arg1));
1705
1706     return 0;
1707
1708   } catch(std::exception& e) {
1709     sq_throwerror(vm, e.what());
1710     return SQ_ERROR;
1711   } catch(...) {
1712     sq_throwerror(vm, _SC("Unexpected exception while executing function 'move'"));
1713     return SQ_ERROR;
1714   }
1715
1716 }
1717
1718 static SQInteger ScriptedObject_set_pos_wrapper(HSQUIRRELVM vm)
1719 {
1720   SQUserPointer data;
1721   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1722     sq_throwerror(vm, _SC("'set_pos' called without instance"));
1723     return SQ_ERROR;
1724   }
1725   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
1726   SQFloat arg0;
1727   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
1728     sq_throwerror(vm, _SC("Argument 1 not a float"));
1729     return SQ_ERROR;
1730   }
1731   SQFloat arg1;
1732   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
1733     sq_throwerror(vm, _SC("Argument 2 not a float"));
1734     return SQ_ERROR;
1735   }
1736
1737   try {
1738     _this->set_pos(static_cast<float> (arg0), static_cast<float> (arg1));
1739
1740     return 0;
1741
1742   } catch(std::exception& e) {
1743     sq_throwerror(vm, e.what());
1744     return SQ_ERROR;
1745   } catch(...) {
1746     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_pos'"));
1747     return SQ_ERROR;
1748   }
1749
1750 }
1751
1752 static SQInteger ScriptedObject_get_pos_x_wrapper(HSQUIRRELVM vm)
1753 {
1754   SQUserPointer data;
1755   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1756     sq_throwerror(vm, _SC("'get_pos_x' called without instance"));
1757     return SQ_ERROR;
1758   }
1759   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
1760
1761   try {
1762     float return_value = _this->get_pos_x();
1763
1764     sq_pushfloat(vm, return_value);
1765     return 1;
1766
1767   } catch(std::exception& e) {
1768     sq_throwerror(vm, e.what());
1769     return SQ_ERROR;
1770   } catch(...) {
1771     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_x'"));
1772     return SQ_ERROR;
1773   }
1774
1775 }
1776
1777 static SQInteger ScriptedObject_get_pos_y_wrapper(HSQUIRRELVM vm)
1778 {
1779   SQUserPointer data;
1780   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1781     sq_throwerror(vm, _SC("'get_pos_y' called without instance"));
1782     return SQ_ERROR;
1783   }
1784   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
1785
1786   try {
1787     float return_value = _this->get_pos_y();
1788
1789     sq_pushfloat(vm, return_value);
1790     return 1;
1791
1792   } catch(std::exception& e) {
1793     sq_throwerror(vm, e.what());
1794     return SQ_ERROR;
1795   } catch(...) {
1796     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_y'"));
1797     return SQ_ERROR;
1798   }
1799
1800 }
1801
1802 static SQInteger ScriptedObject_set_velocity_wrapper(HSQUIRRELVM vm)
1803 {
1804   SQUserPointer data;
1805   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1806     sq_throwerror(vm, _SC("'set_velocity' called without instance"));
1807     return SQ_ERROR;
1808   }
1809   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
1810   SQFloat arg0;
1811   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
1812     sq_throwerror(vm, _SC("Argument 1 not a float"));
1813     return SQ_ERROR;
1814   }
1815   SQFloat arg1;
1816   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
1817     sq_throwerror(vm, _SC("Argument 2 not a float"));
1818     return SQ_ERROR;
1819   }
1820
1821   try {
1822     _this->set_velocity(static_cast<float> (arg0), static_cast<float> (arg1));
1823
1824     return 0;
1825
1826   } catch(std::exception& e) {
1827     sq_throwerror(vm, e.what());
1828     return SQ_ERROR;
1829   } catch(...) {
1830     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_velocity'"));
1831     return SQ_ERROR;
1832   }
1833
1834 }
1835
1836 static SQInteger ScriptedObject_get_velocity_x_wrapper(HSQUIRRELVM vm)
1837 {
1838   SQUserPointer data;
1839   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1840     sq_throwerror(vm, _SC("'get_velocity_x' called without instance"));
1841     return SQ_ERROR;
1842   }
1843   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
1844
1845   try {
1846     float return_value = _this->get_velocity_x();
1847
1848     sq_pushfloat(vm, return_value);
1849     return 1;
1850
1851   } catch(std::exception& e) {
1852     sq_throwerror(vm, e.what());
1853     return SQ_ERROR;
1854   } catch(...) {
1855     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_velocity_x'"));
1856     return SQ_ERROR;
1857   }
1858
1859 }
1860
1861 static SQInteger ScriptedObject_get_velocity_y_wrapper(HSQUIRRELVM vm)
1862 {
1863   SQUserPointer data;
1864   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1865     sq_throwerror(vm, _SC("'get_velocity_y' called without instance"));
1866     return SQ_ERROR;
1867   }
1868   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
1869
1870   try {
1871     float return_value = _this->get_velocity_y();
1872
1873     sq_pushfloat(vm, return_value);
1874     return 1;
1875
1876   } catch(std::exception& e) {
1877     sq_throwerror(vm, e.what());
1878     return SQ_ERROR;
1879   } catch(...) {
1880     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_velocity_y'"));
1881     return SQ_ERROR;
1882   }
1883
1884 }
1885
1886 static SQInteger ScriptedObject_set_visible_wrapper(HSQUIRRELVM vm)
1887 {
1888   SQUserPointer data;
1889   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1890     sq_throwerror(vm, _SC("'set_visible' called without instance"));
1891     return SQ_ERROR;
1892   }
1893   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
1894   SQBool arg0;
1895   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1896     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1897     return SQ_ERROR;
1898   }
1899
1900   try {
1901     _this->set_visible(arg0 == SQTrue);
1902
1903     return 0;
1904
1905   } catch(std::exception& e) {
1906     sq_throwerror(vm, e.what());
1907     return SQ_ERROR;
1908   } catch(...) {
1909     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_visible'"));
1910     return SQ_ERROR;
1911   }
1912
1913 }
1914
1915 static SQInteger ScriptedObject_is_visible_wrapper(HSQUIRRELVM vm)
1916 {
1917   SQUserPointer data;
1918   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1919     sq_throwerror(vm, _SC("'is_visible' called without instance"));
1920     return SQ_ERROR;
1921   }
1922   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
1923
1924   try {
1925     bool return_value = _this->is_visible();
1926
1927     sq_pushbool(vm, return_value);
1928     return 1;
1929
1930   } catch(std::exception& e) {
1931     sq_throwerror(vm, e.what());
1932     return SQ_ERROR;
1933   } catch(...) {
1934     sq_throwerror(vm, _SC("Unexpected exception while executing function 'is_visible'"));
1935     return SQ_ERROR;
1936   }
1937
1938 }
1939
1940 static SQInteger ScriptedObject_set_solid_wrapper(HSQUIRRELVM vm)
1941 {
1942   SQUserPointer data;
1943   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1944     sq_throwerror(vm, _SC("'set_solid' called without instance"));
1945     return SQ_ERROR;
1946   }
1947   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
1948   SQBool arg0;
1949   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1950     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1951     return SQ_ERROR;
1952   }
1953
1954   try {
1955     _this->set_solid(arg0 == SQTrue);
1956
1957     return 0;
1958
1959   } catch(std::exception& e) {
1960     sq_throwerror(vm, e.what());
1961     return SQ_ERROR;
1962   } catch(...) {
1963     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_solid'"));
1964     return SQ_ERROR;
1965   }
1966
1967 }
1968
1969 static SQInteger ScriptedObject_is_solid_wrapper(HSQUIRRELVM vm)
1970 {
1971   SQUserPointer data;
1972   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1973     sq_throwerror(vm, _SC("'is_solid' called without instance"));
1974     return SQ_ERROR;
1975   }
1976   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
1977
1978   try {
1979     bool return_value = _this->is_solid();
1980
1981     sq_pushbool(vm, return_value);
1982     return 1;
1983
1984   } catch(std::exception& e) {
1985     sq_throwerror(vm, e.what());
1986     return SQ_ERROR;
1987   } catch(...) {
1988     sq_throwerror(vm, _SC("Unexpected exception while executing function 'is_solid'"));
1989     return SQ_ERROR;
1990   }
1991
1992 }
1993
1994 static SQInteger ScriptedObject_get_name_wrapper(HSQUIRRELVM vm)
1995 {
1996   SQUserPointer data;
1997   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
1998     sq_throwerror(vm, _SC("'get_name' called without instance"));
1999     return SQ_ERROR;
2000   }
2001   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
2002
2003   try {
2004     std::string return_value = _this->get_name();
2005
2006     sq_pushstring(vm, return_value.c_str(), return_value.size());
2007     return 1;
2008
2009   } catch(std::exception& e) {
2010     sq_throwerror(vm, e.what());
2011     return SQ_ERROR;
2012   } catch(...) {
2013     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_name'"));
2014     return SQ_ERROR;
2015   }
2016
2017 }
2018
2019 static SQInteger SSector_release_hook(SQUserPointer ptr, SQInteger )
2020 {
2021   Scripting::SSector* _this = reinterpret_cast<Scripting::SSector*> (ptr);
2022   delete _this;
2023   return 0;
2024 }
2025
2026 static SQInteger SSector_set_ambient_light_wrapper(HSQUIRRELVM vm)
2027 {
2028   SQUserPointer data;
2029   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2030     sq_throwerror(vm, _SC("'set_ambient_light' called without instance"));
2031     return SQ_ERROR;
2032   }
2033   Scripting::SSector* _this = reinterpret_cast<Scripting::SSector*> (data);
2034   SQFloat arg0;
2035   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
2036     sq_throwerror(vm, _SC("Argument 1 not a float"));
2037     return SQ_ERROR;
2038   }
2039   SQFloat arg1;
2040   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
2041     sq_throwerror(vm, _SC("Argument 2 not a float"));
2042     return SQ_ERROR;
2043   }
2044   SQFloat arg2;
2045   if(SQ_FAILED(sq_getfloat(vm, 4, &arg2))) {
2046     sq_throwerror(vm, _SC("Argument 3 not a float"));
2047     return SQ_ERROR;
2048   }
2049
2050   try {
2051     _this->set_ambient_light(static_cast<float> (arg0), static_cast<float> (arg1), static_cast<float> (arg2));
2052
2053     return 0;
2054
2055   } catch(std::exception& e) {
2056     sq_throwerror(vm, e.what());
2057     return SQ_ERROR;
2058   } catch(...) {
2059     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_ambient_light'"));
2060     return SQ_ERROR;
2061   }
2062
2063 }
2064
2065 static SQInteger SSector_get_ambient_red_wrapper(HSQUIRRELVM vm)
2066 {
2067   SQUserPointer data;
2068   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2069     sq_throwerror(vm, _SC("'get_ambient_red' called without instance"));
2070     return SQ_ERROR;
2071   }
2072   Scripting::SSector* _this = reinterpret_cast<Scripting::SSector*> (data);
2073
2074   try {
2075     float return_value = _this->get_ambient_red();
2076
2077     sq_pushfloat(vm, return_value);
2078     return 1;
2079
2080   } catch(std::exception& e) {
2081     sq_throwerror(vm, e.what());
2082     return SQ_ERROR;
2083   } catch(...) {
2084     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_ambient_red'"));
2085     return SQ_ERROR;
2086   }
2087
2088 }
2089
2090 static SQInteger SSector_get_ambient_green_wrapper(HSQUIRRELVM vm)
2091 {
2092   SQUserPointer data;
2093   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2094     sq_throwerror(vm, _SC("'get_ambient_green' called without instance"));
2095     return SQ_ERROR;
2096   }
2097   Scripting::SSector* _this = reinterpret_cast<Scripting::SSector*> (data);
2098
2099   try {
2100     float return_value = _this->get_ambient_green();
2101
2102     sq_pushfloat(vm, return_value);
2103     return 1;
2104
2105   } catch(std::exception& e) {
2106     sq_throwerror(vm, e.what());
2107     return SQ_ERROR;
2108   } catch(...) {
2109     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_ambient_green'"));
2110     return SQ_ERROR;
2111   }
2112
2113 }
2114
2115 static SQInteger SSector_get_ambient_blue_wrapper(HSQUIRRELVM vm)
2116 {
2117   SQUserPointer data;
2118   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2119     sq_throwerror(vm, _SC("'get_ambient_blue' called without instance"));
2120     return SQ_ERROR;
2121   }
2122   Scripting::SSector* _this = reinterpret_cast<Scripting::SSector*> (data);
2123
2124   try {
2125     float return_value = _this->get_ambient_blue();
2126
2127     sq_pushfloat(vm, return_value);
2128     return 1;
2129
2130   } catch(std::exception& e) {
2131     sq_throwerror(vm, e.what());
2132     return SQ_ERROR;
2133   } catch(...) {
2134     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_ambient_blue'"));
2135     return SQ_ERROR;
2136   }
2137
2138 }
2139
2140 static SQInteger SSector_set_gravity_wrapper(HSQUIRRELVM vm)
2141 {
2142   SQUserPointer data;
2143   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2144     sq_throwerror(vm, _SC("'set_gravity' called without instance"));
2145     return SQ_ERROR;
2146   }
2147   Scripting::SSector* _this = reinterpret_cast<Scripting::SSector*> (data);
2148   SQFloat arg0;
2149   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
2150     sq_throwerror(vm, _SC("Argument 1 not a float"));
2151     return SQ_ERROR;
2152   }
2153
2154   try {
2155     _this->set_gravity(static_cast<float> (arg0));
2156
2157     return 0;
2158
2159   } catch(std::exception& e) {
2160     sq_throwerror(vm, e.what());
2161     return SQ_ERROR;
2162   } catch(...) {
2163     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_gravity'"));
2164     return SQ_ERROR;
2165   }
2166
2167 }
2168
2169 static SQInteger Text_release_hook(SQUserPointer ptr, SQInteger )
2170 {
2171   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (ptr);
2172   delete _this;
2173   return 0;
2174 }
2175
2176 static SQInteger Text_set_text_wrapper(HSQUIRRELVM vm)
2177 {
2178   SQUserPointer data;
2179   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2180     sq_throwerror(vm, _SC("'set_text' called without instance"));
2181     return SQ_ERROR;
2182   }
2183   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
2184   const SQChar* arg0;
2185   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2186     sq_throwerror(vm, _SC("Argument 1 not a string"));
2187     return SQ_ERROR;
2188   }
2189
2190   try {
2191     _this->set_text(arg0);
2192
2193     return 0;
2194
2195   } catch(std::exception& e) {
2196     sq_throwerror(vm, e.what());
2197     return SQ_ERROR;
2198   } catch(...) {
2199     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_text'"));
2200     return SQ_ERROR;
2201   }
2202
2203 }
2204
2205 static SQInteger Text_set_font_wrapper(HSQUIRRELVM vm)
2206 {
2207   SQUserPointer data;
2208   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2209     sq_throwerror(vm, _SC("'set_font' called without instance"));
2210     return SQ_ERROR;
2211   }
2212   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
2213   const SQChar* arg0;
2214   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2215     sq_throwerror(vm, _SC("Argument 1 not a string"));
2216     return SQ_ERROR;
2217   }
2218
2219   try {
2220     _this->set_font(arg0);
2221
2222     return 0;
2223
2224   } catch(std::exception& e) {
2225     sq_throwerror(vm, e.what());
2226     return SQ_ERROR;
2227   } catch(...) {
2228     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_font'"));
2229     return SQ_ERROR;
2230   }
2231
2232 }
2233
2234 static SQInteger Text_fade_in_wrapper(HSQUIRRELVM vm)
2235 {
2236   SQUserPointer data;
2237   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2238     sq_throwerror(vm, _SC("'fade_in' called without instance"));
2239     return SQ_ERROR;
2240   }
2241   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
2242   SQFloat arg0;
2243   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
2244     sq_throwerror(vm, _SC("Argument 1 not a float"));
2245     return SQ_ERROR;
2246   }
2247
2248   try {
2249     _this->fade_in(static_cast<float> (arg0));
2250
2251     return 0;
2252
2253   } catch(std::exception& e) {
2254     sq_throwerror(vm, e.what());
2255     return SQ_ERROR;
2256   } catch(...) {
2257     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fade_in'"));
2258     return SQ_ERROR;
2259   }
2260
2261 }
2262
2263 static SQInteger Text_fade_out_wrapper(HSQUIRRELVM vm)
2264 {
2265   SQUserPointer data;
2266   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2267     sq_throwerror(vm, _SC("'fade_out' called without instance"));
2268     return SQ_ERROR;
2269   }
2270   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
2271   SQFloat arg0;
2272   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
2273     sq_throwerror(vm, _SC("Argument 1 not a float"));
2274     return SQ_ERROR;
2275   }
2276
2277   try {
2278     _this->fade_out(static_cast<float> (arg0));
2279
2280     return 0;
2281
2282   } catch(std::exception& e) {
2283     sq_throwerror(vm, e.what());
2284     return SQ_ERROR;
2285   } catch(...) {
2286     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fade_out'"));
2287     return SQ_ERROR;
2288   }
2289
2290 }
2291
2292 static SQInteger Text_set_visible_wrapper(HSQUIRRELVM vm)
2293 {
2294   SQUserPointer data;
2295   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2296     sq_throwerror(vm, _SC("'set_visible' called without instance"));
2297     return SQ_ERROR;
2298   }
2299   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
2300   SQBool arg0;
2301   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
2302     sq_throwerror(vm, _SC("Argument 1 not a bool"));
2303     return SQ_ERROR;
2304   }
2305
2306   try {
2307     _this->set_visible(arg0 == SQTrue);
2308
2309     return 0;
2310
2311   } catch(std::exception& e) {
2312     sq_throwerror(vm, e.what());
2313     return SQ_ERROR;
2314   } catch(...) {
2315     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_visible'"));
2316     return SQ_ERROR;
2317   }
2318
2319 }
2320
2321 static SQInteger Text_set_centered_wrapper(HSQUIRRELVM vm)
2322 {
2323   SQUserPointer data;
2324   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2325     sq_throwerror(vm, _SC("'set_centered' called without instance"));
2326     return SQ_ERROR;
2327   }
2328   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
2329   SQBool arg0;
2330   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
2331     sq_throwerror(vm, _SC("Argument 1 not a bool"));
2332     return SQ_ERROR;
2333   }
2334
2335   try {
2336     _this->set_centered(arg0 == SQTrue);
2337
2338     return 0;
2339
2340   } catch(std::exception& e) {
2341     sq_throwerror(vm, e.what());
2342     return SQ_ERROR;
2343   } catch(...) {
2344     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_centered'"));
2345     return SQ_ERROR;
2346   }
2347
2348 }
2349
2350 static SQInteger Text_set_pos_wrapper(HSQUIRRELVM vm)
2351 {
2352   SQUserPointer data;
2353   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2354     sq_throwerror(vm, _SC("'set_pos' called without instance"));
2355     return SQ_ERROR;
2356   }
2357   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
2358   SQFloat arg0;
2359   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
2360     sq_throwerror(vm, _SC("Argument 1 not a float"));
2361     return SQ_ERROR;
2362   }
2363   SQFloat arg1;
2364   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
2365     sq_throwerror(vm, _SC("Argument 2 not a float"));
2366     return SQ_ERROR;
2367   }
2368
2369   try {
2370     _this->set_pos(static_cast<float> (arg0), static_cast<float> (arg1));
2371
2372     return 0;
2373
2374   } catch(std::exception& e) {
2375     sq_throwerror(vm, e.what());
2376     return SQ_ERROR;
2377   } catch(...) {
2378     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_pos'"));
2379     return SQ_ERROR;
2380   }
2381
2382 }
2383
2384 static SQInteger Text_get_pos_x_wrapper(HSQUIRRELVM vm)
2385 {
2386   SQUserPointer data;
2387   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2388     sq_throwerror(vm, _SC("'get_pos_x' called without instance"));
2389     return SQ_ERROR;
2390   }
2391   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
2392
2393   try {
2394     float return_value = _this->get_pos_x();
2395
2396     sq_pushfloat(vm, return_value);
2397     return 1;
2398
2399   } catch(std::exception& e) {
2400     sq_throwerror(vm, e.what());
2401     return SQ_ERROR;
2402   } catch(...) {
2403     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_x'"));
2404     return SQ_ERROR;
2405   }
2406
2407 }
2408
2409 static SQInteger Text_get_pos_y_wrapper(HSQUIRRELVM vm)
2410 {
2411   SQUserPointer data;
2412   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2413     sq_throwerror(vm, _SC("'get_pos_y' called without instance"));
2414     return SQ_ERROR;
2415   }
2416   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
2417
2418   try {
2419     float return_value = _this->get_pos_y();
2420
2421     sq_pushfloat(vm, return_value);
2422     return 1;
2423
2424   } catch(std::exception& e) {
2425     sq_throwerror(vm, e.what());
2426     return SQ_ERROR;
2427   } catch(...) {
2428     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_y'"));
2429     return SQ_ERROR;
2430   }
2431
2432 }
2433
2434 static SQInteger Text_set_anchor_point_wrapper(HSQUIRRELVM vm)
2435 {
2436   SQUserPointer data;
2437   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2438     sq_throwerror(vm, _SC("'set_anchor_point' called without instance"));
2439     return SQ_ERROR;
2440   }
2441   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
2442   SQInteger arg0;
2443   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
2444     sq_throwerror(vm, _SC("Argument 1 not an integer"));
2445     return SQ_ERROR;
2446   }
2447
2448   try {
2449     _this->set_anchor_point(static_cast<int> (arg0));
2450
2451     return 0;
2452
2453   } catch(std::exception& e) {
2454     sq_throwerror(vm, e.what());
2455     return SQ_ERROR;
2456   } catch(...) {
2457     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_anchor_point'"));
2458     return SQ_ERROR;
2459   }
2460
2461 }
2462
2463 static SQInteger Text_get_anchor_point_wrapper(HSQUIRRELVM vm)
2464 {
2465   SQUserPointer data;
2466   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2467     sq_throwerror(vm, _SC("'get_anchor_point' called without instance"));
2468     return SQ_ERROR;
2469   }
2470   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
2471
2472   try {
2473     int return_value = _this->get_anchor_point();
2474
2475     sq_pushinteger(vm, return_value);
2476     return 1;
2477
2478   } catch(std::exception& e) {
2479     sq_throwerror(vm, e.what());
2480     return SQ_ERROR;
2481   } catch(...) {
2482     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_anchor_point'"));
2483     return SQ_ERROR;
2484   }
2485
2486 }
2487
2488 static SQInteger Thunderstorm_release_hook(SQUserPointer ptr, SQInteger )
2489 {
2490   Scripting::Thunderstorm* _this = reinterpret_cast<Scripting::Thunderstorm*> (ptr);
2491   delete _this;
2492   return 0;
2493 }
2494
2495 static SQInteger Thunderstorm_start_wrapper(HSQUIRRELVM vm)
2496 {
2497   SQUserPointer data;
2498   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2499     sq_throwerror(vm, _SC("'start' called without instance"));
2500     return SQ_ERROR;
2501   }
2502   Scripting::Thunderstorm* _this = reinterpret_cast<Scripting::Thunderstorm*> (data);
2503
2504   try {
2505     _this->start();
2506
2507     return 0;
2508
2509   } catch(std::exception& e) {
2510     sq_throwerror(vm, e.what());
2511     return SQ_ERROR;
2512   } catch(...) {
2513     sq_throwerror(vm, _SC("Unexpected exception while executing function 'start'"));
2514     return SQ_ERROR;
2515   }
2516
2517 }
2518
2519 static SQInteger Thunderstorm_stop_wrapper(HSQUIRRELVM vm)
2520 {
2521   SQUserPointer data;
2522   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2523     sq_throwerror(vm, _SC("'stop' called without instance"));
2524     return SQ_ERROR;
2525   }
2526   Scripting::Thunderstorm* _this = reinterpret_cast<Scripting::Thunderstorm*> (data);
2527
2528   try {
2529     _this->stop();
2530
2531     return 0;
2532
2533   } catch(std::exception& e) {
2534     sq_throwerror(vm, e.what());
2535     return SQ_ERROR;
2536   } catch(...) {
2537     sq_throwerror(vm, _SC("Unexpected exception while executing function 'stop'"));
2538     return SQ_ERROR;
2539   }
2540
2541 }
2542
2543 static SQInteger Thunderstorm_thunder_wrapper(HSQUIRRELVM vm)
2544 {
2545   SQUserPointer data;
2546   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2547     sq_throwerror(vm, _SC("'thunder' called without instance"));
2548     return SQ_ERROR;
2549   }
2550   Scripting::Thunderstorm* _this = reinterpret_cast<Scripting::Thunderstorm*> (data);
2551
2552   try {
2553     _this->thunder();
2554
2555     return 0;
2556
2557   } catch(std::exception& e) {
2558     sq_throwerror(vm, e.what());
2559     return SQ_ERROR;
2560   } catch(...) {
2561     sq_throwerror(vm, _SC("Unexpected exception while executing function 'thunder'"));
2562     return SQ_ERROR;
2563   }
2564
2565 }
2566
2567 static SQInteger Thunderstorm_lightning_wrapper(HSQUIRRELVM vm)
2568 {
2569   SQUserPointer data;
2570   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2571     sq_throwerror(vm, _SC("'lightning' called without instance"));
2572     return SQ_ERROR;
2573   }
2574   Scripting::Thunderstorm* _this = reinterpret_cast<Scripting::Thunderstorm*> (data);
2575
2576   try {
2577     _this->lightning();
2578
2579     return 0;
2580
2581   } catch(std::exception& e) {
2582     sq_throwerror(vm, e.what());
2583     return SQ_ERROR;
2584   } catch(...) {
2585     sq_throwerror(vm, _SC("Unexpected exception while executing function 'lightning'"));
2586     return SQ_ERROR;
2587   }
2588
2589 }
2590
2591 static SQInteger Thunderstorm_flash_wrapper(HSQUIRRELVM vm)
2592 {
2593   SQUserPointer data;
2594   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2595     sq_throwerror(vm, _SC("'flash' called without instance"));
2596     return SQ_ERROR;
2597   }
2598   Scripting::Thunderstorm* _this = reinterpret_cast<Scripting::Thunderstorm*> (data);
2599
2600   try {
2601     _this->flash();
2602
2603     return 0;
2604
2605   } catch(std::exception& e) {
2606     sq_throwerror(vm, e.what());
2607     return SQ_ERROR;
2608   } catch(...) {
2609     sq_throwerror(vm, _SC("Unexpected exception while executing function 'flash'"));
2610     return SQ_ERROR;
2611   }
2612
2613 }
2614
2615 static SQInteger Thunderstorm_electrify_wrapper(HSQUIRRELVM vm)
2616 {
2617   SQUserPointer data;
2618   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2619     sq_throwerror(vm, _SC("'electrify' called without instance"));
2620     return SQ_ERROR;
2621   }
2622   Scripting::Thunderstorm* _this = reinterpret_cast<Scripting::Thunderstorm*> (data);
2623
2624   try {
2625     _this->electrify();
2626
2627     return 0;
2628
2629   } catch(std::exception& e) {
2630     sq_throwerror(vm, e.what());
2631     return SQ_ERROR;
2632   } catch(...) {
2633     sq_throwerror(vm, _SC("Unexpected exception while executing function 'electrify'"));
2634     return SQ_ERROR;
2635   }
2636
2637 }
2638
2639 static SQInteger TileMap_release_hook(SQUserPointer ptr, SQInteger )
2640 {
2641   Scripting::TileMap* _this = reinterpret_cast<Scripting::TileMap*> (ptr);
2642   delete _this;
2643   return 0;
2644 }
2645
2646 static SQInteger TileMap_goto_node_wrapper(HSQUIRRELVM vm)
2647 {
2648   SQUserPointer data;
2649   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2650     sq_throwerror(vm, _SC("'goto_node' called without instance"));
2651     return SQ_ERROR;
2652   }
2653   Scripting::TileMap* _this = reinterpret_cast<Scripting::TileMap*> (data);
2654   SQInteger arg0;
2655   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
2656     sq_throwerror(vm, _SC("Argument 1 not an integer"));
2657     return SQ_ERROR;
2658   }
2659
2660   try {
2661     _this->goto_node(static_cast<int> (arg0));
2662
2663     return 0;
2664
2665   } catch(std::exception& e) {
2666     sq_throwerror(vm, e.what());
2667     return SQ_ERROR;
2668   } catch(...) {
2669     sq_throwerror(vm, _SC("Unexpected exception while executing function 'goto_node'"));
2670     return SQ_ERROR;
2671   }
2672
2673 }
2674
2675 static SQInteger TileMap_start_moving_wrapper(HSQUIRRELVM vm)
2676 {
2677   SQUserPointer data;
2678   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2679     sq_throwerror(vm, _SC("'start_moving' called without instance"));
2680     return SQ_ERROR;
2681   }
2682   Scripting::TileMap* _this = reinterpret_cast<Scripting::TileMap*> (data);
2683
2684   try {
2685     _this->start_moving();
2686
2687     return 0;
2688
2689   } catch(std::exception& e) {
2690     sq_throwerror(vm, e.what());
2691     return SQ_ERROR;
2692   } catch(...) {
2693     sq_throwerror(vm, _SC("Unexpected exception while executing function 'start_moving'"));
2694     return SQ_ERROR;
2695   }
2696
2697 }
2698
2699 static SQInteger TileMap_stop_moving_wrapper(HSQUIRRELVM vm)
2700 {
2701   SQUserPointer data;
2702   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2703     sq_throwerror(vm, _SC("'stop_moving' called without instance"));
2704     return SQ_ERROR;
2705   }
2706   Scripting::TileMap* _this = reinterpret_cast<Scripting::TileMap*> (data);
2707
2708   try {
2709     _this->stop_moving();
2710
2711     return 0;
2712
2713   } catch(std::exception& e) {
2714     sq_throwerror(vm, e.what());
2715     return SQ_ERROR;
2716   } catch(...) {
2717     sq_throwerror(vm, _SC("Unexpected exception while executing function 'stop_moving'"));
2718     return SQ_ERROR;
2719   }
2720
2721 }
2722
2723 static SQInteger TileMap_fade_wrapper(HSQUIRRELVM vm)
2724 {
2725   SQUserPointer data;
2726   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2727     sq_throwerror(vm, _SC("'fade' called without instance"));
2728     return SQ_ERROR;
2729   }
2730   Scripting::TileMap* _this = reinterpret_cast<Scripting::TileMap*> (data);
2731   SQFloat arg0;
2732   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
2733     sq_throwerror(vm, _SC("Argument 1 not a float"));
2734     return SQ_ERROR;
2735   }
2736   SQFloat arg1;
2737   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
2738     sq_throwerror(vm, _SC("Argument 2 not a float"));
2739     return SQ_ERROR;
2740   }
2741
2742   try {
2743     _this->fade(static_cast<float> (arg0), static_cast<float> (arg1));
2744
2745     return 0;
2746
2747   } catch(std::exception& e) {
2748     sq_throwerror(vm, e.what());
2749     return SQ_ERROR;
2750   } catch(...) {
2751     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fade'"));
2752     return SQ_ERROR;
2753   }
2754
2755 }
2756
2757 static SQInteger TileMap_set_alpha_wrapper(HSQUIRRELVM vm)
2758 {
2759   SQUserPointer data;
2760   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2761     sq_throwerror(vm, _SC("'set_alpha' called without instance"));
2762     return SQ_ERROR;
2763   }
2764   Scripting::TileMap* _this = reinterpret_cast<Scripting::TileMap*> (data);
2765   SQFloat arg0;
2766   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
2767     sq_throwerror(vm, _SC("Argument 1 not a float"));
2768     return SQ_ERROR;
2769   }
2770
2771   try {
2772     _this->set_alpha(static_cast<float> (arg0));
2773
2774     return 0;
2775
2776   } catch(std::exception& e) {
2777     sq_throwerror(vm, e.what());
2778     return SQ_ERROR;
2779   } catch(...) {
2780     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_alpha'"));
2781     return SQ_ERROR;
2782   }
2783
2784 }
2785
2786 static SQInteger TileMap_get_alpha_wrapper(HSQUIRRELVM vm)
2787 {
2788   SQUserPointer data;
2789   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2790     sq_throwerror(vm, _SC("'get_alpha' called without instance"));
2791     return SQ_ERROR;
2792   }
2793   Scripting::TileMap* _this = reinterpret_cast<Scripting::TileMap*> (data);
2794
2795   try {
2796     float return_value = _this->get_alpha();
2797
2798     sq_pushfloat(vm, return_value);
2799     return 1;
2800
2801   } catch(std::exception& e) {
2802     sq_throwerror(vm, e.what());
2803     return SQ_ERROR;
2804   } catch(...) {
2805     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_alpha'"));
2806     return SQ_ERROR;
2807   }
2808
2809 }
2810
2811 static SQInteger WillOWisp_release_hook(SQUserPointer ptr, SQInteger )
2812 {
2813   Scripting::WillOWisp* _this = reinterpret_cast<Scripting::WillOWisp*> (ptr);
2814   delete _this;
2815   return 0;
2816 }
2817
2818 static SQInteger WillOWisp_goto_node_wrapper(HSQUIRRELVM vm)
2819 {
2820   SQUserPointer data;
2821   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2822     sq_throwerror(vm, _SC("'goto_node' called without instance"));
2823     return SQ_ERROR;
2824   }
2825   Scripting::WillOWisp* _this = reinterpret_cast<Scripting::WillOWisp*> (data);
2826   SQInteger arg0;
2827   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
2828     sq_throwerror(vm, _SC("Argument 1 not an integer"));
2829     return SQ_ERROR;
2830   }
2831
2832   try {
2833     _this->goto_node(static_cast<int> (arg0));
2834
2835     return 0;
2836
2837   } catch(std::exception& e) {
2838     sq_throwerror(vm, e.what());
2839     return SQ_ERROR;
2840   } catch(...) {
2841     sq_throwerror(vm, _SC("Unexpected exception while executing function 'goto_node'"));
2842     return SQ_ERROR;
2843   }
2844
2845 }
2846
2847 static SQInteger WillOWisp_set_state_wrapper(HSQUIRRELVM vm)
2848 {
2849   SQUserPointer data;
2850   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2851     sq_throwerror(vm, _SC("'set_state' called without instance"));
2852     return SQ_ERROR;
2853   }
2854   Scripting::WillOWisp* _this = reinterpret_cast<Scripting::WillOWisp*> (data);
2855   const SQChar* arg0;
2856   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2857     sq_throwerror(vm, _SC("Argument 1 not a string"));
2858     return SQ_ERROR;
2859   }
2860
2861   try {
2862     _this->set_state(arg0);
2863
2864     return 0;
2865
2866   } catch(std::exception& e) {
2867     sq_throwerror(vm, e.what());
2868     return SQ_ERROR;
2869   } catch(...) {
2870     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_state'"));
2871     return SQ_ERROR;
2872   }
2873
2874 }
2875
2876 static SQInteger WillOWisp_start_moving_wrapper(HSQUIRRELVM vm)
2877 {
2878   SQUserPointer data;
2879   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2880     sq_throwerror(vm, _SC("'start_moving' called without instance"));
2881     return SQ_ERROR;
2882   }
2883   Scripting::WillOWisp* _this = reinterpret_cast<Scripting::WillOWisp*> (data);
2884
2885   try {
2886     _this->start_moving();
2887
2888     return 0;
2889
2890   } catch(std::exception& e) {
2891     sq_throwerror(vm, e.what());
2892     return SQ_ERROR;
2893   } catch(...) {
2894     sq_throwerror(vm, _SC("Unexpected exception while executing function 'start_moving'"));
2895     return SQ_ERROR;
2896   }
2897
2898 }
2899
2900 static SQInteger WillOWisp_stop_moving_wrapper(HSQUIRRELVM vm)
2901 {
2902   SQUserPointer data;
2903   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2904     sq_throwerror(vm, _SC("'stop_moving' called without instance"));
2905     return SQ_ERROR;
2906   }
2907   Scripting::WillOWisp* _this = reinterpret_cast<Scripting::WillOWisp*> (data);
2908
2909   try {
2910     _this->stop_moving();
2911
2912     return 0;
2913
2914   } catch(std::exception& e) {
2915     sq_throwerror(vm, e.what());
2916     return SQ_ERROR;
2917   } catch(...) {
2918     sq_throwerror(vm, _SC("Unexpected exception while executing function 'stop_moving'"));
2919     return SQ_ERROR;
2920   }
2921
2922 }
2923
2924 static SQInteger Wind_release_hook(SQUserPointer ptr, SQInteger )
2925 {
2926   Scripting::Wind* _this = reinterpret_cast<Scripting::Wind*> (ptr);
2927   delete _this;
2928   return 0;
2929 }
2930
2931 static SQInteger Wind_start_wrapper(HSQUIRRELVM vm)
2932 {
2933   SQUserPointer data;
2934   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2935     sq_throwerror(vm, _SC("'start' called without instance"));
2936     return SQ_ERROR;
2937   }
2938   Scripting::Wind* _this = reinterpret_cast<Scripting::Wind*> (data);
2939
2940   try {
2941     _this->start();
2942
2943     return 0;
2944
2945   } catch(std::exception& e) {
2946     sq_throwerror(vm, e.what());
2947     return SQ_ERROR;
2948   } catch(...) {
2949     sq_throwerror(vm, _SC("Unexpected exception while executing function 'start'"));
2950     return SQ_ERROR;
2951   }
2952
2953 }
2954
2955 static SQInteger Wind_stop_wrapper(HSQUIRRELVM vm)
2956 {
2957   SQUserPointer data;
2958   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0)) || !data) {
2959     sq_throwerror(vm, _SC("'stop' called without instance"));
2960     return SQ_ERROR;
2961   }
2962   Scripting::Wind* _this = reinterpret_cast<Scripting::Wind*> (data);
2963
2964   try {
2965     _this->stop();
2966
2967     return 0;
2968
2969   } catch(std::exception& e) {
2970     sq_throwerror(vm, e.what());
2971     return SQ_ERROR;
2972   } catch(...) {
2973     sq_throwerror(vm, _SC("Unexpected exception while executing function 'stop'"));
2974     return SQ_ERROR;
2975   }
2976
2977 }
2978
2979 static SQInteger display_wrapper(HSQUIRRELVM vm)
2980 {
2981   return Scripting::display(vm);
2982 }
2983
2984 static SQInteger print_stacktrace_wrapper(HSQUIRRELVM vm)
2985 {
2986   HSQUIRRELVM arg0 = vm;
2987
2988   try {
2989     Scripting::print_stacktrace(arg0);
2990
2991     return 0;
2992
2993   } catch(std::exception& e) {
2994     sq_throwerror(vm, e.what());
2995     return SQ_ERROR;
2996   } catch(...) {
2997     sq_throwerror(vm, _SC("Unexpected exception while executing function 'print_stacktrace'"));
2998     return SQ_ERROR;
2999   }
3000
3001 }
3002
3003 static SQInteger get_current_thread_wrapper(HSQUIRRELVM vm)
3004 {
3005   return Scripting::get_current_thread(vm);
3006 }
3007
3008 static SQInteger display_text_file_wrapper(HSQUIRRELVM vm)
3009 {
3010   const SQChar* arg0;
3011   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
3012     sq_throwerror(vm, _SC("Argument 1 not a string"));
3013     return SQ_ERROR;
3014   }
3015
3016   try {
3017     Scripting::display_text_file(arg0);
3018
3019     return 0;
3020
3021   } catch(std::exception& e) {
3022     sq_throwerror(vm, e.what());
3023     return SQ_ERROR;
3024   } catch(...) {
3025     sq_throwerror(vm, _SC("Unexpected exception while executing function 'display_text_file'"));
3026     return SQ_ERROR;
3027   }
3028
3029 }
3030
3031 static SQInteger load_worldmap_wrapper(HSQUIRRELVM vm)
3032 {
3033   const SQChar* arg0;
3034   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
3035     sq_throwerror(vm, _SC("Argument 1 not a string"));
3036     return SQ_ERROR;
3037   }
3038
3039   try {
3040     Scripting::load_worldmap(arg0);
3041
3042     return 0;
3043
3044   } catch(std::exception& e) {
3045     sq_throwerror(vm, e.what());
3046     return SQ_ERROR;
3047   } catch(...) {
3048     sq_throwerror(vm, _SC("Unexpected exception while executing function 'load_worldmap'"));
3049     return SQ_ERROR;
3050   }
3051
3052 }
3053
3054 static SQInteger load_level_wrapper(HSQUIRRELVM vm)
3055 {
3056   const SQChar* arg0;
3057   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
3058     sq_throwerror(vm, _SC("Argument 1 not a string"));
3059     return SQ_ERROR;
3060   }
3061
3062   try {
3063     Scripting::load_level(arg0);
3064
3065     return 0;
3066
3067   } catch(std::exception& e) {
3068     sq_throwerror(vm, e.what());
3069     return SQ_ERROR;
3070   } catch(...) {
3071     sq_throwerror(vm, _SC("Unexpected exception while executing function 'load_level'"));
3072     return SQ_ERROR;
3073   }
3074
3075 }
3076
3077 static SQInteger wait_wrapper(HSQUIRRELVM vm)
3078 {
3079   HSQUIRRELVM arg0 = vm;
3080   SQFloat arg1;
3081   if(SQ_FAILED(sq_getfloat(vm, 2, &arg1))) {
3082     sq_throwerror(vm, _SC("Argument 1 not a float"));
3083     return SQ_ERROR;
3084   }
3085
3086   try {
3087     Scripting::wait(arg0, static_cast<float> (arg1));
3088
3089     return sq_suspendvm(vm);
3090
3091   } catch(std::exception& e) {
3092     sq_throwerror(vm, e.what());
3093     return SQ_ERROR;
3094   } catch(...) {
3095     sq_throwerror(vm, _SC("Unexpected exception while executing function 'wait'"));
3096     return SQ_ERROR;
3097   }
3098
3099 }
3100
3101 static SQInteger wait_for_screenswitch_wrapper(HSQUIRRELVM vm)
3102 {
3103   HSQUIRRELVM arg0 = vm;
3104
3105   try {
3106     Scripting::wait_for_screenswitch(arg0);
3107
3108     return sq_suspendvm(vm);
3109
3110   } catch(std::exception& e) {
3111     sq_throwerror(vm, e.what());
3112     return SQ_ERROR;
3113   } catch(...) {
3114     sq_throwerror(vm, _SC("Unexpected exception while executing function 'wait_for_screenswitch'"));
3115     return SQ_ERROR;
3116   }
3117
3118 }
3119
3120 static SQInteger exit_screen_wrapper(HSQUIRRELVM vm)
3121 {
3122   (void) vm;
3123
3124   try {
3125     Scripting::exit_screen();
3126
3127     return 0;
3128
3129   } catch(std::exception& e) {
3130     sq_throwerror(vm, e.what());
3131     return SQ_ERROR;
3132   } catch(...) {
3133     sq_throwerror(vm, _SC("Unexpected exception while executing function 'exit_screen'"));
3134     return SQ_ERROR;
3135   }
3136
3137 }
3138
3139 static SQInteger fadeout_screen_wrapper(HSQUIRRELVM vm)
3140 {
3141   SQFloat arg0;
3142   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
3143     sq_throwerror(vm, _SC("Argument 1 not a float"));
3144     return SQ_ERROR;
3145   }
3146
3147   try {
3148     Scripting::fadeout_screen(static_cast<float> (arg0));
3149
3150     return 0;
3151
3152   } catch(std::exception& e) {
3153     sq_throwerror(vm, e.what());
3154     return SQ_ERROR;
3155   } catch(...) {
3156     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fadeout_screen'"));
3157     return SQ_ERROR;
3158   }
3159
3160 }
3161
3162 static SQInteger shrink_screen_wrapper(HSQUIRRELVM vm)
3163 {
3164   SQFloat arg0;
3165   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
3166     sq_throwerror(vm, _SC("Argument 1 not a float"));
3167     return SQ_ERROR;
3168   }
3169   SQFloat arg1;
3170   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
3171     sq_throwerror(vm, _SC("Argument 2 not a float"));
3172     return SQ_ERROR;
3173   }
3174   SQFloat arg2;
3175   if(SQ_FAILED(sq_getfloat(vm, 4, &arg2))) {
3176     sq_throwerror(vm, _SC("Argument 3 not a float"));
3177     return SQ_ERROR;
3178   }
3179
3180   try {
3181     Scripting::shrink_screen(static_cast<float> (arg0), static_cast<float> (arg1), static_cast<float> (arg2));
3182
3183     return 0;
3184
3185   } catch(std::exception& e) {
3186     sq_throwerror(vm, e.what());
3187     return SQ_ERROR;
3188   } catch(...) {
3189     sq_throwerror(vm, _SC("Unexpected exception while executing function 'shrink_screen'"));
3190     return SQ_ERROR;
3191   }
3192
3193 }
3194
3195 static SQInteger abort_screenfade_wrapper(HSQUIRRELVM vm)
3196 {
3197   (void) vm;
3198
3199   try {
3200     Scripting::abort_screenfade();
3201
3202     return 0;
3203
3204   } catch(std::exception& e) {
3205     sq_throwerror(vm, e.what());
3206     return SQ_ERROR;
3207   } catch(...) {
3208     sq_throwerror(vm, _SC("Unexpected exception while executing function 'abort_screenfade'"));
3209     return SQ_ERROR;
3210   }
3211
3212 }
3213
3214 static SQInteger translate_wrapper(HSQUIRRELVM vm)
3215 {
3216   const SQChar* arg0;
3217   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
3218     sq_throwerror(vm, _SC("Argument 1 not a string"));
3219     return SQ_ERROR;
3220   }
3221
3222   try {
3223     std::string return_value = Scripting::translate(arg0);
3224
3225     sq_pushstring(vm, return_value.c_str(), return_value.size());
3226     return 1;
3227
3228   } catch(std::exception& e) {
3229     sq_throwerror(vm, e.what());
3230     return SQ_ERROR;
3231   } catch(...) {
3232     sq_throwerror(vm, _SC("Unexpected exception while executing function 'translate'"));
3233     return SQ_ERROR;
3234   }
3235
3236 }
3237
3238 static SQInteger import_wrapper(HSQUIRRELVM vm)
3239 {
3240   HSQUIRRELVM arg0 = vm;
3241   const SQChar* arg1;
3242   if(SQ_FAILED(sq_getstring(vm, 2, &arg1))) {
3243     sq_throwerror(vm, _SC("Argument 1 not a string"));
3244     return SQ_ERROR;
3245   }
3246
3247   try {
3248     Scripting::import(arg0, arg1);
3249
3250     return 0;
3251
3252   } catch(std::exception& e) {
3253     sq_throwerror(vm, e.what());
3254     return SQ_ERROR;
3255   } catch(...) {
3256     sq_throwerror(vm, _SC("Unexpected exception while executing function 'import'"));
3257     return SQ_ERROR;
3258   }
3259
3260 }
3261
3262 static SQInteger save_state_wrapper(HSQUIRRELVM vm)
3263 {
3264   (void) vm;
3265
3266   try {
3267     Scripting::save_state();
3268
3269     return 0;
3270
3271   } catch(std::exception& e) {
3272     sq_throwerror(vm, e.what());
3273     return SQ_ERROR;
3274   } catch(...) {
3275     sq_throwerror(vm, _SC("Unexpected exception while executing function 'save_state'"));
3276     return SQ_ERROR;
3277   }
3278
3279 }
3280
3281 static SQInteger update_worldmap_wrapper(HSQUIRRELVM vm)
3282 {
3283   (void) vm;
3284
3285   try {
3286     Scripting::update_worldmap();
3287
3288     return 0;
3289
3290   } catch(std::exception& e) {
3291     sq_throwerror(vm, e.what());
3292     return SQ_ERROR;
3293   } catch(...) {
3294     sq_throwerror(vm, _SC("Unexpected exception while executing function 'update_worldmap'"));
3295     return SQ_ERROR;
3296   }
3297
3298 }
3299
3300 static SQInteger debug_collrects_wrapper(HSQUIRRELVM vm)
3301 {
3302   SQBool arg0;
3303   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
3304     sq_throwerror(vm, _SC("Argument 1 not a bool"));
3305     return SQ_ERROR;
3306   }
3307
3308   try {
3309     Scripting::debug_collrects(arg0 == SQTrue);
3310
3311     return 0;
3312
3313   } catch(std::exception& e) {
3314     sq_throwerror(vm, e.what());
3315     return SQ_ERROR;
3316   } catch(...) {
3317     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_collrects'"));
3318     return SQ_ERROR;
3319   }
3320
3321 }
3322
3323 static SQInteger debug_show_fps_wrapper(HSQUIRRELVM vm)
3324 {
3325   SQBool arg0;
3326   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
3327     sq_throwerror(vm, _SC("Argument 1 not a bool"));
3328     return SQ_ERROR;
3329   }
3330
3331   try {
3332     Scripting::debug_show_fps(arg0 == SQTrue);
3333
3334     return 0;
3335
3336   } catch(std::exception& e) {
3337     sq_throwerror(vm, e.what());
3338     return SQ_ERROR;
3339   } catch(...) {
3340     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_show_fps'"));
3341     return SQ_ERROR;
3342   }
3343
3344 }
3345
3346 static SQInteger debug_draw_solids_only_wrapper(HSQUIRRELVM vm)
3347 {
3348   SQBool arg0;
3349   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
3350     sq_throwerror(vm, _SC("Argument 1 not a bool"));
3351     return SQ_ERROR;
3352   }
3353
3354   try {
3355     Scripting::debug_draw_solids_only(arg0 == SQTrue);
3356
3357     return 0;
3358
3359   } catch(std::exception& e) {
3360     sq_throwerror(vm, e.what());
3361     return SQ_ERROR;
3362   } catch(...) {
3363     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_draw_solids_only'"));
3364     return SQ_ERROR;
3365   }
3366
3367 }
3368
3369 static SQInteger debug_worldmap_ghost_wrapper(HSQUIRRELVM vm)
3370 {
3371   SQBool arg0;
3372   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
3373     sq_throwerror(vm, _SC("Argument 1 not a bool"));
3374     return SQ_ERROR;
3375   }
3376
3377   try {
3378     Scripting::debug_worldmap_ghost(arg0 == SQTrue);
3379
3380     return 0;
3381
3382   } catch(std::exception& e) {
3383     sq_throwerror(vm, e.what());
3384     return SQ_ERROR;
3385   } catch(...) {
3386     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_worldmap_ghost'"));
3387     return SQ_ERROR;
3388   }
3389
3390 }
3391
3392 static SQInteger play_music_wrapper(HSQUIRRELVM vm)
3393 {
3394   const SQChar* arg0;
3395   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
3396     sq_throwerror(vm, _SC("Argument 1 not a string"));
3397     return SQ_ERROR;
3398   }
3399
3400   try {
3401     Scripting::play_music(arg0);
3402
3403     return 0;
3404
3405   } catch(std::exception& e) {
3406     sq_throwerror(vm, e.what());
3407     return SQ_ERROR;
3408   } catch(...) {
3409     sq_throwerror(vm, _SC("Unexpected exception while executing function 'play_music'"));
3410     return SQ_ERROR;
3411   }
3412
3413 }
3414
3415 static SQInteger play_sound_wrapper(HSQUIRRELVM vm)
3416 {
3417   const SQChar* arg0;
3418   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
3419     sq_throwerror(vm, _SC("Argument 1 not a string"));
3420     return SQ_ERROR;
3421   }
3422
3423   try {
3424     Scripting::play_sound(arg0);
3425
3426     return 0;
3427
3428   } catch(std::exception& e) {
3429     sq_throwerror(vm, e.what());
3430     return SQ_ERROR;
3431   } catch(...) {
3432     sq_throwerror(vm, _SC("Unexpected exception while executing function 'play_sound'"));
3433     return SQ_ERROR;
3434   }
3435
3436 }
3437
3438 static SQInteger set_game_speed_wrapper(HSQUIRRELVM vm)
3439 {
3440   SQFloat arg0;
3441   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
3442     sq_throwerror(vm, _SC("Argument 1 not a float"));
3443     return SQ_ERROR;
3444   }
3445
3446   try {
3447     Scripting::set_game_speed(static_cast<float> (arg0));
3448
3449     return 0;
3450
3451   } catch(std::exception& e) {
3452     sq_throwerror(vm, e.what());
3453     return SQ_ERROR;
3454   } catch(...) {
3455     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_game_speed'"));
3456     return SQ_ERROR;
3457   }
3458
3459 }
3460
3461 static SQInteger grease_wrapper(HSQUIRRELVM vm)
3462 {
3463   (void) vm;
3464
3465   try {
3466     Scripting::grease();
3467
3468     return 0;
3469
3470   } catch(std::exception& e) {
3471     sq_throwerror(vm, e.what());
3472     return SQ_ERROR;
3473   } catch(...) {
3474     sq_throwerror(vm, _SC("Unexpected exception while executing function 'grease'"));
3475     return SQ_ERROR;
3476   }
3477
3478 }
3479
3480 static SQInteger invincible_wrapper(HSQUIRRELVM vm)
3481 {
3482   (void) vm;
3483
3484   try {
3485     Scripting::invincible();
3486
3487     return 0;
3488
3489   } catch(std::exception& e) {
3490     sq_throwerror(vm, e.what());
3491     return SQ_ERROR;
3492   } catch(...) {
3493     sq_throwerror(vm, _SC("Unexpected exception while executing function 'invincible'"));
3494     return SQ_ERROR;
3495   }
3496
3497 }
3498
3499 static SQInteger ghost_wrapper(HSQUIRRELVM vm)
3500 {
3501   (void) vm;
3502
3503   try {
3504     Scripting::ghost();
3505
3506     return 0;
3507
3508   } catch(std::exception& e) {
3509     sq_throwerror(vm, e.what());
3510     return SQ_ERROR;
3511   } catch(...) {
3512     sq_throwerror(vm, _SC("Unexpected exception while executing function 'ghost'"));
3513     return SQ_ERROR;
3514   }
3515
3516 }
3517
3518 static SQInteger mortal_wrapper(HSQUIRRELVM vm)
3519 {
3520   (void) vm;
3521
3522   try {
3523     Scripting::mortal();
3524
3525     return 0;
3526
3527   } catch(std::exception& e) {
3528     sq_throwerror(vm, e.what());
3529     return SQ_ERROR;
3530   } catch(...) {
3531     sq_throwerror(vm, _SC("Unexpected exception while executing function 'mortal'"));
3532     return SQ_ERROR;
3533   }
3534
3535 }
3536
3537 static SQInteger restart_wrapper(HSQUIRRELVM vm)
3538 {
3539   (void) vm;
3540
3541   try {
3542     Scripting::restart();
3543
3544     return 0;
3545
3546   } catch(std::exception& e) {
3547     sq_throwerror(vm, e.what());
3548     return SQ_ERROR;
3549   } catch(...) {
3550     sq_throwerror(vm, _SC("Unexpected exception while executing function 'restart'"));
3551     return SQ_ERROR;
3552   }
3553
3554 }
3555
3556 static SQInteger whereami_wrapper(HSQUIRRELVM vm)
3557 {
3558   (void) vm;
3559
3560   try {
3561     Scripting::whereami();
3562
3563     return 0;
3564
3565   } catch(std::exception& e) {
3566     sq_throwerror(vm, e.what());
3567     return SQ_ERROR;
3568   } catch(...) {
3569     sq_throwerror(vm, _SC("Unexpected exception while executing function 'whereami'"));
3570     return SQ_ERROR;
3571   }
3572
3573 }
3574
3575 static SQInteger gotoend_wrapper(HSQUIRRELVM vm)
3576 {
3577   (void) vm;
3578
3579   try {
3580     Scripting::gotoend();
3581
3582     return 0;
3583
3584   } catch(std::exception& e) {
3585     sq_throwerror(vm, e.what());
3586     return SQ_ERROR;
3587   } catch(...) {
3588     sq_throwerror(vm, _SC("Unexpected exception while executing function 'gotoend'"));
3589     return SQ_ERROR;
3590   }
3591
3592 }
3593
3594 static SQInteger camera_wrapper(HSQUIRRELVM vm)
3595 {
3596   (void) vm;
3597
3598   try {
3599     Scripting::camera();
3600
3601     return 0;
3602
3603   } catch(std::exception& e) {
3604     sq_throwerror(vm, e.what());
3605     return SQ_ERROR;
3606   } catch(...) {
3607     sq_throwerror(vm, _SC("Unexpected exception while executing function 'camera'"));
3608     return SQ_ERROR;
3609   }
3610
3611 }
3612
3613 static SQInteger set_gamma_wrapper(HSQUIRRELVM vm)
3614 {
3615   SQFloat arg0;
3616   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
3617     sq_throwerror(vm, _SC("Argument 1 not a float"));
3618     return SQ_ERROR;
3619   }
3620
3621   try {
3622     Scripting::set_gamma(static_cast<float> (arg0));
3623
3624     return 0;
3625
3626   } catch(std::exception& e) {
3627     sq_throwerror(vm, e.what());
3628     return SQ_ERROR;
3629   } catch(...) {
3630     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_gamma'"));
3631     return SQ_ERROR;
3632   }
3633
3634 }
3635
3636 static SQInteger quit_wrapper(HSQUIRRELVM vm)
3637 {
3638   (void) vm;
3639
3640   try {
3641     Scripting::quit();
3642
3643     return 0;
3644
3645   } catch(std::exception& e) {
3646     sq_throwerror(vm, e.what());
3647     return SQ_ERROR;
3648   } catch(...) {
3649     sq_throwerror(vm, _SC("Unexpected exception while executing function 'quit'"));
3650     return SQ_ERROR;
3651   }
3652
3653 }
3654
3655 static SQInteger rand_wrapper(HSQUIRRELVM vm)
3656 {
3657
3658   try {
3659     int return_value = Scripting::rand();
3660
3661     sq_pushinteger(vm, return_value);
3662     return 1;
3663
3664   } catch(std::exception& e) {
3665     sq_throwerror(vm, e.what());
3666     return SQ_ERROR;
3667   } catch(...) {
3668     sq_throwerror(vm, _SC("Unexpected exception while executing function 'rand'"));
3669     return SQ_ERROR;
3670   }
3671
3672 }
3673
3674 static SQInteger record_demo_wrapper(HSQUIRRELVM vm)
3675 {
3676   const SQChar* arg0;
3677   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
3678     sq_throwerror(vm, _SC("Argument 1 not a string"));
3679     return SQ_ERROR;
3680   }
3681
3682   try {
3683     Scripting::record_demo(arg0);
3684
3685     return 0;
3686
3687   } catch(std::exception& e) {
3688     sq_throwerror(vm, e.what());
3689     return SQ_ERROR;
3690   } catch(...) {
3691     sq_throwerror(vm, _SC("Unexpected exception while executing function 'record_demo'"));
3692     return SQ_ERROR;
3693   }
3694
3695 }
3696
3697 static SQInteger play_demo_wrapper(HSQUIRRELVM vm)
3698 {
3699   const SQChar* arg0;
3700   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
3701     sq_throwerror(vm, _SC("Argument 1 not a string"));
3702     return SQ_ERROR;
3703   }
3704
3705   try {
3706     Scripting::play_demo(arg0);
3707
3708     return 0;
3709
3710   } catch(std::exception& e) {
3711     sq_throwerror(vm, e.what());
3712     return SQ_ERROR;
3713   } catch(...) {
3714     sq_throwerror(vm, _SC("Unexpected exception while executing function 'play_demo'"));
3715     return SQ_ERROR;
3716   }
3717
3718 }
3719
3720 static SQInteger Level_finish_wrapper(HSQUIRRELVM vm)
3721 {
3722   SQBool arg0;
3723   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
3724     sq_throwerror(vm, _SC("Argument 1 not a bool"));
3725     return SQ_ERROR;
3726   }
3727
3728   try {
3729     Scripting::Level_finish(arg0 == SQTrue);
3730
3731     return 0;
3732
3733   } catch(std::exception& e) {
3734     sq_throwerror(vm, e.what());
3735     return SQ_ERROR;
3736   } catch(...) {
3737     sq_throwerror(vm, _SC("Unexpected exception while executing function 'Level_finish'"));
3738     return SQ_ERROR;
3739   }
3740
3741 }
3742
3743 static SQInteger Level_spawn_wrapper(HSQUIRRELVM vm)
3744 {
3745   const SQChar* arg0;
3746   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
3747     sq_throwerror(vm, _SC("Argument 1 not a string"));
3748     return SQ_ERROR;
3749   }
3750   const SQChar* arg1;
3751   if(SQ_FAILED(sq_getstring(vm, 3, &arg1))) {
3752     sq_throwerror(vm, _SC("Argument 2 not a string"));
3753     return SQ_ERROR;
3754   }
3755
3756   try {
3757     Scripting::Level_spawn(arg0, arg1);
3758
3759     return 0;
3760
3761   } catch(std::exception& e) {
3762     sq_throwerror(vm, e.what());
3763     return SQ_ERROR;
3764   } catch(...) {
3765     sq_throwerror(vm, _SC("Unexpected exception while executing function 'Level_spawn'"));
3766     return SQ_ERROR;
3767   }
3768
3769 }
3770
3771 static SQInteger Level_flip_vertically_wrapper(HSQUIRRELVM vm)
3772 {
3773   (void) vm;
3774
3775   try {
3776     Scripting::Level_flip_vertically();
3777
3778     return 0;
3779
3780   } catch(std::exception& e) {
3781     sq_throwerror(vm, e.what());
3782     return SQ_ERROR;
3783   } catch(...) {
3784     sq_throwerror(vm, _SC("Unexpected exception while executing function 'Level_flip_vertically'"));
3785     return SQ_ERROR;
3786   }
3787
3788 }
3789
3790 static SQInteger Level_toggle_pause_wrapper(HSQUIRRELVM vm)
3791 {
3792   (void) vm;
3793
3794   try {
3795     Scripting::Level_toggle_pause();
3796
3797     return 0;
3798
3799   } catch(std::exception& e) {
3800     sq_throwerror(vm, e.what());
3801     return SQ_ERROR;
3802   } catch(...) {
3803     sq_throwerror(vm, _SC("Unexpected exception while executing function 'Level_toggle_pause'"));
3804     return SQ_ERROR;
3805   }
3806
3807 }
3808
3809 static SQInteger Level_edit_wrapper(HSQUIRRELVM vm)
3810 {
3811   SQBool arg0;
3812   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
3813     sq_throwerror(vm, _SC("Argument 1 not a bool"));
3814     return SQ_ERROR;
3815   }
3816
3817   try {
3818     Scripting::Level_edit(arg0 == SQTrue);
3819
3820     return 0;
3821
3822   } catch(std::exception& e) {
3823     sq_throwerror(vm, e.what());
3824     return SQ_ERROR;
3825   } catch(...) {
3826     sq_throwerror(vm, _SC("Unexpected exception while executing function 'Level_edit'"));
3827     return SQ_ERROR;
3828   }
3829
3830 }
3831
3832 } // end of namespace Wrapper
3833 void create_squirrel_instance(HSQUIRRELVM v, Scripting::AmbientSound* object, bool setup_releasehook)
3834 {
3835   using namespace Wrapper;
3836
3837   sq_pushroottable(v);
3838   sq_pushstring(v, "AmbientSound", -1);
3839   if(SQ_FAILED(sq_get(v, -2))) {
3840     std::ostringstream msg;
3841     msg << "Couldn't resolved squirrel type 'AmbientSound'";
3842     throw SquirrelError(v, msg.str());
3843   }
3844
3845   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3846     std::ostringstream msg;
3847     msg << "Couldn't setup squirrel instance for object of type 'AmbientSound'";
3848     throw SquirrelError(v, msg.str());
3849   }
3850   sq_remove(v, -2); // remove object name
3851
3852   if(setup_releasehook) {
3853     sq_setreleasehook(v, -1, AmbientSound_release_hook);
3854   }
3855
3856   sq_remove(v, -2); // remove root table
3857 }
3858
3859 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Camera* object, bool setup_releasehook)
3860 {
3861   using namespace Wrapper;
3862
3863   sq_pushroottable(v);
3864   sq_pushstring(v, "Camera", -1);
3865   if(SQ_FAILED(sq_get(v, -2))) {
3866     std::ostringstream msg;
3867     msg << "Couldn't resolved squirrel type 'Camera'";
3868     throw SquirrelError(v, msg.str());
3869   }
3870
3871   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3872     std::ostringstream msg;
3873     msg << "Couldn't setup squirrel instance for object of type 'Camera'";
3874     throw SquirrelError(v, msg.str());
3875   }
3876   sq_remove(v, -2); // remove object name
3877
3878   if(setup_releasehook) {
3879     sq_setreleasehook(v, -1, Camera_release_hook);
3880   }
3881
3882   sq_remove(v, -2); // remove root table
3883 }
3884
3885 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Candle* object, bool setup_releasehook)
3886 {
3887   using namespace Wrapper;
3888
3889   sq_pushroottable(v);
3890   sq_pushstring(v, "Candle", -1);
3891   if(SQ_FAILED(sq_get(v, -2))) {
3892     std::ostringstream msg;
3893     msg << "Couldn't resolved squirrel type 'Candle'";
3894     throw SquirrelError(v, msg.str());
3895   }
3896
3897   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3898     std::ostringstream msg;
3899     msg << "Couldn't setup squirrel instance for object of type 'Candle'";
3900     throw SquirrelError(v, msg.str());
3901   }
3902   sq_remove(v, -2); // remove object name
3903
3904   if(setup_releasehook) {
3905     sq_setreleasehook(v, -1, Candle_release_hook);
3906   }
3907
3908   sq_remove(v, -2); // remove root table
3909 }
3910
3911 void create_squirrel_instance(HSQUIRRELVM v, Scripting::DisplayEffect* object, bool setup_releasehook)
3912 {
3913   using namespace Wrapper;
3914
3915   sq_pushroottable(v);
3916   sq_pushstring(v, "DisplayEffect", -1);
3917   if(SQ_FAILED(sq_get(v, -2))) {
3918     std::ostringstream msg;
3919     msg << "Couldn't resolved squirrel type 'DisplayEffect'";
3920     throw SquirrelError(v, msg.str());
3921   }
3922
3923   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3924     std::ostringstream msg;
3925     msg << "Couldn't setup squirrel instance for object of type 'DisplayEffect'";
3926     throw SquirrelError(v, msg.str());
3927   }
3928   sq_remove(v, -2); // remove object name
3929
3930   if(setup_releasehook) {
3931     sq_setreleasehook(v, -1, DisplayEffect_release_hook);
3932   }
3933
3934   sq_remove(v, -2); // remove root table
3935 }
3936
3937 void create_squirrel_instance(HSQUIRRELVM v, Scripting::FloatingImage* object, bool setup_releasehook)
3938 {
3939   using namespace Wrapper;
3940
3941   sq_pushroottable(v);
3942   sq_pushstring(v, "FloatingImage", -1);
3943   if(SQ_FAILED(sq_get(v, -2))) {
3944     std::ostringstream msg;
3945     msg << "Couldn't resolved squirrel type 'FloatingImage'";
3946     throw SquirrelError(v, msg.str());
3947   }
3948
3949   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3950     std::ostringstream msg;
3951     msg << "Couldn't setup squirrel instance for object of type 'FloatingImage'";
3952     throw SquirrelError(v, msg.str());
3953   }
3954   sq_remove(v, -2); // remove object name
3955
3956   if(setup_releasehook) {
3957     sq_setreleasehook(v, -1, FloatingImage_release_hook);
3958   }
3959
3960   sq_remove(v, -2); // remove root table
3961 }
3962
3963 void create_squirrel_instance(HSQUIRRELVM v, Scripting::LevelTime* object, bool setup_releasehook)
3964 {
3965   using namespace Wrapper;
3966
3967   sq_pushroottable(v);
3968   sq_pushstring(v, "LevelTime", -1);
3969   if(SQ_FAILED(sq_get(v, -2))) {
3970     std::ostringstream msg;
3971     msg << "Couldn't resolved squirrel type 'LevelTime'";
3972     throw SquirrelError(v, msg.str());
3973   }
3974
3975   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3976     std::ostringstream msg;
3977     msg << "Couldn't setup squirrel instance for object of type 'LevelTime'";
3978     throw SquirrelError(v, msg.str());
3979   }
3980   sq_remove(v, -2); // remove object name
3981
3982   if(setup_releasehook) {
3983     sq_setreleasehook(v, -1, LevelTime_release_hook);
3984   }
3985
3986   sq_remove(v, -2); // remove root table
3987 }
3988
3989 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Platform* object, bool setup_releasehook)
3990 {
3991   using namespace Wrapper;
3992
3993   sq_pushroottable(v);
3994   sq_pushstring(v, "Platform", -1);
3995   if(SQ_FAILED(sq_get(v, -2))) {
3996     std::ostringstream msg;
3997     msg << "Couldn't resolved squirrel type 'Platform'";
3998     throw SquirrelError(v, msg.str());
3999   }
4000
4001   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
4002     std::ostringstream msg;
4003     msg << "Couldn't setup squirrel instance for object of type 'Platform'";
4004     throw SquirrelError(v, msg.str());
4005   }
4006   sq_remove(v, -2); // remove object name
4007
4008   if(setup_releasehook) {
4009     sq_setreleasehook(v, -1, Platform_release_hook);
4010   }
4011
4012   sq_remove(v, -2); // remove root table
4013 }
4014
4015 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Player* object, bool setup_releasehook)
4016 {
4017   using namespace Wrapper;
4018
4019   sq_pushroottable(v);
4020   sq_pushstring(v, "Player", -1);
4021   if(SQ_FAILED(sq_get(v, -2))) {
4022     std::ostringstream msg;
4023     msg << "Couldn't resolved squirrel type 'Player'";
4024     throw SquirrelError(v, msg.str());
4025   }
4026
4027   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
4028     std::ostringstream msg;
4029     msg << "Couldn't setup squirrel instance for object of type 'Player'";
4030     throw SquirrelError(v, msg.str());
4031   }
4032   sq_remove(v, -2); // remove object name
4033
4034   if(setup_releasehook) {
4035     sq_setreleasehook(v, -1, Player_release_hook);
4036   }
4037
4038   sq_remove(v, -2); // remove root table
4039 }
4040
4041 void create_squirrel_instance(HSQUIRRELVM v, Scripting::ScriptedObject* object, bool setup_releasehook)
4042 {
4043   using namespace Wrapper;
4044
4045   sq_pushroottable(v);
4046   sq_pushstring(v, "ScriptedObject", -1);
4047   if(SQ_FAILED(sq_get(v, -2))) {
4048     std::ostringstream msg;
4049     msg << "Couldn't resolved squirrel type 'ScriptedObject'";
4050     throw SquirrelError(v, msg.str());
4051   }
4052
4053   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
4054     std::ostringstream msg;
4055     msg << "Couldn't setup squirrel instance for object of type 'ScriptedObject'";
4056     throw SquirrelError(v, msg.str());
4057   }
4058   sq_remove(v, -2); // remove object name
4059
4060   if(setup_releasehook) {
4061     sq_setreleasehook(v, -1, ScriptedObject_release_hook);
4062   }
4063
4064   sq_remove(v, -2); // remove root table
4065 }
4066
4067 void create_squirrel_instance(HSQUIRRELVM v, Scripting::SSector* object, bool setup_releasehook)
4068 {
4069   using namespace Wrapper;
4070
4071   sq_pushroottable(v);
4072   sq_pushstring(v, "SSector", -1);
4073   if(SQ_FAILED(sq_get(v, -2))) {
4074     std::ostringstream msg;
4075     msg << "Couldn't resolved squirrel type 'SSector'";
4076     throw SquirrelError(v, msg.str());
4077   }
4078
4079   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
4080     std::ostringstream msg;
4081     msg << "Couldn't setup squirrel instance for object of type 'SSector'";
4082     throw SquirrelError(v, msg.str());
4083   }
4084   sq_remove(v, -2); // remove object name
4085
4086   if(setup_releasehook) {
4087     sq_setreleasehook(v, -1, SSector_release_hook);
4088   }
4089
4090   sq_remove(v, -2); // remove root table
4091 }
4092
4093 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Text* object, bool setup_releasehook)
4094 {
4095   using namespace Wrapper;
4096
4097   sq_pushroottable(v);
4098   sq_pushstring(v, "Text", -1);
4099   if(SQ_FAILED(sq_get(v, -2))) {
4100     std::ostringstream msg;
4101     msg << "Couldn't resolved squirrel type 'Text'";
4102     throw SquirrelError(v, msg.str());
4103   }
4104
4105   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
4106     std::ostringstream msg;
4107     msg << "Couldn't setup squirrel instance for object of type 'Text'";
4108     throw SquirrelError(v, msg.str());
4109   }
4110   sq_remove(v, -2); // remove object name
4111
4112   if(setup_releasehook) {
4113     sq_setreleasehook(v, -1, Text_release_hook);
4114   }
4115
4116   sq_remove(v, -2); // remove root table
4117 }
4118
4119 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Thunderstorm* object, bool setup_releasehook)
4120 {
4121   using namespace Wrapper;
4122
4123   sq_pushroottable(v);
4124   sq_pushstring(v, "Thunderstorm", -1);
4125   if(SQ_FAILED(sq_get(v, -2))) {
4126     std::ostringstream msg;
4127     msg << "Couldn't resolved squirrel type 'Thunderstorm'";
4128     throw SquirrelError(v, msg.str());
4129   }
4130
4131   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
4132     std::ostringstream msg;
4133     msg << "Couldn't setup squirrel instance for object of type 'Thunderstorm'";
4134     throw SquirrelError(v, msg.str());
4135   }
4136   sq_remove(v, -2); // remove object name
4137
4138   if(setup_releasehook) {
4139     sq_setreleasehook(v, -1, Thunderstorm_release_hook);
4140   }
4141
4142   sq_remove(v, -2); // remove root table
4143 }
4144
4145 void create_squirrel_instance(HSQUIRRELVM v, Scripting::TileMap* object, bool setup_releasehook)
4146 {
4147   using namespace Wrapper;
4148
4149   sq_pushroottable(v);
4150   sq_pushstring(v, "TileMap", -1);
4151   if(SQ_FAILED(sq_get(v, -2))) {
4152     std::ostringstream msg;
4153     msg << "Couldn't resolved squirrel type 'TileMap'";
4154     throw SquirrelError(v, msg.str());
4155   }
4156
4157   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
4158     std::ostringstream msg;
4159     msg << "Couldn't setup squirrel instance for object of type 'TileMap'";
4160     throw SquirrelError(v, msg.str());
4161   }
4162   sq_remove(v, -2); // remove object name
4163
4164   if(setup_releasehook) {
4165     sq_setreleasehook(v, -1, TileMap_release_hook);
4166   }
4167
4168   sq_remove(v, -2); // remove root table
4169 }
4170
4171 void create_squirrel_instance(HSQUIRRELVM v, Scripting::WillOWisp* object, bool setup_releasehook)
4172 {
4173   using namespace Wrapper;
4174
4175   sq_pushroottable(v);
4176   sq_pushstring(v, "WillOWisp", -1);
4177   if(SQ_FAILED(sq_get(v, -2))) {
4178     std::ostringstream msg;
4179     msg << "Couldn't resolved squirrel type 'WillOWisp'";
4180     throw SquirrelError(v, msg.str());
4181   }
4182
4183   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
4184     std::ostringstream msg;
4185     msg << "Couldn't setup squirrel instance for object of type 'WillOWisp'";
4186     throw SquirrelError(v, msg.str());
4187   }
4188   sq_remove(v, -2); // remove object name
4189
4190   if(setup_releasehook) {
4191     sq_setreleasehook(v, -1, WillOWisp_release_hook);
4192   }
4193
4194   sq_remove(v, -2); // remove root table
4195 }
4196
4197 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Wind* object, bool setup_releasehook)
4198 {
4199   using namespace Wrapper;
4200
4201   sq_pushroottable(v);
4202   sq_pushstring(v, "Wind", -1);
4203   if(SQ_FAILED(sq_get(v, -2))) {
4204     std::ostringstream msg;
4205     msg << "Couldn't resolved squirrel type 'Wind'";
4206     throw SquirrelError(v, msg.str());
4207   }
4208
4209   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
4210     std::ostringstream msg;
4211     msg << "Couldn't setup squirrel instance for object of type 'Wind'";
4212     throw SquirrelError(v, msg.str());
4213   }
4214   sq_remove(v, -2); // remove object name
4215
4216   if(setup_releasehook) {
4217     sq_setreleasehook(v, -1, Wind_release_hook);
4218   }
4219
4220   sq_remove(v, -2); // remove root table
4221 }
4222
4223 void register_supertux_wrapper(HSQUIRRELVM v)
4224 {
4225   using namespace Wrapper;
4226
4227   sq_pushstring(v, "ANCHOR_TOP", -1);
4228   sq_pushinteger(v, 16);
4229   if(SQ_FAILED(sq_createslot(v, -3))) {
4230     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP'");
4231   }
4232
4233   sq_pushstring(v, "ANCHOR_BOTTOM", -1);
4234   sq_pushinteger(v, 32);
4235   if(SQ_FAILED(sq_createslot(v, -3))) {
4236     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM'");
4237   }
4238
4239   sq_pushstring(v, "ANCHOR_LEFT", -1);
4240   sq_pushinteger(v, 1);
4241   if(SQ_FAILED(sq_createslot(v, -3))) {
4242     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_LEFT'");
4243   }
4244
4245   sq_pushstring(v, "ANCHOR_RIGHT", -1);
4246   sq_pushinteger(v, 2);
4247   if(SQ_FAILED(sq_createslot(v, -3))) {
4248     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_RIGHT'");
4249   }
4250
4251   sq_pushstring(v, "ANCHOR_MIDDLE", -1);
4252   sq_pushinteger(v, 0);
4253   if(SQ_FAILED(sq_createslot(v, -3))) {
4254     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_MIDDLE'");
4255   }
4256
4257   sq_pushstring(v, "ANCHOR_TOP_LEFT", -1);
4258   sq_pushinteger(v, 17);
4259   if(SQ_FAILED(sq_createslot(v, -3))) {
4260     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP_LEFT'");
4261   }
4262
4263   sq_pushstring(v, "ANCHOR_TOP_RIGHT", -1);
4264   sq_pushinteger(v, 18);
4265   if(SQ_FAILED(sq_createslot(v, -3))) {
4266     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP_RIGHT'");
4267   }
4268
4269   sq_pushstring(v, "ANCHOR_BOTTOM_LEFT", -1);
4270   sq_pushinteger(v, 33);
4271   if(SQ_FAILED(sq_createslot(v, -3))) {
4272     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM_LEFT'");
4273   }
4274
4275   sq_pushstring(v, "ANCHOR_BOTTOM_RIGHT", -1);
4276   sq_pushinteger(v, 34);
4277   if(SQ_FAILED(sq_createslot(v, -3))) {
4278     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM_RIGHT'");
4279   }
4280
4281   sq_pushstring(v, "display", -1);
4282   sq_newclosure(v, &display_wrapper, 0);
4283   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "t.");
4284   if(SQ_FAILED(sq_createslot(v, -3))) {
4285     throw SquirrelError(v, "Couldn't register function 'display'");
4286   }
4287
4288   sq_pushstring(v, "print_stacktrace", -1);
4289   sq_newclosure(v, &print_stacktrace_wrapper, 0);
4290   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4291   if(SQ_FAILED(sq_createslot(v, -3))) {
4292     throw SquirrelError(v, "Couldn't register function 'print_stacktrace'");
4293   }
4294
4295   sq_pushstring(v, "get_current_thread", -1);
4296   sq_newclosure(v, &get_current_thread_wrapper, 0);
4297   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "t");
4298   if(SQ_FAILED(sq_createslot(v, -3))) {
4299     throw SquirrelError(v, "Couldn't register function 'get_current_thread'");
4300   }
4301
4302   sq_pushstring(v, "display_text_file", -1);
4303   sq_newclosure(v, &display_text_file_wrapper, 0);
4304   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
4305   if(SQ_FAILED(sq_createslot(v, -3))) {
4306     throw SquirrelError(v, "Couldn't register function 'display_text_file'");
4307   }
4308
4309   sq_pushstring(v, "load_worldmap", -1);
4310   sq_newclosure(v, &load_worldmap_wrapper, 0);
4311   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
4312   if(SQ_FAILED(sq_createslot(v, -3))) {
4313     throw SquirrelError(v, "Couldn't register function 'load_worldmap'");
4314   }
4315
4316   sq_pushstring(v, "load_level", -1);
4317   sq_newclosure(v, &load_level_wrapper, 0);
4318   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
4319   if(SQ_FAILED(sq_createslot(v, -3))) {
4320     throw SquirrelError(v, "Couldn't register function 'load_level'");
4321   }
4322
4323   sq_pushstring(v, "wait", -1);
4324   sq_newclosure(v, &wait_wrapper, 0);
4325   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
4326   if(SQ_FAILED(sq_createslot(v, -3))) {
4327     throw SquirrelError(v, "Couldn't register function 'wait'");
4328   }
4329
4330   sq_pushstring(v, "wait_for_screenswitch", -1);
4331   sq_newclosure(v, &wait_for_screenswitch_wrapper, 0);
4332   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4333   if(SQ_FAILED(sq_createslot(v, -3))) {
4334     throw SquirrelError(v, "Couldn't register function 'wait_for_screenswitch'");
4335   }
4336
4337   sq_pushstring(v, "exit_screen", -1);
4338   sq_newclosure(v, &exit_screen_wrapper, 0);
4339   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4340   if(SQ_FAILED(sq_createslot(v, -3))) {
4341     throw SquirrelError(v, "Couldn't register function 'exit_screen'");
4342   }
4343
4344   sq_pushstring(v, "fadeout_screen", -1);
4345   sq_newclosure(v, &fadeout_screen_wrapper, 0);
4346   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
4347   if(SQ_FAILED(sq_createslot(v, -3))) {
4348     throw SquirrelError(v, "Couldn't register function 'fadeout_screen'");
4349   }
4350
4351   sq_pushstring(v, "shrink_screen", -1);
4352   sq_newclosure(v, &shrink_screen_wrapper, 0);
4353   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tnnn");
4354   if(SQ_FAILED(sq_createslot(v, -3))) {
4355     throw SquirrelError(v, "Couldn't register function 'shrink_screen'");
4356   }
4357
4358   sq_pushstring(v, "abort_screenfade", -1);
4359   sq_newclosure(v, &abort_screenfade_wrapper, 0);
4360   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4361   if(SQ_FAILED(sq_createslot(v, -3))) {
4362     throw SquirrelError(v, "Couldn't register function 'abort_screenfade'");
4363   }
4364
4365   sq_pushstring(v, "translate", -1);
4366   sq_newclosure(v, &translate_wrapper, 0);
4367   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
4368   if(SQ_FAILED(sq_createslot(v, -3))) {
4369     throw SquirrelError(v, "Couldn't register function 'translate'");
4370   }
4371
4372   sq_pushstring(v, "import", -1);
4373   sq_newclosure(v, &import_wrapper, 0);
4374   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
4375   if(SQ_FAILED(sq_createslot(v, -3))) {
4376     throw SquirrelError(v, "Couldn't register function 'import'");
4377   }
4378
4379   sq_pushstring(v, "save_state", -1);
4380   sq_newclosure(v, &save_state_wrapper, 0);
4381   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4382   if(SQ_FAILED(sq_createslot(v, -3))) {
4383     throw SquirrelError(v, "Couldn't register function 'save_state'");
4384   }
4385
4386   sq_pushstring(v, "update_worldmap", -1);
4387   sq_newclosure(v, &update_worldmap_wrapper, 0);
4388   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4389   if(SQ_FAILED(sq_createslot(v, -3))) {
4390     throw SquirrelError(v, "Couldn't register function 'update_worldmap'");
4391   }
4392
4393   sq_pushstring(v, "debug_collrects", -1);
4394   sq_newclosure(v, &debug_collrects_wrapper, 0);
4395   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
4396   if(SQ_FAILED(sq_createslot(v, -3))) {
4397     throw SquirrelError(v, "Couldn't register function 'debug_collrects'");
4398   }
4399
4400   sq_pushstring(v, "debug_show_fps", -1);
4401   sq_newclosure(v, &debug_show_fps_wrapper, 0);
4402   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
4403   if(SQ_FAILED(sq_createslot(v, -3))) {
4404     throw SquirrelError(v, "Couldn't register function 'debug_show_fps'");
4405   }
4406
4407   sq_pushstring(v, "debug_draw_solids_only", -1);
4408   sq_newclosure(v, &debug_draw_solids_only_wrapper, 0);
4409   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
4410   if(SQ_FAILED(sq_createslot(v, -3))) {
4411     throw SquirrelError(v, "Couldn't register function 'debug_draw_solids_only'");
4412   }
4413
4414   sq_pushstring(v, "debug_worldmap_ghost", -1);
4415   sq_newclosure(v, &debug_worldmap_ghost_wrapper, 0);
4416   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
4417   if(SQ_FAILED(sq_createslot(v, -3))) {
4418     throw SquirrelError(v, "Couldn't register function 'debug_worldmap_ghost'");
4419   }
4420
4421   sq_pushstring(v, "play_music", -1);
4422   sq_newclosure(v, &play_music_wrapper, 0);
4423   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
4424   if(SQ_FAILED(sq_createslot(v, -3))) {
4425     throw SquirrelError(v, "Couldn't register function 'play_music'");
4426   }
4427
4428   sq_pushstring(v, "play_sound", -1);
4429   sq_newclosure(v, &play_sound_wrapper, 0);
4430   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
4431   if(SQ_FAILED(sq_createslot(v, -3))) {
4432     throw SquirrelError(v, "Couldn't register function 'play_sound'");
4433   }
4434
4435   sq_pushstring(v, "set_game_speed", -1);
4436   sq_newclosure(v, &set_game_speed_wrapper, 0);
4437   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
4438   if(SQ_FAILED(sq_createslot(v, -3))) {
4439     throw SquirrelError(v, "Couldn't register function 'set_game_speed'");
4440   }
4441
4442   sq_pushstring(v, "grease", -1);
4443   sq_newclosure(v, &grease_wrapper, 0);
4444   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4445   if(SQ_FAILED(sq_createslot(v, -3))) {
4446     throw SquirrelError(v, "Couldn't register function 'grease'");
4447   }
4448
4449   sq_pushstring(v, "invincible", -1);
4450   sq_newclosure(v, &invincible_wrapper, 0);
4451   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4452   if(SQ_FAILED(sq_createslot(v, -3))) {
4453     throw SquirrelError(v, "Couldn't register function 'invincible'");
4454   }
4455
4456   sq_pushstring(v, "ghost", -1);
4457   sq_newclosure(v, &ghost_wrapper, 0);
4458   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4459   if(SQ_FAILED(sq_createslot(v, -3))) {
4460     throw SquirrelError(v, "Couldn't register function 'ghost'");
4461   }
4462
4463   sq_pushstring(v, "mortal", -1);
4464   sq_newclosure(v, &mortal_wrapper, 0);
4465   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4466   if(SQ_FAILED(sq_createslot(v, -3))) {
4467     throw SquirrelError(v, "Couldn't register function 'mortal'");
4468   }
4469
4470   sq_pushstring(v, "restart", -1);
4471   sq_newclosure(v, &restart_wrapper, 0);
4472   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4473   if(SQ_FAILED(sq_createslot(v, -3))) {
4474     throw SquirrelError(v, "Couldn't register function 'restart'");
4475   }
4476
4477   sq_pushstring(v, "whereami", -1);
4478   sq_newclosure(v, &whereami_wrapper, 0);
4479   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4480   if(SQ_FAILED(sq_createslot(v, -3))) {
4481     throw SquirrelError(v, "Couldn't register function 'whereami'");
4482   }
4483
4484   sq_pushstring(v, "gotoend", -1);
4485   sq_newclosure(v, &gotoend_wrapper, 0);
4486   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4487   if(SQ_FAILED(sq_createslot(v, -3))) {
4488     throw SquirrelError(v, "Couldn't register function 'gotoend'");
4489   }
4490
4491   sq_pushstring(v, "camera", -1);
4492   sq_newclosure(v, &camera_wrapper, 0);
4493   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4494   if(SQ_FAILED(sq_createslot(v, -3))) {
4495     throw SquirrelError(v, "Couldn't register function 'camera'");
4496   }
4497
4498   sq_pushstring(v, "set_gamma", -1);
4499   sq_newclosure(v, &set_gamma_wrapper, 0);
4500   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
4501   if(SQ_FAILED(sq_createslot(v, -3))) {
4502     throw SquirrelError(v, "Couldn't register function 'set_gamma'");
4503   }
4504
4505   sq_pushstring(v, "quit", -1);
4506   sq_newclosure(v, &quit_wrapper, 0);
4507   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4508   if(SQ_FAILED(sq_createslot(v, -3))) {
4509     throw SquirrelError(v, "Couldn't register function 'quit'");
4510   }
4511
4512   sq_pushstring(v, "rand", -1);
4513   sq_newclosure(v, &rand_wrapper, 0);
4514   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4515   if(SQ_FAILED(sq_createslot(v, -3))) {
4516     throw SquirrelError(v, "Couldn't register function 'rand'");
4517   }
4518
4519   sq_pushstring(v, "record_demo", -1);
4520   sq_newclosure(v, &record_demo_wrapper, 0);
4521   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
4522   if(SQ_FAILED(sq_createslot(v, -3))) {
4523     throw SquirrelError(v, "Couldn't register function 'record_demo'");
4524   }
4525
4526   sq_pushstring(v, "play_demo", -1);
4527   sq_newclosure(v, &play_demo_wrapper, 0);
4528   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
4529   if(SQ_FAILED(sq_createslot(v, -3))) {
4530     throw SquirrelError(v, "Couldn't register function 'play_demo'");
4531   }
4532
4533   sq_pushstring(v, "Level_finish", -1);
4534   sq_newclosure(v, &Level_finish_wrapper, 0);
4535   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
4536   if(SQ_FAILED(sq_createslot(v, -3))) {
4537     throw SquirrelError(v, "Couldn't register function 'Level_finish'");
4538   }
4539
4540   sq_pushstring(v, "Level_spawn", -1);
4541   sq_newclosure(v, &Level_spawn_wrapper, 0);
4542   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tss");
4543   if(SQ_FAILED(sq_createslot(v, -3))) {
4544     throw SquirrelError(v, "Couldn't register function 'Level_spawn'");
4545   }
4546
4547   sq_pushstring(v, "Level_flip_vertically", -1);
4548   sq_newclosure(v, &Level_flip_vertically_wrapper, 0);
4549   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4550   if(SQ_FAILED(sq_createslot(v, -3))) {
4551     throw SquirrelError(v, "Couldn't register function 'Level_flip_vertically'");
4552   }
4553
4554   sq_pushstring(v, "Level_toggle_pause", -1);
4555   sq_newclosure(v, &Level_toggle_pause_wrapper, 0);
4556   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4557   if(SQ_FAILED(sq_createslot(v, -3))) {
4558     throw SquirrelError(v, "Couldn't register function 'Level_toggle_pause'");
4559   }
4560
4561   sq_pushstring(v, "Level_edit", -1);
4562   sq_newclosure(v, &Level_edit_wrapper, 0);
4563   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
4564   if(SQ_FAILED(sq_createslot(v, -3))) {
4565     throw SquirrelError(v, "Couldn't register function 'Level_edit'");
4566   }
4567
4568   // Register class AmbientSound
4569   sq_pushstring(v, "AmbientSound", -1);
4570   if(sq_newclass(v, SQFalse) < 0) {
4571     std::ostringstream msg;
4572     msg << "Couldn't create new class 'AmbientSound'";
4573     throw SquirrelError(v, msg.str());
4574   }
4575   sq_pushstring(v, "set_pos", -1);
4576   sq_newclosure(v, &AmbientSound_set_pos_wrapper, 0);
4577   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tnn");
4578   if(SQ_FAILED(sq_createslot(v, -3))) {
4579     throw SquirrelError(v, "Couldn't register function 'set_pos'");
4580   }
4581
4582   sq_pushstring(v, "get_pos_x", -1);
4583   sq_newclosure(v, &AmbientSound_get_pos_x_wrapper, 0);
4584   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4585   if(SQ_FAILED(sq_createslot(v, -3))) {
4586     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
4587   }
4588
4589   sq_pushstring(v, "get_pos_y", -1);
4590   sq_newclosure(v, &AmbientSound_get_pos_y_wrapper, 0);
4591   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4592   if(SQ_FAILED(sq_createslot(v, -3))) {
4593     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
4594   }
4595
4596   if(SQ_FAILED(sq_createslot(v, -3))) {
4597     throw SquirrelError(v, "Couldn't register class 'AmbientSound'");
4598   }
4599
4600   // Register class Camera
4601   sq_pushstring(v, "Camera", -1);
4602   if(sq_newclass(v, SQFalse) < 0) {
4603     std::ostringstream msg;
4604     msg << "Couldn't create new class 'Camera'";
4605     throw SquirrelError(v, msg.str());
4606   }
4607   sq_pushstring(v, "reload_config", -1);
4608   sq_newclosure(v, &Camera_reload_config_wrapper, 0);
4609   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4610   if(SQ_FAILED(sq_createslot(v, -3))) {
4611     throw SquirrelError(v, "Couldn't register function 'reload_config'");
4612   }
4613
4614   sq_pushstring(v, "shake", -1);
4615   sq_newclosure(v, &Camera_shake_wrapper, 0);
4616   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tnnn");
4617   if(SQ_FAILED(sq_createslot(v, -3))) {
4618     throw SquirrelError(v, "Couldn't register function 'shake'");
4619   }
4620
4621   sq_pushstring(v, "set_pos", -1);
4622   sq_newclosure(v, &Camera_set_pos_wrapper, 0);
4623   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tnn");
4624   if(SQ_FAILED(sq_createslot(v, -3))) {
4625     throw SquirrelError(v, "Couldn't register function 'set_pos'");
4626   }
4627
4628   sq_pushstring(v, "set_mode", -1);
4629   sq_newclosure(v, &Camera_set_mode_wrapper, 0);
4630   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
4631   if(SQ_FAILED(sq_createslot(v, -3))) {
4632     throw SquirrelError(v, "Couldn't register function 'set_mode'");
4633   }
4634
4635   sq_pushstring(v, "scroll_to", -1);
4636   sq_newclosure(v, &Camera_scroll_to_wrapper, 0);
4637   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tnnn");
4638   if(SQ_FAILED(sq_createslot(v, -3))) {
4639     throw SquirrelError(v, "Couldn't register function 'scroll_to'");
4640   }
4641
4642   if(SQ_FAILED(sq_createslot(v, -3))) {
4643     throw SquirrelError(v, "Couldn't register class 'Camera'");
4644   }
4645
4646   // Register class Candle
4647   sq_pushstring(v, "Candle", -1);
4648   if(sq_newclass(v, SQFalse) < 0) {
4649     std::ostringstream msg;
4650     msg << "Couldn't create new class 'Candle'";
4651     throw SquirrelError(v, msg.str());
4652   }
4653   sq_pushstring(v, "get_burning", -1);
4654   sq_newclosure(v, &Candle_get_burning_wrapper, 0);
4655   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4656   if(SQ_FAILED(sq_createslot(v, -3))) {
4657     throw SquirrelError(v, "Couldn't register function 'get_burning'");
4658   }
4659
4660   sq_pushstring(v, "set_burning", -1);
4661   sq_newclosure(v, &Candle_set_burning_wrapper, 0);
4662   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
4663   if(SQ_FAILED(sq_createslot(v, -3))) {
4664     throw SquirrelError(v, "Couldn't register function 'set_burning'");
4665   }
4666
4667   if(SQ_FAILED(sq_createslot(v, -3))) {
4668     throw SquirrelError(v, "Couldn't register class 'Candle'");
4669   }
4670
4671   // Register class DisplayEffect
4672   sq_pushstring(v, "DisplayEffect", -1);
4673   if(sq_newclass(v, SQFalse) < 0) {
4674     std::ostringstream msg;
4675     msg << "Couldn't create new class 'DisplayEffect'";
4676     throw SquirrelError(v, msg.str());
4677   }
4678   sq_pushstring(v, "fade_out", -1);
4679   sq_newclosure(v, &DisplayEffect_fade_out_wrapper, 0);
4680   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
4681   if(SQ_FAILED(sq_createslot(v, -3))) {
4682     throw SquirrelError(v, "Couldn't register function 'fade_out'");
4683   }
4684
4685   sq_pushstring(v, "fade_in", -1);
4686   sq_newclosure(v, &DisplayEffect_fade_in_wrapper, 0);
4687   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
4688   if(SQ_FAILED(sq_createslot(v, -3))) {
4689     throw SquirrelError(v, "Couldn't register function 'fade_in'");
4690   }
4691
4692   sq_pushstring(v, "set_black", -1);
4693   sq_newclosure(v, &DisplayEffect_set_black_wrapper, 0);
4694   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
4695   if(SQ_FAILED(sq_createslot(v, -3))) {
4696     throw SquirrelError(v, "Couldn't register function 'set_black'");
4697   }
4698
4699   sq_pushstring(v, "is_black", -1);
4700   sq_newclosure(v, &DisplayEffect_is_black_wrapper, 0);
4701   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4702   if(SQ_FAILED(sq_createslot(v, -3))) {
4703     throw SquirrelError(v, "Couldn't register function 'is_black'");
4704   }
4705
4706   sq_pushstring(v, "sixteen_to_nine", -1);
4707   sq_newclosure(v, &DisplayEffect_sixteen_to_nine_wrapper, 0);
4708   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
4709   if(SQ_FAILED(sq_createslot(v, -3))) {
4710     throw SquirrelError(v, "Couldn't register function 'sixteen_to_nine'");
4711   }
4712
4713   sq_pushstring(v, "four_to_three", -1);
4714   sq_newclosure(v, &DisplayEffect_four_to_three_wrapper, 0);
4715   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
4716   if(SQ_FAILED(sq_createslot(v, -3))) {
4717     throw SquirrelError(v, "Couldn't register function 'four_to_three'");
4718   }
4719
4720   if(SQ_FAILED(sq_createslot(v, -3))) {
4721     throw SquirrelError(v, "Couldn't register class 'DisplayEffect'");
4722   }
4723
4724   // Register class FloatingImage
4725   sq_pushstring(v, "FloatingImage", -1);
4726   if(sq_newclass(v, SQFalse) < 0) {
4727     std::ostringstream msg;
4728     msg << "Couldn't create new class 'FloatingImage'";
4729     throw SquirrelError(v, msg.str());
4730   }
4731   sq_pushstring(v, "constructor", -1);
4732   sq_newclosure(v, &FloatingImage_constructor_wrapper, 0);
4733   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
4734   if(SQ_FAILED(sq_createslot(v, -3))) {
4735     throw SquirrelError(v, "Couldn't register function 'constructor'");
4736   }
4737
4738   sq_pushstring(v, "set_layer", -1);
4739   sq_newclosure(v, &FloatingImage_set_layer_wrapper, 0);
4740   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ti");
4741   if(SQ_FAILED(sq_createslot(v, -3))) {
4742     throw SquirrelError(v, "Couldn't register function 'set_layer'");
4743   }
4744
4745   sq_pushstring(v, "get_layer", -1);
4746   sq_newclosure(v, &FloatingImage_get_layer_wrapper, 0);
4747   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4748   if(SQ_FAILED(sq_createslot(v, -3))) {
4749     throw SquirrelError(v, "Couldn't register function 'get_layer'");
4750   }
4751
4752   sq_pushstring(v, "set_pos", -1);
4753   sq_newclosure(v, &FloatingImage_set_pos_wrapper, 0);
4754   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tnn");
4755   if(SQ_FAILED(sq_createslot(v, -3))) {
4756     throw SquirrelError(v, "Couldn't register function 'set_pos'");
4757   }
4758
4759   sq_pushstring(v, "get_pos_x", -1);
4760   sq_newclosure(v, &FloatingImage_get_pos_x_wrapper, 0);
4761   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4762   if(SQ_FAILED(sq_createslot(v, -3))) {
4763     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
4764   }
4765
4766   sq_pushstring(v, "get_pos_y", -1);
4767   sq_newclosure(v, &FloatingImage_get_pos_y_wrapper, 0);
4768   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4769   if(SQ_FAILED(sq_createslot(v, -3))) {
4770     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
4771   }
4772
4773   sq_pushstring(v, "set_anchor_point", -1);
4774   sq_newclosure(v, &FloatingImage_set_anchor_point_wrapper, 0);
4775   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ti");
4776   if(SQ_FAILED(sq_createslot(v, -3))) {
4777     throw SquirrelError(v, "Couldn't register function 'set_anchor_point'");
4778   }
4779
4780   sq_pushstring(v, "get_anchor_point", -1);
4781   sq_newclosure(v, &FloatingImage_get_anchor_point_wrapper, 0);
4782   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4783   if(SQ_FAILED(sq_createslot(v, -3))) {
4784     throw SquirrelError(v, "Couldn't register function 'get_anchor_point'");
4785   }
4786
4787   sq_pushstring(v, "set_visible", -1);
4788   sq_newclosure(v, &FloatingImage_set_visible_wrapper, 0);
4789   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
4790   if(SQ_FAILED(sq_createslot(v, -3))) {
4791     throw SquirrelError(v, "Couldn't register function 'set_visible'");
4792   }
4793
4794   sq_pushstring(v, "get_visible", -1);
4795   sq_newclosure(v, &FloatingImage_get_visible_wrapper, 0);
4796   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4797   if(SQ_FAILED(sq_createslot(v, -3))) {
4798     throw SquirrelError(v, "Couldn't register function 'get_visible'");
4799   }
4800
4801   sq_pushstring(v, "set_action", -1);
4802   sq_newclosure(v, &FloatingImage_set_action_wrapper, 0);
4803   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
4804   if(SQ_FAILED(sq_createslot(v, -3))) {
4805     throw SquirrelError(v, "Couldn't register function 'set_action'");
4806   }
4807
4808   sq_pushstring(v, "get_action", -1);
4809   sq_newclosure(v, &FloatingImage_get_action_wrapper, 0);
4810   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4811   if(SQ_FAILED(sq_createslot(v, -3))) {
4812     throw SquirrelError(v, "Couldn't register function 'get_action'");
4813   }
4814
4815   sq_pushstring(v, "fade_in", -1);
4816   sq_newclosure(v, &FloatingImage_fade_in_wrapper, 0);
4817   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
4818   if(SQ_FAILED(sq_createslot(v, -3))) {
4819     throw SquirrelError(v, "Couldn't register function 'fade_in'");
4820   }
4821
4822   sq_pushstring(v, "fade_out", -1);
4823   sq_newclosure(v, &FloatingImage_fade_out_wrapper, 0);
4824   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
4825   if(SQ_FAILED(sq_createslot(v, -3))) {
4826     throw SquirrelError(v, "Couldn't register function 'fade_out'");
4827   }
4828
4829   if(SQ_FAILED(sq_createslot(v, -3))) {
4830     throw SquirrelError(v, "Couldn't register class 'FloatingImage'");
4831   }
4832
4833   // Register class LevelTime
4834   sq_pushstring(v, "LevelTime", -1);
4835   if(sq_newclass(v, SQFalse) < 0) {
4836     std::ostringstream msg;
4837     msg << "Couldn't create new class 'LevelTime'";
4838     throw SquirrelError(v, msg.str());
4839   }
4840   sq_pushstring(v, "start", -1);
4841   sq_newclosure(v, &LevelTime_start_wrapper, 0);
4842   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4843   if(SQ_FAILED(sq_createslot(v, -3))) {
4844     throw SquirrelError(v, "Couldn't register function 'start'");
4845   }
4846
4847   sq_pushstring(v, "stop", -1);
4848   sq_newclosure(v, &LevelTime_stop_wrapper, 0);
4849   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4850   if(SQ_FAILED(sq_createslot(v, -3))) {
4851     throw SquirrelError(v, "Couldn't register function 'stop'");
4852   }
4853
4854   sq_pushstring(v, "get_time", -1);
4855   sq_newclosure(v, &LevelTime_get_time_wrapper, 0);
4856   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4857   if(SQ_FAILED(sq_createslot(v, -3))) {
4858     throw SquirrelError(v, "Couldn't register function 'get_time'");
4859   }
4860
4861   sq_pushstring(v, "set_time", -1);
4862   sq_newclosure(v, &LevelTime_set_time_wrapper, 0);
4863   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
4864   if(SQ_FAILED(sq_createslot(v, -3))) {
4865     throw SquirrelError(v, "Couldn't register function 'set_time'");
4866   }
4867
4868   if(SQ_FAILED(sq_createslot(v, -3))) {
4869     throw SquirrelError(v, "Couldn't register class 'LevelTime'");
4870   }
4871
4872   // Register class Platform
4873   sq_pushstring(v, "Platform", -1);
4874   if(sq_newclass(v, SQFalse) < 0) {
4875     std::ostringstream msg;
4876     msg << "Couldn't create new class 'Platform'";
4877     throw SquirrelError(v, msg.str());
4878   }
4879   sq_pushstring(v, "goto_node", -1);
4880   sq_newclosure(v, &Platform_goto_node_wrapper, 0);
4881   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ti");
4882   if(SQ_FAILED(sq_createslot(v, -3))) {
4883     throw SquirrelError(v, "Couldn't register function 'goto_node'");
4884   }
4885
4886   sq_pushstring(v, "start_moving", -1);
4887   sq_newclosure(v, &Platform_start_moving_wrapper, 0);
4888   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4889   if(SQ_FAILED(sq_createslot(v, -3))) {
4890     throw SquirrelError(v, "Couldn't register function 'start_moving'");
4891   }
4892
4893   sq_pushstring(v, "stop_moving", -1);
4894   sq_newclosure(v, &Platform_stop_moving_wrapper, 0);
4895   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4896   if(SQ_FAILED(sq_createslot(v, -3))) {
4897     throw SquirrelError(v, "Couldn't register function 'stop_moving'");
4898   }
4899
4900   if(SQ_FAILED(sq_createslot(v, -3))) {
4901     throw SquirrelError(v, "Couldn't register class 'Platform'");
4902   }
4903
4904   // Register class Player
4905   sq_pushstring(v, "Player", -1);
4906   if(sq_newclass(v, SQFalse) < 0) {
4907     std::ostringstream msg;
4908     msg << "Couldn't create new class 'Player'";
4909     throw SquirrelError(v, msg.str());
4910   }
4911   sq_pushstring(v, "add_bonus", -1);
4912   sq_newclosure(v, &Player_add_bonus_wrapper, 0);
4913   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
4914   if(SQ_FAILED(sq_createslot(v, -3))) {
4915     throw SquirrelError(v, "Couldn't register function 'add_bonus'");
4916   }
4917
4918   sq_pushstring(v, "add_coins", -1);
4919   sq_newclosure(v, &Player_add_coins_wrapper, 0);
4920   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ti");
4921   if(SQ_FAILED(sq_createslot(v, -3))) {
4922     throw SquirrelError(v, "Couldn't register function 'add_coins'");
4923   }
4924
4925   sq_pushstring(v, "make_invincible", -1);
4926   sq_newclosure(v, &Player_make_invincible_wrapper, 0);
4927   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4928   if(SQ_FAILED(sq_createslot(v, -3))) {
4929     throw SquirrelError(v, "Couldn't register function 'make_invincible'");
4930   }
4931
4932   sq_pushstring(v, "deactivate", -1);
4933   sq_newclosure(v, &Player_deactivate_wrapper, 0);
4934   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4935   if(SQ_FAILED(sq_createslot(v, -3))) {
4936     throw SquirrelError(v, "Couldn't register function 'deactivate'");
4937   }
4938
4939   sq_pushstring(v, "activate", -1);
4940   sq_newclosure(v, &Player_activate_wrapper, 0);
4941   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4942   if(SQ_FAILED(sq_createslot(v, -3))) {
4943     throw SquirrelError(v, "Couldn't register function 'activate'");
4944   }
4945
4946   sq_pushstring(v, "walk", -1);
4947   sq_newclosure(v, &Player_walk_wrapper, 0);
4948   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
4949   if(SQ_FAILED(sq_createslot(v, -3))) {
4950     throw SquirrelError(v, "Couldn't register function 'walk'");
4951   }
4952
4953   sq_pushstring(v, "set_visible", -1);
4954   sq_newclosure(v, &Player_set_visible_wrapper, 0);
4955   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
4956   if(SQ_FAILED(sq_createslot(v, -3))) {
4957     throw SquirrelError(v, "Couldn't register function 'set_visible'");
4958   }
4959
4960   sq_pushstring(v, "get_visible", -1);
4961   sq_newclosure(v, &Player_get_visible_wrapper, 0);
4962   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4963   if(SQ_FAILED(sq_createslot(v, -3))) {
4964     throw SquirrelError(v, "Couldn't register function 'get_visible'");
4965   }
4966
4967   sq_pushstring(v, "kill", -1);
4968   sq_newclosure(v, &Player_kill_wrapper, 0);
4969   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
4970   if(SQ_FAILED(sq_createslot(v, -3))) {
4971     throw SquirrelError(v, "Couldn't register function 'kill'");
4972   }
4973
4974   sq_pushstring(v, "set_ghost_mode", -1);
4975   sq_newclosure(v, &Player_set_ghost_mode_wrapper, 0);
4976   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
4977   if(SQ_FAILED(sq_createslot(v, -3))) {
4978     throw SquirrelError(v, "Couldn't register function 'set_ghost_mode'");
4979   }
4980
4981   sq_pushstring(v, "get_ghost_mode", -1);
4982   sq_newclosure(v, &Player_get_ghost_mode_wrapper, 0);
4983   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4984   if(SQ_FAILED(sq_createslot(v, -3))) {
4985     throw SquirrelError(v, "Couldn't register function 'get_ghost_mode'");
4986   }
4987
4988   sq_pushstring(v, "do_cheer", -1);
4989   sq_newclosure(v, &Player_do_cheer_wrapper, 0);
4990   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4991   if(SQ_FAILED(sq_createslot(v, -3))) {
4992     throw SquirrelError(v, "Couldn't register function 'do_cheer'");
4993   }
4994
4995   sq_pushstring(v, "do_duck", -1);
4996   sq_newclosure(v, &Player_do_duck_wrapper, 0);
4997   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
4998   if(SQ_FAILED(sq_createslot(v, -3))) {
4999     throw SquirrelError(v, "Couldn't register function 'do_duck'");
5000   }
5001
5002   sq_pushstring(v, "do_standup", -1);
5003   sq_newclosure(v, &Player_do_standup_wrapper, 0);
5004   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5005   if(SQ_FAILED(sq_createslot(v, -3))) {
5006     throw SquirrelError(v, "Couldn't register function 'do_standup'");
5007   }
5008
5009   sq_pushstring(v, "do_backflip", -1);
5010   sq_newclosure(v, &Player_do_backflip_wrapper, 0);
5011   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5012   if(SQ_FAILED(sq_createslot(v, -3))) {
5013     throw SquirrelError(v, "Couldn't register function 'do_backflip'");
5014   }
5015
5016   sq_pushstring(v, "do_jump", -1);
5017   sq_newclosure(v, &Player_do_jump_wrapper, 0);
5018   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
5019   if(SQ_FAILED(sq_createslot(v, -3))) {
5020     throw SquirrelError(v, "Couldn't register function 'do_jump'");
5021   }
5022
5023   sq_pushstring(v, "trigger_sequence", -1);
5024   sq_newclosure(v, &Player_trigger_sequence_wrapper, 0);
5025   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
5026   if(SQ_FAILED(sq_createslot(v, -3))) {
5027     throw SquirrelError(v, "Couldn't register function 'trigger_sequence'");
5028   }
5029
5030   sq_pushstring(v, "use_scripting_controller", -1);
5031   sq_newclosure(v, &Player_use_scripting_controller_wrapper, 0);
5032   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
5033   if(SQ_FAILED(sq_createslot(v, -3))) {
5034     throw SquirrelError(v, "Couldn't register function 'use_scripting_controller'");
5035   }
5036
5037   sq_pushstring(v, "do_scripting_controller", -1);
5038   sq_newclosure(v, &Player_do_scripting_controller_wrapper, 0);
5039   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tsb");
5040   if(SQ_FAILED(sq_createslot(v, -3))) {
5041     throw SquirrelError(v, "Couldn't register function 'do_scripting_controller'");
5042   }
5043
5044   if(SQ_FAILED(sq_createslot(v, -3))) {
5045     throw SquirrelError(v, "Couldn't register class 'Player'");
5046   }
5047
5048   // Register class ScriptedObject
5049   sq_pushstring(v, "ScriptedObject", -1);
5050   if(sq_newclass(v, SQFalse) < 0) {
5051     std::ostringstream msg;
5052     msg << "Couldn't create new class 'ScriptedObject'";
5053     throw SquirrelError(v, msg.str());
5054   }
5055   sq_pushstring(v, "set_action", -1);
5056   sq_newclosure(v, &ScriptedObject_set_action_wrapper, 0);
5057   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
5058   if(SQ_FAILED(sq_createslot(v, -3))) {
5059     throw SquirrelError(v, "Couldn't register function 'set_action'");
5060   }
5061
5062   sq_pushstring(v, "get_action", -1);
5063   sq_newclosure(v, &ScriptedObject_get_action_wrapper, 0);
5064   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5065   if(SQ_FAILED(sq_createslot(v, -3))) {
5066     throw SquirrelError(v, "Couldn't register function 'get_action'");
5067   }
5068
5069   sq_pushstring(v, "move", -1);
5070   sq_newclosure(v, &ScriptedObject_move_wrapper, 0);
5071   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tnn");
5072   if(SQ_FAILED(sq_createslot(v, -3))) {
5073     throw SquirrelError(v, "Couldn't register function 'move'");
5074   }
5075
5076   sq_pushstring(v, "set_pos", -1);
5077   sq_newclosure(v, &ScriptedObject_set_pos_wrapper, 0);
5078   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tnn");
5079   if(SQ_FAILED(sq_createslot(v, -3))) {
5080     throw SquirrelError(v, "Couldn't register function 'set_pos'");
5081   }
5082
5083   sq_pushstring(v, "get_pos_x", -1);
5084   sq_newclosure(v, &ScriptedObject_get_pos_x_wrapper, 0);
5085   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5086   if(SQ_FAILED(sq_createslot(v, -3))) {
5087     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
5088   }
5089
5090   sq_pushstring(v, "get_pos_y", -1);
5091   sq_newclosure(v, &ScriptedObject_get_pos_y_wrapper, 0);
5092   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5093   if(SQ_FAILED(sq_createslot(v, -3))) {
5094     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
5095   }
5096
5097   sq_pushstring(v, "set_velocity", -1);
5098   sq_newclosure(v, &ScriptedObject_set_velocity_wrapper, 0);
5099   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tnn");
5100   if(SQ_FAILED(sq_createslot(v, -3))) {
5101     throw SquirrelError(v, "Couldn't register function 'set_velocity'");
5102   }
5103
5104   sq_pushstring(v, "get_velocity_x", -1);
5105   sq_newclosure(v, &ScriptedObject_get_velocity_x_wrapper, 0);
5106   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5107   if(SQ_FAILED(sq_createslot(v, -3))) {
5108     throw SquirrelError(v, "Couldn't register function 'get_velocity_x'");
5109   }
5110
5111   sq_pushstring(v, "get_velocity_y", -1);
5112   sq_newclosure(v, &ScriptedObject_get_velocity_y_wrapper, 0);
5113   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5114   if(SQ_FAILED(sq_createslot(v, -3))) {
5115     throw SquirrelError(v, "Couldn't register function 'get_velocity_y'");
5116   }
5117
5118   sq_pushstring(v, "set_visible", -1);
5119   sq_newclosure(v, &ScriptedObject_set_visible_wrapper, 0);
5120   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
5121   if(SQ_FAILED(sq_createslot(v, -3))) {
5122     throw SquirrelError(v, "Couldn't register function 'set_visible'");
5123   }
5124
5125   sq_pushstring(v, "is_visible", -1);
5126   sq_newclosure(v, &ScriptedObject_is_visible_wrapper, 0);
5127   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5128   if(SQ_FAILED(sq_createslot(v, -3))) {
5129     throw SquirrelError(v, "Couldn't register function 'is_visible'");
5130   }
5131
5132   sq_pushstring(v, "set_solid", -1);
5133   sq_newclosure(v, &ScriptedObject_set_solid_wrapper, 0);
5134   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
5135   if(SQ_FAILED(sq_createslot(v, -3))) {
5136     throw SquirrelError(v, "Couldn't register function 'set_solid'");
5137   }
5138
5139   sq_pushstring(v, "is_solid", -1);
5140   sq_newclosure(v, &ScriptedObject_is_solid_wrapper, 0);
5141   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5142   if(SQ_FAILED(sq_createslot(v, -3))) {
5143     throw SquirrelError(v, "Couldn't register function 'is_solid'");
5144   }
5145
5146   sq_pushstring(v, "get_name", -1);
5147   sq_newclosure(v, &ScriptedObject_get_name_wrapper, 0);
5148   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5149   if(SQ_FAILED(sq_createslot(v, -3))) {
5150     throw SquirrelError(v, "Couldn't register function 'get_name'");
5151   }
5152
5153   if(SQ_FAILED(sq_createslot(v, -3))) {
5154     throw SquirrelError(v, "Couldn't register class 'ScriptedObject'");
5155   }
5156
5157   // Register class SSector
5158   sq_pushstring(v, "SSector", -1);
5159   if(sq_newclass(v, SQFalse) < 0) {
5160     std::ostringstream msg;
5161     msg << "Couldn't create new class 'SSector'";
5162     throw SquirrelError(v, msg.str());
5163   }
5164   sq_pushstring(v, "set_ambient_light", -1);
5165   sq_newclosure(v, &SSector_set_ambient_light_wrapper, 0);
5166   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tnnn");
5167   if(SQ_FAILED(sq_createslot(v, -3))) {
5168     throw SquirrelError(v, "Couldn't register function 'set_ambient_light'");
5169   }
5170
5171   sq_pushstring(v, "get_ambient_red", -1);
5172   sq_newclosure(v, &SSector_get_ambient_red_wrapper, 0);
5173   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5174   if(SQ_FAILED(sq_createslot(v, -3))) {
5175     throw SquirrelError(v, "Couldn't register function 'get_ambient_red'");
5176   }
5177
5178   sq_pushstring(v, "get_ambient_green", -1);
5179   sq_newclosure(v, &SSector_get_ambient_green_wrapper, 0);
5180   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5181   if(SQ_FAILED(sq_createslot(v, -3))) {
5182     throw SquirrelError(v, "Couldn't register function 'get_ambient_green'");
5183   }
5184
5185   sq_pushstring(v, "get_ambient_blue", -1);
5186   sq_newclosure(v, &SSector_get_ambient_blue_wrapper, 0);
5187   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5188   if(SQ_FAILED(sq_createslot(v, -3))) {
5189     throw SquirrelError(v, "Couldn't register function 'get_ambient_blue'");
5190   }
5191
5192   sq_pushstring(v, "set_gravity", -1);
5193   sq_newclosure(v, &SSector_set_gravity_wrapper, 0);
5194   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
5195   if(SQ_FAILED(sq_createslot(v, -3))) {
5196     throw SquirrelError(v, "Couldn't register function 'set_gravity'");
5197   }
5198
5199   if(SQ_FAILED(sq_createslot(v, -3))) {
5200     throw SquirrelError(v, "Couldn't register class 'SSector'");
5201   }
5202
5203   // Register class Text
5204   sq_pushstring(v, "Text", -1);
5205   if(sq_newclass(v, SQFalse) < 0) {
5206     std::ostringstream msg;
5207     msg << "Couldn't create new class 'Text'";
5208     throw SquirrelError(v, msg.str());
5209   }
5210   sq_pushstring(v, "set_text", -1);
5211   sq_newclosure(v, &Text_set_text_wrapper, 0);
5212   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
5213   if(SQ_FAILED(sq_createslot(v, -3))) {
5214     throw SquirrelError(v, "Couldn't register function 'set_text'");
5215   }
5216
5217   sq_pushstring(v, "set_font", -1);
5218   sq_newclosure(v, &Text_set_font_wrapper, 0);
5219   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
5220   if(SQ_FAILED(sq_createslot(v, -3))) {
5221     throw SquirrelError(v, "Couldn't register function 'set_font'");
5222   }
5223
5224   sq_pushstring(v, "fade_in", -1);
5225   sq_newclosure(v, &Text_fade_in_wrapper, 0);
5226   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
5227   if(SQ_FAILED(sq_createslot(v, -3))) {
5228     throw SquirrelError(v, "Couldn't register function 'fade_in'");
5229   }
5230
5231   sq_pushstring(v, "fade_out", -1);
5232   sq_newclosure(v, &Text_fade_out_wrapper, 0);
5233   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
5234   if(SQ_FAILED(sq_createslot(v, -3))) {
5235     throw SquirrelError(v, "Couldn't register function 'fade_out'");
5236   }
5237
5238   sq_pushstring(v, "set_visible", -1);
5239   sq_newclosure(v, &Text_set_visible_wrapper, 0);
5240   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
5241   if(SQ_FAILED(sq_createslot(v, -3))) {
5242     throw SquirrelError(v, "Couldn't register function 'set_visible'");
5243   }
5244
5245   sq_pushstring(v, "set_centered", -1);
5246   sq_newclosure(v, &Text_set_centered_wrapper, 0);
5247   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tb");
5248   if(SQ_FAILED(sq_createslot(v, -3))) {
5249     throw SquirrelError(v, "Couldn't register function 'set_centered'");
5250   }
5251
5252   sq_pushstring(v, "set_pos", -1);
5253   sq_newclosure(v, &Text_set_pos_wrapper, 0);
5254   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tnn");
5255   if(SQ_FAILED(sq_createslot(v, -3))) {
5256     throw SquirrelError(v, "Couldn't register function 'set_pos'");
5257   }
5258
5259   sq_pushstring(v, "get_pos_x", -1);
5260   sq_newclosure(v, &Text_get_pos_x_wrapper, 0);
5261   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5262   if(SQ_FAILED(sq_createslot(v, -3))) {
5263     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
5264   }
5265
5266   sq_pushstring(v, "get_pos_y", -1);
5267   sq_newclosure(v, &Text_get_pos_y_wrapper, 0);
5268   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5269   if(SQ_FAILED(sq_createslot(v, -3))) {
5270     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
5271   }
5272
5273   sq_pushstring(v, "set_anchor_point", -1);
5274   sq_newclosure(v, &Text_set_anchor_point_wrapper, 0);
5275   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ti");
5276   if(SQ_FAILED(sq_createslot(v, -3))) {
5277     throw SquirrelError(v, "Couldn't register function 'set_anchor_point'");
5278   }
5279
5280   sq_pushstring(v, "get_anchor_point", -1);
5281   sq_newclosure(v, &Text_get_anchor_point_wrapper, 0);
5282   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5283   if(SQ_FAILED(sq_createslot(v, -3))) {
5284     throw SquirrelError(v, "Couldn't register function 'get_anchor_point'");
5285   }
5286
5287   if(SQ_FAILED(sq_createslot(v, -3))) {
5288     throw SquirrelError(v, "Couldn't register class 'Text'");
5289   }
5290
5291   // Register class Thunderstorm
5292   sq_pushstring(v, "Thunderstorm", -1);
5293   if(sq_newclass(v, SQFalse) < 0) {
5294     std::ostringstream msg;
5295     msg << "Couldn't create new class 'Thunderstorm'";
5296     throw SquirrelError(v, msg.str());
5297   }
5298   sq_pushstring(v, "start", -1);
5299   sq_newclosure(v, &Thunderstorm_start_wrapper, 0);
5300   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5301   if(SQ_FAILED(sq_createslot(v, -3))) {
5302     throw SquirrelError(v, "Couldn't register function 'start'");
5303   }
5304
5305   sq_pushstring(v, "stop", -1);
5306   sq_newclosure(v, &Thunderstorm_stop_wrapper, 0);
5307   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5308   if(SQ_FAILED(sq_createslot(v, -3))) {
5309     throw SquirrelError(v, "Couldn't register function 'stop'");
5310   }
5311
5312   sq_pushstring(v, "thunder", -1);
5313   sq_newclosure(v, &Thunderstorm_thunder_wrapper, 0);
5314   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5315   if(SQ_FAILED(sq_createslot(v, -3))) {
5316     throw SquirrelError(v, "Couldn't register function 'thunder'");
5317   }
5318
5319   sq_pushstring(v, "lightning", -1);
5320   sq_newclosure(v, &Thunderstorm_lightning_wrapper, 0);
5321   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5322   if(SQ_FAILED(sq_createslot(v, -3))) {
5323     throw SquirrelError(v, "Couldn't register function 'lightning'");
5324   }
5325
5326   sq_pushstring(v, "flash", -1);
5327   sq_newclosure(v, &Thunderstorm_flash_wrapper, 0);
5328   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5329   if(SQ_FAILED(sq_createslot(v, -3))) {
5330     throw SquirrelError(v, "Couldn't register function 'flash'");
5331   }
5332
5333   sq_pushstring(v, "electrify", -1);
5334   sq_newclosure(v, &Thunderstorm_electrify_wrapper, 0);
5335   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5336   if(SQ_FAILED(sq_createslot(v, -3))) {
5337     throw SquirrelError(v, "Couldn't register function 'electrify'");
5338   }
5339
5340   if(SQ_FAILED(sq_createslot(v, -3))) {
5341     throw SquirrelError(v, "Couldn't register class 'Thunderstorm'");
5342   }
5343
5344   // Register class TileMap
5345   sq_pushstring(v, "TileMap", -1);
5346   if(sq_newclass(v, SQFalse) < 0) {
5347     std::ostringstream msg;
5348     msg << "Couldn't create new class 'TileMap'";
5349     throw SquirrelError(v, msg.str());
5350   }
5351   sq_pushstring(v, "goto_node", -1);
5352   sq_newclosure(v, &TileMap_goto_node_wrapper, 0);
5353   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ti");
5354   if(SQ_FAILED(sq_createslot(v, -3))) {
5355     throw SquirrelError(v, "Couldn't register function 'goto_node'");
5356   }
5357
5358   sq_pushstring(v, "start_moving", -1);
5359   sq_newclosure(v, &TileMap_start_moving_wrapper, 0);
5360   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5361   if(SQ_FAILED(sq_createslot(v, -3))) {
5362     throw SquirrelError(v, "Couldn't register function 'start_moving'");
5363   }
5364
5365   sq_pushstring(v, "stop_moving", -1);
5366   sq_newclosure(v, &TileMap_stop_moving_wrapper, 0);
5367   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5368   if(SQ_FAILED(sq_createslot(v, -3))) {
5369     throw SquirrelError(v, "Couldn't register function 'stop_moving'");
5370   }
5371
5372   sq_pushstring(v, "fade", -1);
5373   sq_newclosure(v, &TileMap_fade_wrapper, 0);
5374   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tnn");
5375   if(SQ_FAILED(sq_createslot(v, -3))) {
5376     throw SquirrelError(v, "Couldn't register function 'fade'");
5377   }
5378
5379   sq_pushstring(v, "set_alpha", -1);
5380   sq_newclosure(v, &TileMap_set_alpha_wrapper, 0);
5381   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|tn");
5382   if(SQ_FAILED(sq_createslot(v, -3))) {
5383     throw SquirrelError(v, "Couldn't register function 'set_alpha'");
5384   }
5385
5386   sq_pushstring(v, "get_alpha", -1);
5387   sq_newclosure(v, &TileMap_get_alpha_wrapper, 0);
5388   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5389   if(SQ_FAILED(sq_createslot(v, -3))) {
5390     throw SquirrelError(v, "Couldn't register function 'get_alpha'");
5391   }
5392
5393   if(SQ_FAILED(sq_createslot(v, -3))) {
5394     throw SquirrelError(v, "Couldn't register class 'TileMap'");
5395   }
5396
5397   // Register class WillOWisp
5398   sq_pushstring(v, "WillOWisp", -1);
5399   if(sq_newclass(v, SQFalse) < 0) {
5400     std::ostringstream msg;
5401     msg << "Couldn't create new class 'WillOWisp'";
5402     throw SquirrelError(v, msg.str());
5403   }
5404   sq_pushstring(v, "goto_node", -1);
5405   sq_newclosure(v, &WillOWisp_goto_node_wrapper, 0);
5406   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ti");
5407   if(SQ_FAILED(sq_createslot(v, -3))) {
5408     throw SquirrelError(v, "Couldn't register function 'goto_node'");
5409   }
5410
5411   sq_pushstring(v, "set_state", -1);
5412   sq_newclosure(v, &WillOWisp_set_state_wrapper, 0);
5413   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|ts");
5414   if(SQ_FAILED(sq_createslot(v, -3))) {
5415     throw SquirrelError(v, "Couldn't register function 'set_state'");
5416   }
5417
5418   sq_pushstring(v, "start_moving", -1);
5419   sq_newclosure(v, &WillOWisp_start_moving_wrapper, 0);
5420   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5421   if(SQ_FAILED(sq_createslot(v, -3))) {
5422     throw SquirrelError(v, "Couldn't register function 'start_moving'");
5423   }
5424
5425   sq_pushstring(v, "stop_moving", -1);
5426   sq_newclosure(v, &WillOWisp_stop_moving_wrapper, 0);
5427   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5428   if(SQ_FAILED(sq_createslot(v, -3))) {
5429     throw SquirrelError(v, "Couldn't register function 'stop_moving'");
5430   }
5431
5432   if(SQ_FAILED(sq_createslot(v, -3))) {
5433     throw SquirrelError(v, "Couldn't register class 'WillOWisp'");
5434   }
5435
5436   // Register class Wind
5437   sq_pushstring(v, "Wind", -1);
5438   if(sq_newclass(v, SQFalse) < 0) {
5439     std::ostringstream msg;
5440     msg << "Couldn't create new class 'Wind'";
5441     throw SquirrelError(v, msg.str());
5442   }
5443   sq_pushstring(v, "start", -1);
5444   sq_newclosure(v, &Wind_start_wrapper, 0);
5445   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5446   if(SQ_FAILED(sq_createslot(v, -3))) {
5447     throw SquirrelError(v, "Couldn't register function 'start'");
5448   }
5449
5450   sq_pushstring(v, "stop", -1);
5451   sq_newclosure(v, &Wind_stop_wrapper, 0);
5452   sq_setparamscheck(v, SQ_MATCHTYPEMASKSTRING, "x|t");
5453   if(SQ_FAILED(sq_createslot(v, -3))) {
5454     throw SquirrelError(v, "Couldn't register function 'stop'");
5455   }
5456
5457   if(SQ_FAILED(sq_createslot(v, -3))) {
5458     throw SquirrelError(v, "Couldn't register class 'Wind'");
5459   }
5460
5461 }
5462
5463 } // end of namespace Scripting
5464
5465 /* EOF */