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