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