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 display_wrapper(HSQUIRRELVM vm)
2899 {
2900   return Scripting::display(vm);
2901 }
2902
2903 static SQInteger print_stacktrace_wrapper(HSQUIRRELVM vm)
2904 {
2905   HSQUIRRELVM arg0 = vm;
2906
2907   try {
2908     Scripting::print_stacktrace(arg0);
2909
2910     return 0;
2911
2912   } catch(std::exception& e) {
2913     sq_throwerror(vm, e.what());
2914     return SQ_ERROR;
2915   } catch(...) {
2916     sq_throwerror(vm, _SC("Unexpected exception while executing function 'print_stacktrace'"));
2917     return SQ_ERROR;
2918   }
2919
2920 }
2921
2922 static SQInteger get_current_thread_wrapper(HSQUIRRELVM vm)
2923 {
2924   return Scripting::get_current_thread(vm);
2925 }
2926
2927 static SQInteger display_text_file_wrapper(HSQUIRRELVM vm)
2928 {
2929   const SQChar* arg0;
2930   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2931     sq_throwerror(vm, _SC("Argument 1 not a string"));
2932     return SQ_ERROR;
2933   }
2934
2935   try {
2936     Scripting::display_text_file(arg0);
2937
2938     return 0;
2939
2940   } catch(std::exception& e) {
2941     sq_throwerror(vm, e.what());
2942     return SQ_ERROR;
2943   } catch(...) {
2944     sq_throwerror(vm, _SC("Unexpected exception while executing function 'display_text_file'"));
2945     return SQ_ERROR;
2946   }
2947
2948 }
2949
2950 static SQInteger load_worldmap_wrapper(HSQUIRRELVM vm)
2951 {
2952   const SQChar* arg0;
2953   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2954     sq_throwerror(vm, _SC("Argument 1 not a string"));
2955     return SQ_ERROR;
2956   }
2957
2958   try {
2959     Scripting::load_worldmap(arg0);
2960
2961     return 0;
2962
2963   } catch(std::exception& e) {
2964     sq_throwerror(vm, e.what());
2965     return SQ_ERROR;
2966   } catch(...) {
2967     sq_throwerror(vm, _SC("Unexpected exception while executing function 'load_worldmap'"));
2968     return SQ_ERROR;
2969   }
2970
2971 }
2972
2973 static SQInteger load_level_wrapper(HSQUIRRELVM vm)
2974 {
2975   const SQChar* arg0;
2976   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2977     sq_throwerror(vm, _SC("Argument 1 not a string"));
2978     return SQ_ERROR;
2979   }
2980
2981   try {
2982     Scripting::load_level(arg0);
2983
2984     return 0;
2985
2986   } catch(std::exception& e) {
2987     sq_throwerror(vm, e.what());
2988     return SQ_ERROR;
2989   } catch(...) {
2990     sq_throwerror(vm, _SC("Unexpected exception while executing function 'load_level'"));
2991     return SQ_ERROR;
2992   }
2993
2994 }
2995
2996 static SQInteger wait_wrapper(HSQUIRRELVM vm)
2997 {
2998   HSQUIRRELVM arg0 = vm;
2999   SQFloat arg1;
3000   if(SQ_FAILED(sq_getfloat(vm, 2, &arg1))) {
3001     sq_throwerror(vm, _SC("Argument 1 not a float"));
3002     return SQ_ERROR;
3003   }
3004
3005   try {
3006     Scripting::wait(arg0, static_cast<float> (arg1));
3007
3008     return sq_suspendvm(vm);
3009
3010   } catch(std::exception& e) {
3011     sq_throwerror(vm, e.what());
3012     return SQ_ERROR;
3013   } catch(...) {
3014     sq_throwerror(vm, _SC("Unexpected exception while executing function 'wait'"));
3015     return SQ_ERROR;
3016   }
3017
3018 }
3019
3020 static SQInteger wait_for_screenswitch_wrapper(HSQUIRRELVM vm)
3021 {
3022   HSQUIRRELVM arg0 = vm;
3023
3024   try {
3025     Scripting::wait_for_screenswitch(arg0);
3026
3027     return sq_suspendvm(vm);
3028
3029   } catch(std::exception& e) {
3030     sq_throwerror(vm, e.what());
3031     return SQ_ERROR;
3032   } catch(...) {
3033     sq_throwerror(vm, _SC("Unexpected exception while executing function 'wait_for_screenswitch'"));
3034     return SQ_ERROR;
3035   }
3036
3037 }
3038
3039 static SQInteger exit_screen_wrapper(HSQUIRRELVM vm)
3040 {
3041   (void) vm;
3042
3043   try {
3044     Scripting::exit_screen();
3045
3046     return 0;
3047
3048   } catch(std::exception& e) {
3049     sq_throwerror(vm, e.what());
3050     return SQ_ERROR;
3051   } catch(...) {
3052     sq_throwerror(vm, _SC("Unexpected exception while executing function 'exit_screen'"));
3053     return SQ_ERROR;
3054   }
3055
3056 }
3057
3058 static SQInteger fadeout_screen_wrapper(HSQUIRRELVM vm)
3059 {
3060   SQFloat arg0;
3061   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
3062     sq_throwerror(vm, _SC("Argument 1 not a float"));
3063     return SQ_ERROR;
3064   }
3065
3066   try {
3067     Scripting::fadeout_screen(static_cast<float> (arg0));
3068
3069     return 0;
3070
3071   } catch(std::exception& e) {
3072     sq_throwerror(vm, e.what());
3073     return SQ_ERROR;
3074   } catch(...) {
3075     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fadeout_screen'"));
3076     return SQ_ERROR;
3077   }
3078
3079 }
3080
3081 static SQInteger shrink_screen_wrapper(HSQUIRRELVM vm)
3082 {
3083   SQFloat arg0;
3084   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
3085     sq_throwerror(vm, _SC("Argument 1 not a float"));
3086     return SQ_ERROR;
3087   }
3088   SQFloat arg1;
3089   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
3090     sq_throwerror(vm, _SC("Argument 2 not a float"));
3091     return SQ_ERROR;
3092   }
3093   SQFloat arg2;
3094   if(SQ_FAILED(sq_getfloat(vm, 4, &arg2))) {
3095     sq_throwerror(vm, _SC("Argument 3 not a float"));
3096     return SQ_ERROR;
3097   }
3098
3099   try {
3100     Scripting::shrink_screen(static_cast<float> (arg0), static_cast<float> (arg1), static_cast<float> (arg2));
3101
3102     return 0;
3103
3104   } catch(std::exception& e) {
3105     sq_throwerror(vm, e.what());
3106     return SQ_ERROR;
3107   } catch(...) {
3108     sq_throwerror(vm, _SC("Unexpected exception while executing function 'shrink_screen'"));
3109     return SQ_ERROR;
3110   }
3111
3112 }
3113
3114 static SQInteger abort_screenfade_wrapper(HSQUIRRELVM vm)
3115 {
3116   (void) vm;
3117
3118   try {
3119     Scripting::abort_screenfade();
3120
3121     return 0;
3122
3123   } catch(std::exception& e) {
3124     sq_throwerror(vm, e.what());
3125     return SQ_ERROR;
3126   } catch(...) {
3127     sq_throwerror(vm, _SC("Unexpected exception while executing function 'abort_screenfade'"));
3128     return SQ_ERROR;
3129   }
3130
3131 }
3132
3133 static SQInteger translate_wrapper(HSQUIRRELVM vm)
3134 {
3135   const SQChar* arg0;
3136   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
3137     sq_throwerror(vm, _SC("Argument 1 not a string"));
3138     return SQ_ERROR;
3139   }
3140
3141   try {
3142     std::string return_value = Scripting::translate(arg0);
3143
3144     sq_pushstring(vm, return_value.c_str(), return_value.size());
3145     return 1;
3146
3147   } catch(std::exception& e) {
3148     sq_throwerror(vm, e.what());
3149     return SQ_ERROR;
3150   } catch(...) {
3151     sq_throwerror(vm, _SC("Unexpected exception while executing function 'translate'"));
3152     return SQ_ERROR;
3153   }
3154
3155 }
3156
3157 static SQInteger import_wrapper(HSQUIRRELVM vm)
3158 {
3159   HSQUIRRELVM arg0 = vm;
3160   const SQChar* arg1;
3161   if(SQ_FAILED(sq_getstring(vm, 2, &arg1))) {
3162     sq_throwerror(vm, _SC("Argument 1 not a string"));
3163     return SQ_ERROR;
3164   }
3165
3166   try {
3167     Scripting::import(arg0, arg1);
3168
3169     return 0;
3170
3171   } catch(std::exception& e) {
3172     sq_throwerror(vm, e.what());
3173     return SQ_ERROR;
3174   } catch(...) {
3175     sq_throwerror(vm, _SC("Unexpected exception while executing function 'import'"));
3176     return SQ_ERROR;
3177   }
3178
3179 }
3180
3181 static SQInteger save_state_wrapper(HSQUIRRELVM vm)
3182 {
3183   (void) vm;
3184
3185   try {
3186     Scripting::save_state();
3187
3188     return 0;
3189
3190   } catch(std::exception& e) {
3191     sq_throwerror(vm, e.what());
3192     return SQ_ERROR;
3193   } catch(...) {
3194     sq_throwerror(vm, _SC("Unexpected exception while executing function 'save_state'"));
3195     return SQ_ERROR;
3196   }
3197
3198 }
3199
3200 static SQInteger update_worldmap_wrapper(HSQUIRRELVM vm)
3201 {
3202   (void) vm;
3203
3204   try {
3205     Scripting::update_worldmap();
3206
3207     return 0;
3208
3209   } catch(std::exception& e) {
3210     sq_throwerror(vm, e.what());
3211     return SQ_ERROR;
3212   } catch(...) {
3213     sq_throwerror(vm, _SC("Unexpected exception while executing function 'update_worldmap'"));
3214     return SQ_ERROR;
3215   }
3216
3217 }
3218
3219 static SQInteger debug_collrects_wrapper(HSQUIRRELVM vm)
3220 {
3221   SQBool arg0;
3222   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
3223     sq_throwerror(vm, _SC("Argument 1 not a bool"));
3224     return SQ_ERROR;
3225   }
3226
3227   try {
3228     Scripting::debug_collrects(arg0 == SQTrue);
3229
3230     return 0;
3231
3232   } catch(std::exception& e) {
3233     sq_throwerror(vm, e.what());
3234     return SQ_ERROR;
3235   } catch(...) {
3236     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_collrects'"));
3237     return SQ_ERROR;
3238   }
3239
3240 }
3241
3242 static SQInteger debug_show_fps_wrapper(HSQUIRRELVM vm)
3243 {
3244   SQBool arg0;
3245   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
3246     sq_throwerror(vm, _SC("Argument 1 not a bool"));
3247     return SQ_ERROR;
3248   }
3249
3250   try {
3251     Scripting::debug_show_fps(arg0 == SQTrue);
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 'debug_show_fps'"));
3260     return SQ_ERROR;
3261   }
3262
3263 }
3264
3265 static SQInteger debug_draw_solids_only_wrapper(HSQUIRRELVM vm)
3266 {
3267   SQBool arg0;
3268   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
3269     sq_throwerror(vm, _SC("Argument 1 not a bool"));
3270     return SQ_ERROR;
3271   }
3272
3273   try {
3274     Scripting::debug_draw_solids_only(arg0 == SQTrue);
3275
3276     return 0;
3277
3278   } catch(std::exception& e) {
3279     sq_throwerror(vm, e.what());
3280     return SQ_ERROR;
3281   } catch(...) {
3282     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_draw_solids_only'"));
3283     return SQ_ERROR;
3284   }
3285
3286 }
3287
3288 static SQInteger play_music_wrapper(HSQUIRRELVM vm)
3289 {
3290   const SQChar* arg0;
3291   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
3292     sq_throwerror(vm, _SC("Argument 1 not a string"));
3293     return SQ_ERROR;
3294   }
3295
3296   try {
3297     Scripting::play_music(arg0);
3298
3299     return 0;
3300
3301   } catch(std::exception& e) {
3302     sq_throwerror(vm, e.what());
3303     return SQ_ERROR;
3304   } catch(...) {
3305     sq_throwerror(vm, _SC("Unexpected exception while executing function 'play_music'"));
3306     return SQ_ERROR;
3307   }
3308
3309 }
3310
3311 static SQInteger play_sound_wrapper(HSQUIRRELVM vm)
3312 {
3313   const SQChar* arg0;
3314   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
3315     sq_throwerror(vm, _SC("Argument 1 not a string"));
3316     return SQ_ERROR;
3317   }
3318
3319   try {
3320     Scripting::play_sound(arg0);
3321
3322     return 0;
3323
3324   } catch(std::exception& e) {
3325     sq_throwerror(vm, e.what());
3326     return SQ_ERROR;
3327   } catch(...) {
3328     sq_throwerror(vm, _SC("Unexpected exception while executing function 'play_sound'"));
3329     return SQ_ERROR;
3330   }
3331
3332 }
3333
3334 static SQInteger grease_wrapper(HSQUIRRELVM vm)
3335 {
3336   (void) vm;
3337
3338   try {
3339     Scripting::grease();
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 'grease'"));
3348     return SQ_ERROR;
3349   }
3350
3351 }
3352
3353 static SQInteger invincible_wrapper(HSQUIRRELVM vm)
3354 {
3355   (void) vm;
3356
3357   try {
3358     Scripting::invincible();
3359
3360     return 0;
3361
3362   } catch(std::exception& e) {
3363     sq_throwerror(vm, e.what());
3364     return SQ_ERROR;
3365   } catch(...) {
3366     sq_throwerror(vm, _SC("Unexpected exception while executing function 'invincible'"));
3367     return SQ_ERROR;
3368   }
3369
3370 }
3371
3372 static SQInteger ghost_wrapper(HSQUIRRELVM vm)
3373 {
3374   (void) vm;
3375
3376   try {
3377     Scripting::ghost();
3378
3379     return 0;
3380
3381   } catch(std::exception& e) {
3382     sq_throwerror(vm, e.what());
3383     return SQ_ERROR;
3384   } catch(...) {
3385     sq_throwerror(vm, _SC("Unexpected exception while executing function 'ghost'"));
3386     return SQ_ERROR;
3387   }
3388
3389 }
3390
3391 static SQInteger mortal_wrapper(HSQUIRRELVM vm)
3392 {
3393   (void) vm;
3394
3395   try {
3396     Scripting::mortal();
3397
3398     return 0;
3399
3400   } catch(std::exception& e) {
3401     sq_throwerror(vm, e.what());
3402     return SQ_ERROR;
3403   } catch(...) {
3404     sq_throwerror(vm, _SC("Unexpected exception while executing function 'mortal'"));
3405     return SQ_ERROR;
3406   }
3407
3408 }
3409
3410 static SQInteger restart_wrapper(HSQUIRRELVM vm)
3411 {
3412   (void) vm;
3413
3414   try {
3415     Scripting::restart();
3416
3417     return 0;
3418
3419   } catch(std::exception& e) {
3420     sq_throwerror(vm, e.what());
3421     return SQ_ERROR;
3422   } catch(...) {
3423     sq_throwerror(vm, _SC("Unexpected exception while executing function 'restart'"));
3424     return SQ_ERROR;
3425   }
3426
3427 }
3428
3429 static SQInteger whereami_wrapper(HSQUIRRELVM vm)
3430 {
3431   (void) vm;
3432
3433   try {
3434     Scripting::whereami();
3435
3436     return 0;
3437
3438   } catch(std::exception& e) {
3439     sq_throwerror(vm, e.what());
3440     return SQ_ERROR;
3441   } catch(...) {
3442     sq_throwerror(vm, _SC("Unexpected exception while executing function 'whereami'"));
3443     return SQ_ERROR;
3444   }
3445
3446 }
3447
3448 static SQInteger gotoend_wrapper(HSQUIRRELVM vm)
3449 {
3450   (void) vm;
3451
3452   try {
3453     Scripting::gotoend();
3454
3455     return 0;
3456
3457   } catch(std::exception& e) {
3458     sq_throwerror(vm, e.what());
3459     return SQ_ERROR;
3460   } catch(...) {
3461     sq_throwerror(vm, _SC("Unexpected exception while executing function 'gotoend'"));
3462     return SQ_ERROR;
3463   }
3464
3465 }
3466
3467 static SQInteger camera_wrapper(HSQUIRRELVM vm)
3468 {
3469   (void) vm;
3470
3471   try {
3472     Scripting::camera();
3473
3474     return 0;
3475
3476   } catch(std::exception& e) {
3477     sq_throwerror(vm, e.what());
3478     return SQ_ERROR;
3479   } catch(...) {
3480     sq_throwerror(vm, _SC("Unexpected exception while executing function 'camera'"));
3481     return SQ_ERROR;
3482   }
3483
3484 }
3485
3486 static SQInteger quit_wrapper(HSQUIRRELVM vm)
3487 {
3488   (void) vm;
3489
3490   try {
3491     Scripting::quit();
3492
3493     return 0;
3494
3495   } catch(std::exception& e) {
3496     sq_throwerror(vm, e.what());
3497     return SQ_ERROR;
3498   } catch(...) {
3499     sq_throwerror(vm, _SC("Unexpected exception while executing function 'quit'"));
3500     return SQ_ERROR;
3501   }
3502
3503 }
3504
3505 static SQInteger rand_wrapper(HSQUIRRELVM vm)
3506 {
3507
3508   try {
3509     int return_value = Scripting::rand();
3510
3511     sq_pushinteger(vm, return_value);
3512     return 1;
3513
3514   } catch(std::exception& e) {
3515     sq_throwerror(vm, e.what());
3516     return SQ_ERROR;
3517   } catch(...) {
3518     sq_throwerror(vm, _SC("Unexpected exception while executing function 'rand'"));
3519     return SQ_ERROR;
3520   }
3521
3522 }
3523
3524 } // end of namespace Wrapper
3525 void create_squirrel_instance(HSQUIRRELVM v, Scripting::DisplayEffect* object, bool setup_releasehook)
3526 {
3527   using namespace Wrapper;
3528
3529   sq_pushroottable(v);
3530   sq_pushstring(v, "DisplayEffect", -1);
3531   if(SQ_FAILED(sq_get(v, -2))) {
3532     std::ostringstream msg;
3533     msg << "Couldn't resolved squirrel type 'DisplayEffect'";
3534     throw SquirrelError(v, msg.str());
3535   }
3536
3537   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3538     std::ostringstream msg;
3539     msg << "Couldn't setup squirrel instance for object of type 'DisplayEffect'";
3540     throw SquirrelError(v, msg.str());
3541   }
3542   sq_remove(v, -2); // remove object name
3543
3544   if(setup_releasehook) {
3545     sq_setreleasehook(v, -1, DisplayEffect_release_hook);
3546   }
3547
3548   sq_remove(v, -2); // remove root table
3549 }
3550
3551 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Camera* object, bool setup_releasehook)
3552 {
3553   using namespace Wrapper;
3554
3555   sq_pushroottable(v);
3556   sq_pushstring(v, "Camera", -1);
3557   if(SQ_FAILED(sq_get(v, -2))) {
3558     std::ostringstream msg;
3559     msg << "Couldn't resolved squirrel type 'Camera'";
3560     throw SquirrelError(v, msg.str());
3561   }
3562
3563   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3564     std::ostringstream msg;
3565     msg << "Couldn't setup squirrel instance for object of type 'Camera'";
3566     throw SquirrelError(v, msg.str());
3567   }
3568   sq_remove(v, -2); // remove object name
3569
3570   if(setup_releasehook) {
3571     sq_setreleasehook(v, -1, Camera_release_hook);
3572   }
3573
3574   sq_remove(v, -2); // remove root table
3575 }
3576
3577 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Level* object, bool setup_releasehook)
3578 {
3579   using namespace Wrapper;
3580
3581   sq_pushroottable(v);
3582   sq_pushstring(v, "Level", -1);
3583   if(SQ_FAILED(sq_get(v, -2))) {
3584     std::ostringstream msg;
3585     msg << "Couldn't resolved squirrel type 'Level'";
3586     throw SquirrelError(v, msg.str());
3587   }
3588
3589   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3590     std::ostringstream msg;
3591     msg << "Couldn't setup squirrel instance for object of type 'Level'";
3592     throw SquirrelError(v, msg.str());
3593   }
3594   sq_remove(v, -2); // remove object name
3595
3596   if(setup_releasehook) {
3597     sq_setreleasehook(v, -1, Level_release_hook);
3598   }
3599
3600   sq_remove(v, -2); // remove root table
3601 }
3602
3603 void create_squirrel_instance(HSQUIRRELVM v, Scripting::ScriptedObject* object, bool setup_releasehook)
3604 {
3605   using namespace Wrapper;
3606
3607   sq_pushroottable(v);
3608   sq_pushstring(v, "ScriptedObject", -1);
3609   if(SQ_FAILED(sq_get(v, -2))) {
3610     std::ostringstream msg;
3611     msg << "Couldn't resolved squirrel type 'ScriptedObject'";
3612     throw SquirrelError(v, msg.str());
3613   }
3614
3615   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3616     std::ostringstream msg;
3617     msg << "Couldn't setup squirrel instance for object of type 'ScriptedObject'";
3618     throw SquirrelError(v, msg.str());
3619   }
3620   sq_remove(v, -2); // remove object name
3621
3622   if(setup_releasehook) {
3623     sq_setreleasehook(v, -1, ScriptedObject_release_hook);
3624   }
3625
3626   sq_remove(v, -2); // remove root table
3627 }
3628
3629 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Text* object, bool setup_releasehook)
3630 {
3631   using namespace Wrapper;
3632
3633   sq_pushroottable(v);
3634   sq_pushstring(v, "Text", -1);
3635   if(SQ_FAILED(sq_get(v, -2))) {
3636     std::ostringstream msg;
3637     msg << "Couldn't resolved squirrel type 'Text'";
3638     throw SquirrelError(v, msg.str());
3639   }
3640
3641   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3642     std::ostringstream msg;
3643     msg << "Couldn't setup squirrel instance for object of type 'Text'";
3644     throw SquirrelError(v, msg.str());
3645   }
3646   sq_remove(v, -2); // remove object name
3647
3648   if(setup_releasehook) {
3649     sq_setreleasehook(v, -1, Text_release_hook);
3650   }
3651
3652   sq_remove(v, -2); // remove root table
3653 }
3654
3655 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Player* object, bool setup_releasehook)
3656 {
3657   using namespace Wrapper;
3658
3659   sq_pushroottable(v);
3660   sq_pushstring(v, "Player", -1);
3661   if(SQ_FAILED(sq_get(v, -2))) {
3662     std::ostringstream msg;
3663     msg << "Couldn't resolved squirrel type 'Player'";
3664     throw SquirrelError(v, msg.str());
3665   }
3666
3667   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3668     std::ostringstream msg;
3669     msg << "Couldn't setup squirrel instance for object of type 'Player'";
3670     throw SquirrelError(v, msg.str());
3671   }
3672   sq_remove(v, -2); // remove object name
3673
3674   if(setup_releasehook) {
3675     sq_setreleasehook(v, -1, Player_release_hook);
3676   }
3677
3678   sq_remove(v, -2); // remove root table
3679 }
3680
3681 void create_squirrel_instance(HSQUIRRELVM v, Scripting::FloatingImage* object, bool setup_releasehook)
3682 {
3683   using namespace Wrapper;
3684
3685   sq_pushroottable(v);
3686   sq_pushstring(v, "FloatingImage", -1);
3687   if(SQ_FAILED(sq_get(v, -2))) {
3688     std::ostringstream msg;
3689     msg << "Couldn't resolved squirrel type 'FloatingImage'";
3690     throw SquirrelError(v, msg.str());
3691   }
3692
3693   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3694     std::ostringstream msg;
3695     msg << "Couldn't setup squirrel instance for object of type 'FloatingImage'";
3696     throw SquirrelError(v, msg.str());
3697   }
3698   sq_remove(v, -2); // remove object name
3699
3700   if(setup_releasehook) {
3701     sq_setreleasehook(v, -1, FloatingImage_release_hook);
3702   }
3703
3704   sq_remove(v, -2); // remove root table
3705 }
3706
3707 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Platform* object, bool setup_releasehook)
3708 {
3709   using namespace Wrapper;
3710
3711   sq_pushroottable(v);
3712   sq_pushstring(v, "Platform", -1);
3713   if(SQ_FAILED(sq_get(v, -2))) {
3714     std::ostringstream msg;
3715     msg << "Couldn't resolved squirrel type 'Platform'";
3716     throw SquirrelError(v, msg.str());
3717   }
3718
3719   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3720     std::ostringstream msg;
3721     msg << "Couldn't setup squirrel instance for object of type 'Platform'";
3722     throw SquirrelError(v, msg.str());
3723   }
3724   sq_remove(v, -2); // remove object name
3725
3726   if(setup_releasehook) {
3727     sq_setreleasehook(v, -1, Platform_release_hook);
3728   }
3729
3730   sq_remove(v, -2); // remove root table
3731 }
3732
3733 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Candle* object, bool setup_releasehook)
3734 {
3735   using namespace Wrapper;
3736
3737   sq_pushroottable(v);
3738   sq_pushstring(v, "Candle", -1);
3739   if(SQ_FAILED(sq_get(v, -2))) {
3740     std::ostringstream msg;
3741     msg << "Couldn't resolved squirrel type 'Candle'";
3742     throw SquirrelError(v, msg.str());
3743   }
3744
3745   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3746     std::ostringstream msg;
3747     msg << "Couldn't setup squirrel instance for object of type 'Candle'";
3748     throw SquirrelError(v, msg.str());
3749   }
3750   sq_remove(v, -2); // remove object name
3751
3752   if(setup_releasehook) {
3753     sq_setreleasehook(v, -1, Candle_release_hook);
3754   }
3755
3756   sq_remove(v, -2); // remove root table
3757 }
3758
3759 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Wind* object, bool setup_releasehook)
3760 {
3761   using namespace Wrapper;
3762
3763   sq_pushroottable(v);
3764   sq_pushstring(v, "Wind", -1);
3765   if(SQ_FAILED(sq_get(v, -2))) {
3766     std::ostringstream msg;
3767     msg << "Couldn't resolved squirrel type 'Wind'";
3768     throw SquirrelError(v, msg.str());
3769   }
3770
3771   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3772     std::ostringstream msg;
3773     msg << "Couldn't setup squirrel instance for object of type 'Wind'";
3774     throw SquirrelError(v, msg.str());
3775   }
3776   sq_remove(v, -2); // remove object name
3777
3778   if(setup_releasehook) {
3779     sq_setreleasehook(v, -1, Wind_release_hook);
3780   }
3781
3782   sq_remove(v, -2); // remove root table
3783 }
3784
3785 void create_squirrel_instance(HSQUIRRELVM v, Scripting::AmbientSound* object, bool setup_releasehook)
3786 {
3787   using namespace Wrapper;
3788
3789   sq_pushroottable(v);
3790   sq_pushstring(v, "AmbientSound", -1);
3791   if(SQ_FAILED(sq_get(v, -2))) {
3792     std::ostringstream msg;
3793     msg << "Couldn't resolved squirrel type 'AmbientSound'";
3794     throw SquirrelError(v, msg.str());
3795   }
3796
3797   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3798     std::ostringstream msg;
3799     msg << "Couldn't setup squirrel instance for object of type 'AmbientSound'";
3800     throw SquirrelError(v, msg.str());
3801   }
3802   sq_remove(v, -2); // remove object name
3803
3804   if(setup_releasehook) {
3805     sq_setreleasehook(v, -1, AmbientSound_release_hook);
3806   }
3807
3808   sq_remove(v, -2); // remove root table
3809 }
3810
3811 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Thunderstorm* object, bool setup_releasehook)
3812 {
3813   using namespace Wrapper;
3814
3815   sq_pushroottable(v);
3816   sq_pushstring(v, "Thunderstorm", -1);
3817   if(SQ_FAILED(sq_get(v, -2))) {
3818     std::ostringstream msg;
3819     msg << "Couldn't resolved squirrel type 'Thunderstorm'";
3820     throw SquirrelError(v, msg.str());
3821   }
3822
3823   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3824     std::ostringstream msg;
3825     msg << "Couldn't setup squirrel instance for object of type 'Thunderstorm'";
3826     throw SquirrelError(v, msg.str());
3827   }
3828   sq_remove(v, -2); // remove object name
3829
3830   if(setup_releasehook) {
3831     sq_setreleasehook(v, -1, Thunderstorm_release_hook);
3832   }
3833
3834   sq_remove(v, -2); // remove root table
3835 }
3836
3837 void create_squirrel_instance(HSQUIRRELVM v, Scripting::TileMap* object, bool setup_releasehook)
3838 {
3839   using namespace Wrapper;
3840
3841   sq_pushroottable(v);
3842   sq_pushstring(v, "TileMap", -1);
3843   if(SQ_FAILED(sq_get(v, -2))) {
3844     std::ostringstream msg;
3845     msg << "Couldn't resolved squirrel type 'TileMap'";
3846     throw SquirrelError(v, msg.str());
3847   }
3848
3849   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3850     std::ostringstream msg;
3851     msg << "Couldn't setup squirrel instance for object of type 'TileMap'";
3852     throw SquirrelError(v, msg.str());
3853   }
3854   sq_remove(v, -2); // remove object name
3855
3856   if(setup_releasehook) {
3857     sq_setreleasehook(v, -1, TileMap_release_hook);
3858   }
3859
3860   sq_remove(v, -2); // remove root table
3861 }
3862
3863 void create_squirrel_instance(HSQUIRRELVM v, Scripting::SSector* object, bool setup_releasehook)
3864 {
3865   using namespace Wrapper;
3866
3867   sq_pushroottable(v);
3868   sq_pushstring(v, "SSector", -1);
3869   if(SQ_FAILED(sq_get(v, -2))) {
3870     std::ostringstream msg;
3871     msg << "Couldn't resolved squirrel type 'SSector'";
3872     throw SquirrelError(v, msg.str());
3873   }
3874
3875   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3876     std::ostringstream msg;
3877     msg << "Couldn't setup squirrel instance for object of type 'SSector'";
3878     throw SquirrelError(v, msg.str());
3879   }
3880   sq_remove(v, -2); // remove object name
3881
3882   if(setup_releasehook) {
3883     sq_setreleasehook(v, -1, SSector_release_hook);
3884   }
3885
3886   sq_remove(v, -2); // remove root table
3887 }
3888
3889 void create_squirrel_instance(HSQUIRRELVM v, Scripting::LevelTime* object, bool setup_releasehook)
3890 {
3891   using namespace Wrapper;
3892
3893   sq_pushroottable(v);
3894   sq_pushstring(v, "LevelTime", -1);
3895   if(SQ_FAILED(sq_get(v, -2))) {
3896     std::ostringstream msg;
3897     msg << "Couldn't resolved squirrel type 'LevelTime'";
3898     throw SquirrelError(v, msg.str());
3899   }
3900
3901   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3902     std::ostringstream msg;
3903     msg << "Couldn't setup squirrel instance for object of type 'LevelTime'";
3904     throw SquirrelError(v, msg.str());
3905   }
3906   sq_remove(v, -2); // remove object name
3907
3908   if(setup_releasehook) {
3909     sq_setreleasehook(v, -1, LevelTime_release_hook);
3910   }
3911
3912   sq_remove(v, -2); // remove root table
3913 }
3914
3915 void register_supertux_wrapper(HSQUIRRELVM v)
3916 {
3917   using namespace Wrapper;
3918
3919   sq_pushstring(v, "ANCHOR_TOP", -1);
3920   sq_pushinteger(v, 16);
3921   if(SQ_FAILED(sq_createslot(v, -3))) {
3922     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP'");
3923   }
3924
3925   sq_pushstring(v, "ANCHOR_BOTTOM", -1);
3926   sq_pushinteger(v, 32);
3927   if(SQ_FAILED(sq_createslot(v, -3))) {
3928     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM'");
3929   }
3930
3931   sq_pushstring(v, "ANCHOR_LEFT", -1);
3932   sq_pushinteger(v, 1);
3933   if(SQ_FAILED(sq_createslot(v, -3))) {
3934     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_LEFT'");
3935   }
3936
3937   sq_pushstring(v, "ANCHOR_RIGHT", -1);
3938   sq_pushinteger(v, 2);
3939   if(SQ_FAILED(sq_createslot(v, -3))) {
3940     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_RIGHT'");
3941   }
3942
3943   sq_pushstring(v, "ANCHOR_MIDDLE", -1);
3944   sq_pushinteger(v, 0);
3945   if(SQ_FAILED(sq_createslot(v, -3))) {
3946     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_MIDDLE'");
3947   }
3948
3949   sq_pushstring(v, "ANCHOR_TOP_LEFT", -1);
3950   sq_pushinteger(v, 17);
3951   if(SQ_FAILED(sq_createslot(v, -3))) {
3952     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP_LEFT'");
3953   }
3954
3955   sq_pushstring(v, "ANCHOR_TOP_RIGHT", -1);
3956   sq_pushinteger(v, 18);
3957   if(SQ_FAILED(sq_createslot(v, -3))) {
3958     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP_RIGHT'");
3959   }
3960
3961   sq_pushstring(v, "ANCHOR_BOTTOM_LEFT", -1);
3962   sq_pushinteger(v, 33);
3963   if(SQ_FAILED(sq_createslot(v, -3))) {
3964     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM_LEFT'");
3965   }
3966
3967   sq_pushstring(v, "ANCHOR_BOTTOM_RIGHT", -1);
3968   sq_pushinteger(v, 34);
3969   if(SQ_FAILED(sq_createslot(v, -3))) {
3970     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM_RIGHT'");
3971   }
3972
3973   sq_pushstring(v, "display", -1);
3974   sq_newclosure(v, &display_wrapper, 0);
3975   if(SQ_FAILED(sq_createslot(v, -3))) {
3976     throw SquirrelError(v, "Couldn't register function 'display'");
3977   }
3978
3979   sq_pushstring(v, "print_stacktrace", -1);
3980   sq_newclosure(v, &print_stacktrace_wrapper, 0);
3981   if(SQ_FAILED(sq_createslot(v, -3))) {
3982     throw SquirrelError(v, "Couldn't register function 'print_stacktrace'");
3983   }
3984
3985   sq_pushstring(v, "get_current_thread", -1);
3986   sq_newclosure(v, &get_current_thread_wrapper, 0);
3987   if(SQ_FAILED(sq_createslot(v, -3))) {
3988     throw SquirrelError(v, "Couldn't register function 'get_current_thread'");
3989   }
3990
3991   sq_pushstring(v, "display_text_file", -1);
3992   sq_newclosure(v, &display_text_file_wrapper, 0);
3993   if(SQ_FAILED(sq_createslot(v, -3))) {
3994     throw SquirrelError(v, "Couldn't register function 'display_text_file'");
3995   }
3996
3997   sq_pushstring(v, "load_worldmap", -1);
3998   sq_newclosure(v, &load_worldmap_wrapper, 0);
3999   if(SQ_FAILED(sq_createslot(v, -3))) {
4000     throw SquirrelError(v, "Couldn't register function 'load_worldmap'");
4001   }
4002
4003   sq_pushstring(v, "load_level", -1);
4004   sq_newclosure(v, &load_level_wrapper, 0);
4005   if(SQ_FAILED(sq_createslot(v, -3))) {
4006     throw SquirrelError(v, "Couldn't register function 'load_level'");
4007   }
4008
4009   sq_pushstring(v, "wait", -1);
4010   sq_newclosure(v, &wait_wrapper, 0);
4011   if(SQ_FAILED(sq_createslot(v, -3))) {
4012     throw SquirrelError(v, "Couldn't register function 'wait'");
4013   }
4014
4015   sq_pushstring(v, "wait_for_screenswitch", -1);
4016   sq_newclosure(v, &wait_for_screenswitch_wrapper, 0);
4017   if(SQ_FAILED(sq_createslot(v, -3))) {
4018     throw SquirrelError(v, "Couldn't register function 'wait_for_screenswitch'");
4019   }
4020
4021   sq_pushstring(v, "exit_screen", -1);
4022   sq_newclosure(v, &exit_screen_wrapper, 0);
4023   if(SQ_FAILED(sq_createslot(v, -3))) {
4024     throw SquirrelError(v, "Couldn't register function 'exit_screen'");
4025   }
4026
4027   sq_pushstring(v, "fadeout_screen", -1);
4028   sq_newclosure(v, &fadeout_screen_wrapper, 0);
4029   if(SQ_FAILED(sq_createslot(v, -3))) {
4030     throw SquirrelError(v, "Couldn't register function 'fadeout_screen'");
4031   }
4032
4033   sq_pushstring(v, "shrink_screen", -1);
4034   sq_newclosure(v, &shrink_screen_wrapper, 0);
4035   if(SQ_FAILED(sq_createslot(v, -3))) {
4036     throw SquirrelError(v, "Couldn't register function 'shrink_screen'");
4037   }
4038
4039   sq_pushstring(v, "abort_screenfade", -1);
4040   sq_newclosure(v, &abort_screenfade_wrapper, 0);
4041   if(SQ_FAILED(sq_createslot(v, -3))) {
4042     throw SquirrelError(v, "Couldn't register function 'abort_screenfade'");
4043   }
4044
4045   sq_pushstring(v, "translate", -1);
4046   sq_newclosure(v, &translate_wrapper, 0);
4047   if(SQ_FAILED(sq_createslot(v, -3))) {
4048     throw SquirrelError(v, "Couldn't register function 'translate'");
4049   }
4050
4051   sq_pushstring(v, "import", -1);
4052   sq_newclosure(v, &import_wrapper, 0);
4053   if(SQ_FAILED(sq_createslot(v, -3))) {
4054     throw SquirrelError(v, "Couldn't register function 'import'");
4055   }
4056
4057   sq_pushstring(v, "save_state", -1);
4058   sq_newclosure(v, &save_state_wrapper, 0);
4059   if(SQ_FAILED(sq_createslot(v, -3))) {
4060     throw SquirrelError(v, "Couldn't register function 'save_state'");
4061   }
4062
4063   sq_pushstring(v, "update_worldmap", -1);
4064   sq_newclosure(v, &update_worldmap_wrapper, 0);
4065   if(SQ_FAILED(sq_createslot(v, -3))) {
4066     throw SquirrelError(v, "Couldn't register function 'update_worldmap'");
4067   }
4068
4069   sq_pushstring(v, "debug_collrects", -1);
4070   sq_newclosure(v, &debug_collrects_wrapper, 0);
4071   if(SQ_FAILED(sq_createslot(v, -3))) {
4072     throw SquirrelError(v, "Couldn't register function 'debug_collrects'");
4073   }
4074
4075   sq_pushstring(v, "debug_show_fps", -1);
4076   sq_newclosure(v, &debug_show_fps_wrapper, 0);
4077   if(SQ_FAILED(sq_createslot(v, -3))) {
4078     throw SquirrelError(v, "Couldn't register function 'debug_show_fps'");
4079   }
4080
4081   sq_pushstring(v, "debug_draw_solids_only", -1);
4082   sq_newclosure(v, &debug_draw_solids_only_wrapper, 0);
4083   if(SQ_FAILED(sq_createslot(v, -3))) {
4084     throw SquirrelError(v, "Couldn't register function 'debug_draw_solids_only'");
4085   }
4086
4087   sq_pushstring(v, "play_music", -1);
4088   sq_newclosure(v, &play_music_wrapper, 0);
4089   if(SQ_FAILED(sq_createslot(v, -3))) {
4090     throw SquirrelError(v, "Couldn't register function 'play_music'");
4091   }
4092
4093   sq_pushstring(v, "play_sound", -1);
4094   sq_newclosure(v, &play_sound_wrapper, 0);
4095   if(SQ_FAILED(sq_createslot(v, -3))) {
4096     throw SquirrelError(v, "Couldn't register function 'play_sound'");
4097   }
4098
4099   sq_pushstring(v, "grease", -1);
4100   sq_newclosure(v, &grease_wrapper, 0);
4101   if(SQ_FAILED(sq_createslot(v, -3))) {
4102     throw SquirrelError(v, "Couldn't register function 'grease'");
4103   }
4104
4105   sq_pushstring(v, "invincible", -1);
4106   sq_newclosure(v, &invincible_wrapper, 0);
4107   if(SQ_FAILED(sq_createslot(v, -3))) {
4108     throw SquirrelError(v, "Couldn't register function 'invincible'");
4109   }
4110
4111   sq_pushstring(v, "ghost", -1);
4112   sq_newclosure(v, &ghost_wrapper, 0);
4113   if(SQ_FAILED(sq_createslot(v, -3))) {
4114     throw SquirrelError(v, "Couldn't register function 'ghost'");
4115   }
4116
4117   sq_pushstring(v, "mortal", -1);
4118   sq_newclosure(v, &mortal_wrapper, 0);
4119   if(SQ_FAILED(sq_createslot(v, -3))) {
4120     throw SquirrelError(v, "Couldn't register function 'mortal'");
4121   }
4122
4123   sq_pushstring(v, "restart", -1);
4124   sq_newclosure(v, &restart_wrapper, 0);
4125   if(SQ_FAILED(sq_createslot(v, -3))) {
4126     throw SquirrelError(v, "Couldn't register function 'restart'");
4127   }
4128
4129   sq_pushstring(v, "whereami", -1);
4130   sq_newclosure(v, &whereami_wrapper, 0);
4131   if(SQ_FAILED(sq_createslot(v, -3))) {
4132     throw SquirrelError(v, "Couldn't register function 'whereami'");
4133   }
4134
4135   sq_pushstring(v, "gotoend", -1);
4136   sq_newclosure(v, &gotoend_wrapper, 0);
4137   if(SQ_FAILED(sq_createslot(v, -3))) {
4138     throw SquirrelError(v, "Couldn't register function 'gotoend'");
4139   }
4140
4141   sq_pushstring(v, "camera", -1);
4142   sq_newclosure(v, &camera_wrapper, 0);
4143   if(SQ_FAILED(sq_createslot(v, -3))) {
4144     throw SquirrelError(v, "Couldn't register function 'camera'");
4145   }
4146
4147   sq_pushstring(v, "quit", -1);
4148   sq_newclosure(v, &quit_wrapper, 0);
4149   if(SQ_FAILED(sq_createslot(v, -3))) {
4150     throw SquirrelError(v, "Couldn't register function 'quit'");
4151   }
4152
4153   sq_pushstring(v, "rand", -1);
4154   sq_newclosure(v, &rand_wrapper, 0);
4155   if(SQ_FAILED(sq_createslot(v, -3))) {
4156     throw SquirrelError(v, "Couldn't register function 'rand'");
4157   }
4158
4159   // Register class DisplayEffect
4160   sq_pushstring(v, "DisplayEffect", -1);
4161   if(sq_newclass(v, SQFalse) < 0) {
4162     std::ostringstream msg;
4163     msg << "Couldn't create new class 'DisplayEffect'";
4164     throw SquirrelError(v, msg.str());
4165   }
4166   sq_pushstring(v, "fade_out", -1);
4167   sq_newclosure(v, &DisplayEffect_fade_out_wrapper, 0);
4168   if(SQ_FAILED(sq_createslot(v, -3))) {
4169     throw SquirrelError(v, "Couldn't register function 'fade_out'");
4170   }
4171
4172   sq_pushstring(v, "fade_in", -1);
4173   sq_newclosure(v, &DisplayEffect_fade_in_wrapper, 0);
4174   if(SQ_FAILED(sq_createslot(v, -3))) {
4175     throw SquirrelError(v, "Couldn't register function 'fade_in'");
4176   }
4177
4178   sq_pushstring(v, "set_black", -1);
4179   sq_newclosure(v, &DisplayEffect_set_black_wrapper, 0);
4180   if(SQ_FAILED(sq_createslot(v, -3))) {
4181     throw SquirrelError(v, "Couldn't register function 'set_black'");
4182   }
4183
4184   sq_pushstring(v, "is_black", -1);
4185   sq_newclosure(v, &DisplayEffect_is_black_wrapper, 0);
4186   if(SQ_FAILED(sq_createslot(v, -3))) {
4187     throw SquirrelError(v, "Couldn't register function 'is_black'");
4188   }
4189
4190   sq_pushstring(v, "sixteen_to_nine", -1);
4191   sq_newclosure(v, &DisplayEffect_sixteen_to_nine_wrapper, 0);
4192   if(SQ_FAILED(sq_createslot(v, -3))) {
4193     throw SquirrelError(v, "Couldn't register function 'sixteen_to_nine'");
4194   }
4195
4196   sq_pushstring(v, "four_to_three", -1);
4197   sq_newclosure(v, &DisplayEffect_four_to_three_wrapper, 0);
4198   if(SQ_FAILED(sq_createslot(v, -3))) {
4199     throw SquirrelError(v, "Couldn't register function 'four_to_three'");
4200   }
4201
4202   if(SQ_FAILED(sq_createslot(v, -3))) {
4203     throw SquirrelError(v, "Couldn't register class 'DisplayEffect'");
4204   }
4205
4206   // Register class Camera
4207   sq_pushstring(v, "Camera", -1);
4208   if(sq_newclass(v, SQFalse) < 0) {
4209     std::ostringstream msg;
4210     msg << "Couldn't create new class 'Camera'";
4211     throw SquirrelError(v, msg.str());
4212   }
4213   sq_pushstring(v, "reload_config", -1);
4214   sq_newclosure(v, &Camera_reload_config_wrapper, 0);
4215   if(SQ_FAILED(sq_createslot(v, -3))) {
4216     throw SquirrelError(v, "Couldn't register function 'reload_config'");
4217   }
4218
4219   sq_pushstring(v, "shake", -1);
4220   sq_newclosure(v, &Camera_shake_wrapper, 0);
4221   if(SQ_FAILED(sq_createslot(v, -3))) {
4222     throw SquirrelError(v, "Couldn't register function 'shake'");
4223   }
4224
4225   sq_pushstring(v, "set_pos", -1);
4226   sq_newclosure(v, &Camera_set_pos_wrapper, 0);
4227   if(SQ_FAILED(sq_createslot(v, -3))) {
4228     throw SquirrelError(v, "Couldn't register function 'set_pos'");
4229   }
4230
4231   sq_pushstring(v, "set_mode", -1);
4232   sq_newclosure(v, &Camera_set_mode_wrapper, 0);
4233   if(SQ_FAILED(sq_createslot(v, -3))) {
4234     throw SquirrelError(v, "Couldn't register function 'set_mode'");
4235   }
4236
4237   sq_pushstring(v, "scroll_to", -1);
4238   sq_newclosure(v, &Camera_scroll_to_wrapper, 0);
4239   if(SQ_FAILED(sq_createslot(v, -3))) {
4240     throw SquirrelError(v, "Couldn't register function 'scroll_to'");
4241   }
4242
4243   if(SQ_FAILED(sq_createslot(v, -3))) {
4244     throw SquirrelError(v, "Couldn't register class 'Camera'");
4245   }
4246
4247   // Register class Level
4248   sq_pushstring(v, "Level", -1);
4249   if(sq_newclass(v, SQFalse) < 0) {
4250     std::ostringstream msg;
4251     msg << "Couldn't create new class 'Level'";
4252     throw SquirrelError(v, msg.str());
4253   }
4254   sq_pushstring(v, "finish", -1);
4255   sq_newclosure(v, &Level_finish_wrapper, 0);
4256   if(SQ_FAILED(sq_createslot(v, -3))) {
4257     throw SquirrelError(v, "Couldn't register function 'finish'");
4258   }
4259
4260   sq_pushstring(v, "spawn", -1);
4261   sq_newclosure(v, &Level_spawn_wrapper, 0);
4262   if(SQ_FAILED(sq_createslot(v, -3))) {
4263     throw SquirrelError(v, "Couldn't register function 'spawn'");
4264   }
4265
4266   sq_pushstring(v, "flip_vertically", -1);
4267   sq_newclosure(v, &Level_flip_vertically_wrapper, 0);
4268   if(SQ_FAILED(sq_createslot(v, -3))) {
4269     throw SquirrelError(v, "Couldn't register function 'flip_vertically'");
4270   }
4271
4272   sq_pushstring(v, "toggle_pause", -1);
4273   sq_newclosure(v, &Level_toggle_pause_wrapper, 0);
4274   if(SQ_FAILED(sq_createslot(v, -3))) {
4275     throw SquirrelError(v, "Couldn't register function 'toggle_pause'");
4276   }
4277
4278   if(SQ_FAILED(sq_createslot(v, -3))) {
4279     throw SquirrelError(v, "Couldn't register class 'Level'");
4280   }
4281
4282   // Register class ScriptedObject
4283   sq_pushstring(v, "ScriptedObject", -1);
4284   if(sq_newclass(v, SQFalse) < 0) {
4285     std::ostringstream msg;
4286     msg << "Couldn't create new class 'ScriptedObject'";
4287     throw SquirrelError(v, msg.str());
4288   }
4289   sq_pushstring(v, "set_action", -1);
4290   sq_newclosure(v, &ScriptedObject_set_action_wrapper, 0);
4291   if(SQ_FAILED(sq_createslot(v, -3))) {
4292     throw SquirrelError(v, "Couldn't register function 'set_action'");
4293   }
4294
4295   sq_pushstring(v, "get_action", -1);
4296   sq_newclosure(v, &ScriptedObject_get_action_wrapper, 0);
4297   if(SQ_FAILED(sq_createslot(v, -3))) {
4298     throw SquirrelError(v, "Couldn't register function 'get_action'");
4299   }
4300
4301   sq_pushstring(v, "move", -1);
4302   sq_newclosure(v, &ScriptedObject_move_wrapper, 0);
4303   if(SQ_FAILED(sq_createslot(v, -3))) {
4304     throw SquirrelError(v, "Couldn't register function 'move'");
4305   }
4306
4307   sq_pushstring(v, "set_pos", -1);
4308   sq_newclosure(v, &ScriptedObject_set_pos_wrapper, 0);
4309   if(SQ_FAILED(sq_createslot(v, -3))) {
4310     throw SquirrelError(v, "Couldn't register function 'set_pos'");
4311   }
4312
4313   sq_pushstring(v, "get_pos_x", -1);
4314   sq_newclosure(v, &ScriptedObject_get_pos_x_wrapper, 0);
4315   if(SQ_FAILED(sq_createslot(v, -3))) {
4316     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
4317   }
4318
4319   sq_pushstring(v, "get_pos_y", -1);
4320   sq_newclosure(v, &ScriptedObject_get_pos_y_wrapper, 0);
4321   if(SQ_FAILED(sq_createslot(v, -3))) {
4322     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
4323   }
4324
4325   sq_pushstring(v, "set_velocity", -1);
4326   sq_newclosure(v, &ScriptedObject_set_velocity_wrapper, 0);
4327   if(SQ_FAILED(sq_createslot(v, -3))) {
4328     throw SquirrelError(v, "Couldn't register function 'set_velocity'");
4329   }
4330
4331   sq_pushstring(v, "get_velocity_x", -1);
4332   sq_newclosure(v, &ScriptedObject_get_velocity_x_wrapper, 0);
4333   if(SQ_FAILED(sq_createslot(v, -3))) {
4334     throw SquirrelError(v, "Couldn't register function 'get_velocity_x'");
4335   }
4336
4337   sq_pushstring(v, "get_velocity_y", -1);
4338   sq_newclosure(v, &ScriptedObject_get_velocity_y_wrapper, 0);
4339   if(SQ_FAILED(sq_createslot(v, -3))) {
4340     throw SquirrelError(v, "Couldn't register function 'get_velocity_y'");
4341   }
4342
4343   sq_pushstring(v, "set_visible", -1);
4344   sq_newclosure(v, &ScriptedObject_set_visible_wrapper, 0);
4345   if(SQ_FAILED(sq_createslot(v, -3))) {
4346     throw SquirrelError(v, "Couldn't register function 'set_visible'");
4347   }
4348
4349   sq_pushstring(v, "is_visible", -1);
4350   sq_newclosure(v, &ScriptedObject_is_visible_wrapper, 0);
4351   if(SQ_FAILED(sq_createslot(v, -3))) {
4352     throw SquirrelError(v, "Couldn't register function 'is_visible'");
4353   }
4354
4355   sq_pushstring(v, "set_solid", -1);
4356   sq_newclosure(v, &ScriptedObject_set_solid_wrapper, 0);
4357   if(SQ_FAILED(sq_createslot(v, -3))) {
4358     throw SquirrelError(v, "Couldn't register function 'set_solid'");
4359   }
4360
4361   sq_pushstring(v, "is_solid", -1);
4362   sq_newclosure(v, &ScriptedObject_is_solid_wrapper, 0);
4363   if(SQ_FAILED(sq_createslot(v, -3))) {
4364     throw SquirrelError(v, "Couldn't register function 'is_solid'");
4365   }
4366
4367   sq_pushstring(v, "get_name", -1);
4368   sq_newclosure(v, &ScriptedObject_get_name_wrapper, 0);
4369   if(SQ_FAILED(sq_createslot(v, -3))) {
4370     throw SquirrelError(v, "Couldn't register function 'get_name'");
4371   }
4372
4373   if(SQ_FAILED(sq_createslot(v, -3))) {
4374     throw SquirrelError(v, "Couldn't register class 'ScriptedObject'");
4375   }
4376
4377   // Register class Text
4378   sq_pushstring(v, "Text", -1);
4379   if(sq_newclass(v, SQFalse) < 0) {
4380     std::ostringstream msg;
4381     msg << "Couldn't create new class 'Text'";
4382     throw SquirrelError(v, msg.str());
4383   }
4384   sq_pushstring(v, "set_text", -1);
4385   sq_newclosure(v, &Text_set_text_wrapper, 0);
4386   if(SQ_FAILED(sq_createslot(v, -3))) {
4387     throw SquirrelError(v, "Couldn't register function 'set_text'");
4388   }
4389
4390   sq_pushstring(v, "set_font", -1);
4391   sq_newclosure(v, &Text_set_font_wrapper, 0);
4392   if(SQ_FAILED(sq_createslot(v, -3))) {
4393     throw SquirrelError(v, "Couldn't register function 'set_font'");
4394   }
4395
4396   sq_pushstring(v, "fade_in", -1);
4397   sq_newclosure(v, &Text_fade_in_wrapper, 0);
4398   if(SQ_FAILED(sq_createslot(v, -3))) {
4399     throw SquirrelError(v, "Couldn't register function 'fade_in'");
4400   }
4401
4402   sq_pushstring(v, "fade_out", -1);
4403   sq_newclosure(v, &Text_fade_out_wrapper, 0);
4404   if(SQ_FAILED(sq_createslot(v, -3))) {
4405     throw SquirrelError(v, "Couldn't register function 'fade_out'");
4406   }
4407
4408   sq_pushstring(v, "set_visible", -1);
4409   sq_newclosure(v, &Text_set_visible_wrapper, 0);
4410   if(SQ_FAILED(sq_createslot(v, -3))) {
4411     throw SquirrelError(v, "Couldn't register function 'set_visible'");
4412   }
4413
4414   sq_pushstring(v, "set_centered", -1);
4415   sq_newclosure(v, &Text_set_centered_wrapper, 0);
4416   if(SQ_FAILED(sq_createslot(v, -3))) {
4417     throw SquirrelError(v, "Couldn't register function 'set_centered'");
4418   }
4419
4420   sq_pushstring(v, "set_pos", -1);
4421   sq_newclosure(v, &Text_set_pos_wrapper, 0);
4422   if(SQ_FAILED(sq_createslot(v, -3))) {
4423     throw SquirrelError(v, "Couldn't register function 'set_pos'");
4424   }
4425
4426   sq_pushstring(v, "get_pos_x", -1);
4427   sq_newclosure(v, &Text_get_pos_x_wrapper, 0);
4428   if(SQ_FAILED(sq_createslot(v, -3))) {
4429     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
4430   }
4431
4432   sq_pushstring(v, "get_pos_y", -1);
4433   sq_newclosure(v, &Text_get_pos_y_wrapper, 0);
4434   if(SQ_FAILED(sq_createslot(v, -3))) {
4435     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
4436   }
4437
4438   sq_pushstring(v, "set_anchor_point", -1);
4439   sq_newclosure(v, &Text_set_anchor_point_wrapper, 0);
4440   if(SQ_FAILED(sq_createslot(v, -3))) {
4441     throw SquirrelError(v, "Couldn't register function 'set_anchor_point'");
4442   }
4443
4444   sq_pushstring(v, "get_anchor_point", -1);
4445   sq_newclosure(v, &Text_get_anchor_point_wrapper, 0);
4446   if(SQ_FAILED(sq_createslot(v, -3))) {
4447     throw SquirrelError(v, "Couldn't register function 'get_anchor_point'");
4448   }
4449
4450   if(SQ_FAILED(sq_createslot(v, -3))) {
4451     throw SquirrelError(v, "Couldn't register class 'Text'");
4452   }
4453
4454   // Register class Player
4455   sq_pushstring(v, "Player", -1);
4456   if(sq_newclass(v, SQFalse) < 0) {
4457     std::ostringstream msg;
4458     msg << "Couldn't create new class 'Player'";
4459     throw SquirrelError(v, msg.str());
4460   }
4461   sq_pushstring(v, "add_bonus", -1);
4462   sq_newclosure(v, &Player_add_bonus_wrapper, 0);
4463   if(SQ_FAILED(sq_createslot(v, -3))) {
4464     throw SquirrelError(v, "Couldn't register function 'add_bonus'");
4465   }
4466
4467   sq_pushstring(v, "add_coins", -1);
4468   sq_newclosure(v, &Player_add_coins_wrapper, 0);
4469   if(SQ_FAILED(sq_createslot(v, -3))) {
4470     throw SquirrelError(v, "Couldn't register function 'add_coins'");
4471   }
4472
4473   sq_pushstring(v, "make_invincible", -1);
4474   sq_newclosure(v, &Player_make_invincible_wrapper, 0);
4475   if(SQ_FAILED(sq_createslot(v, -3))) {
4476     throw SquirrelError(v, "Couldn't register function 'make_invincible'");
4477   }
4478
4479   sq_pushstring(v, "deactivate", -1);
4480   sq_newclosure(v, &Player_deactivate_wrapper, 0);
4481   if(SQ_FAILED(sq_createslot(v, -3))) {
4482     throw SquirrelError(v, "Couldn't register function 'deactivate'");
4483   }
4484
4485   sq_pushstring(v, "activate", -1);
4486   sq_newclosure(v, &Player_activate_wrapper, 0);
4487   if(SQ_FAILED(sq_createslot(v, -3))) {
4488     throw SquirrelError(v, "Couldn't register function 'activate'");
4489   }
4490
4491   sq_pushstring(v, "walk", -1);
4492   sq_newclosure(v, &Player_walk_wrapper, 0);
4493   if(SQ_FAILED(sq_createslot(v, -3))) {
4494     throw SquirrelError(v, "Couldn't register function 'walk'");
4495   }
4496
4497   sq_pushstring(v, "set_visible", -1);
4498   sq_newclosure(v, &Player_set_visible_wrapper, 0);
4499   if(SQ_FAILED(sq_createslot(v, -3))) {
4500     throw SquirrelError(v, "Couldn't register function 'set_visible'");
4501   }
4502
4503   sq_pushstring(v, "get_visible", -1);
4504   sq_newclosure(v, &Player_get_visible_wrapper, 0);
4505   if(SQ_FAILED(sq_createslot(v, -3))) {
4506     throw SquirrelError(v, "Couldn't register function 'get_visible'");
4507   }
4508
4509   sq_pushstring(v, "kill", -1);
4510   sq_newclosure(v, &Player_kill_wrapper, 0);
4511   if(SQ_FAILED(sq_createslot(v, -3))) {
4512     throw SquirrelError(v, "Couldn't register function 'kill'");
4513   }
4514
4515   sq_pushstring(v, "set_ghost_mode", -1);
4516   sq_newclosure(v, &Player_set_ghost_mode_wrapper, 0);
4517   if(SQ_FAILED(sq_createslot(v, -3))) {
4518     throw SquirrelError(v, "Couldn't register function 'set_ghost_mode'");
4519   }
4520
4521   sq_pushstring(v, "get_ghost_mode", -1);
4522   sq_newclosure(v, &Player_get_ghost_mode_wrapper, 0);
4523   if(SQ_FAILED(sq_createslot(v, -3))) {
4524     throw SquirrelError(v, "Couldn't register function 'get_ghost_mode'");
4525   }
4526
4527   sq_pushstring(v, "do_cheer", -1);
4528   sq_newclosure(v, &Player_do_cheer_wrapper, 0);
4529   if(SQ_FAILED(sq_createslot(v, -3))) {
4530     throw SquirrelError(v, "Couldn't register function 'do_cheer'");
4531   }
4532
4533   sq_pushstring(v, "do_duck", -1);
4534   sq_newclosure(v, &Player_do_duck_wrapper, 0);
4535   if(SQ_FAILED(sq_createslot(v, -3))) {
4536     throw SquirrelError(v, "Couldn't register function 'do_duck'");
4537   }
4538
4539   sq_pushstring(v, "do_standup", -1);
4540   sq_newclosure(v, &Player_do_standup_wrapper, 0);
4541   if(SQ_FAILED(sq_createslot(v, -3))) {
4542     throw SquirrelError(v, "Couldn't register function 'do_standup'");
4543   }
4544
4545   sq_pushstring(v, "do_backflip", -1);
4546   sq_newclosure(v, &Player_do_backflip_wrapper, 0);
4547   if(SQ_FAILED(sq_createslot(v, -3))) {
4548     throw SquirrelError(v, "Couldn't register function 'do_backflip'");
4549   }
4550
4551   sq_pushstring(v, "do_jump", -1);
4552   sq_newclosure(v, &Player_do_jump_wrapper, 0);
4553   if(SQ_FAILED(sq_createslot(v, -3))) {
4554     throw SquirrelError(v, "Couldn't register function 'do_jump'");
4555   }
4556
4557   sq_pushstring(v, "trigger_sequence", -1);
4558   sq_newclosure(v, &Player_trigger_sequence_wrapper, 0);
4559   if(SQ_FAILED(sq_createslot(v, -3))) {
4560     throw SquirrelError(v, "Couldn't register function 'trigger_sequence'");
4561   }
4562
4563   if(SQ_FAILED(sq_createslot(v, -3))) {
4564     throw SquirrelError(v, "Couldn't register class 'Player'");
4565   }
4566
4567   // Register class FloatingImage
4568   sq_pushstring(v, "FloatingImage", -1);
4569   if(sq_newclass(v, SQFalse) < 0) {
4570     std::ostringstream msg;
4571     msg << "Couldn't create new class 'FloatingImage'";
4572     throw SquirrelError(v, msg.str());
4573   }
4574   sq_pushstring(v, "constructor", -1);
4575   sq_newclosure(v, &FloatingImage_constructor_wrapper, 0);
4576   if(SQ_FAILED(sq_createslot(v, -3))) {
4577     throw SquirrelError(v, "Couldn't register function 'constructor'");
4578   }
4579
4580   sq_pushstring(v, "set_layer", -1);
4581   sq_newclosure(v, &FloatingImage_set_layer_wrapper, 0);
4582   if(SQ_FAILED(sq_createslot(v, -3))) {
4583     throw SquirrelError(v, "Couldn't register function 'set_layer'");
4584   }
4585
4586   sq_pushstring(v, "get_layer", -1);
4587   sq_newclosure(v, &FloatingImage_get_layer_wrapper, 0);
4588   if(SQ_FAILED(sq_createslot(v, -3))) {
4589     throw SquirrelError(v, "Couldn't register function 'get_layer'");
4590   }
4591
4592   sq_pushstring(v, "set_pos", -1);
4593   sq_newclosure(v, &FloatingImage_set_pos_wrapper, 0);
4594   if(SQ_FAILED(sq_createslot(v, -3))) {
4595     throw SquirrelError(v, "Couldn't register function 'set_pos'");
4596   }
4597
4598   sq_pushstring(v, "get_pos_x", -1);
4599   sq_newclosure(v, &FloatingImage_get_pos_x_wrapper, 0);
4600   if(SQ_FAILED(sq_createslot(v, -3))) {
4601     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
4602   }
4603
4604   sq_pushstring(v, "get_pos_y", -1);
4605   sq_newclosure(v, &FloatingImage_get_pos_y_wrapper, 0);
4606   if(SQ_FAILED(sq_createslot(v, -3))) {
4607     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
4608   }
4609
4610   sq_pushstring(v, "set_anchor_point", -1);
4611   sq_newclosure(v, &FloatingImage_set_anchor_point_wrapper, 0);
4612   if(SQ_FAILED(sq_createslot(v, -3))) {
4613     throw SquirrelError(v, "Couldn't register function 'set_anchor_point'");
4614   }
4615
4616   sq_pushstring(v, "get_anchor_point", -1);
4617   sq_newclosure(v, &FloatingImage_get_anchor_point_wrapper, 0);
4618   if(SQ_FAILED(sq_createslot(v, -3))) {
4619     throw SquirrelError(v, "Couldn't register function 'get_anchor_point'");
4620   }
4621
4622   sq_pushstring(v, "set_visible", -1);
4623   sq_newclosure(v, &FloatingImage_set_visible_wrapper, 0);
4624   if(SQ_FAILED(sq_createslot(v, -3))) {
4625     throw SquirrelError(v, "Couldn't register function 'set_visible'");
4626   }
4627
4628   sq_pushstring(v, "get_visible", -1);
4629   sq_newclosure(v, &FloatingImage_get_visible_wrapper, 0);
4630   if(SQ_FAILED(sq_createslot(v, -3))) {
4631     throw SquirrelError(v, "Couldn't register function 'get_visible'");
4632   }
4633
4634   sq_pushstring(v, "set_action", -1);
4635   sq_newclosure(v, &FloatingImage_set_action_wrapper, 0);
4636   if(SQ_FAILED(sq_createslot(v, -3))) {
4637     throw SquirrelError(v, "Couldn't register function 'set_action'");
4638   }
4639
4640   sq_pushstring(v, "get_action", -1);
4641   sq_newclosure(v, &FloatingImage_get_action_wrapper, 0);
4642   if(SQ_FAILED(sq_createslot(v, -3))) {
4643     throw SquirrelError(v, "Couldn't register function 'get_action'");
4644   }
4645
4646   sq_pushstring(v, "fade_in", -1);
4647   sq_newclosure(v, &FloatingImage_fade_in_wrapper, 0);
4648   if(SQ_FAILED(sq_createslot(v, -3))) {
4649     throw SquirrelError(v, "Couldn't register function 'fade_in'");
4650   }
4651
4652   sq_pushstring(v, "fade_out", -1);
4653   sq_newclosure(v, &FloatingImage_fade_out_wrapper, 0);
4654   if(SQ_FAILED(sq_createslot(v, -3))) {
4655     throw SquirrelError(v, "Couldn't register function 'fade_out'");
4656   }
4657
4658   if(SQ_FAILED(sq_createslot(v, -3))) {
4659     throw SquirrelError(v, "Couldn't register class 'FloatingImage'");
4660   }
4661
4662   // Register class Platform
4663   sq_pushstring(v, "Platform", -1);
4664   if(sq_newclass(v, SQFalse) < 0) {
4665     std::ostringstream msg;
4666     msg << "Couldn't create new class 'Platform'";
4667     throw SquirrelError(v, msg.str());
4668   }
4669   sq_pushstring(v, "goto_node", -1);
4670   sq_newclosure(v, &Platform_goto_node_wrapper, 0);
4671   if(SQ_FAILED(sq_createslot(v, -3))) {
4672     throw SquirrelError(v, "Couldn't register function 'goto_node'");
4673   }
4674
4675   sq_pushstring(v, "start_moving", -1);
4676   sq_newclosure(v, &Platform_start_moving_wrapper, 0);
4677   if(SQ_FAILED(sq_createslot(v, -3))) {
4678     throw SquirrelError(v, "Couldn't register function 'start_moving'");
4679   }
4680
4681   sq_pushstring(v, "stop_moving", -1);
4682   sq_newclosure(v, &Platform_stop_moving_wrapper, 0);
4683   if(SQ_FAILED(sq_createslot(v, -3))) {
4684     throw SquirrelError(v, "Couldn't register function 'stop_moving'");
4685   }
4686
4687   if(SQ_FAILED(sq_createslot(v, -3))) {
4688     throw SquirrelError(v, "Couldn't register class 'Platform'");
4689   }
4690
4691   // Register class Candle
4692   sq_pushstring(v, "Candle", -1);
4693   if(sq_newclass(v, SQFalse) < 0) {
4694     std::ostringstream msg;
4695     msg << "Couldn't create new class 'Candle'";
4696     throw SquirrelError(v, msg.str());
4697   }
4698   sq_pushstring(v, "get_burning", -1);
4699   sq_newclosure(v, &Candle_get_burning_wrapper, 0);
4700   if(SQ_FAILED(sq_createslot(v, -3))) {
4701     throw SquirrelError(v, "Couldn't register function 'get_burning'");
4702   }
4703
4704   sq_pushstring(v, "set_burning", -1);
4705   sq_newclosure(v, &Candle_set_burning_wrapper, 0);
4706   if(SQ_FAILED(sq_createslot(v, -3))) {
4707     throw SquirrelError(v, "Couldn't register function 'set_burning'");
4708   }
4709
4710   if(SQ_FAILED(sq_createslot(v, -3))) {
4711     throw SquirrelError(v, "Couldn't register class 'Candle'");
4712   }
4713
4714   // Register class Wind
4715   sq_pushstring(v, "Wind", -1);
4716   if(sq_newclass(v, SQFalse) < 0) {
4717     std::ostringstream msg;
4718     msg << "Couldn't create new class 'Wind'";
4719     throw SquirrelError(v, msg.str());
4720   }
4721   sq_pushstring(v, "start", -1);
4722   sq_newclosure(v, &Wind_start_wrapper, 0);
4723   if(SQ_FAILED(sq_createslot(v, -3))) {
4724     throw SquirrelError(v, "Couldn't register function 'start'");
4725   }
4726
4727   sq_pushstring(v, "stop", -1);
4728   sq_newclosure(v, &Wind_stop_wrapper, 0);
4729   if(SQ_FAILED(sq_createslot(v, -3))) {
4730     throw SquirrelError(v, "Couldn't register function 'stop'");
4731   }
4732
4733   if(SQ_FAILED(sq_createslot(v, -3))) {
4734     throw SquirrelError(v, "Couldn't register class 'Wind'");
4735   }
4736
4737   // Register class AmbientSound
4738   sq_pushstring(v, "AmbientSound", -1);
4739   if(sq_newclass(v, SQFalse) < 0) {
4740     std::ostringstream msg;
4741     msg << "Couldn't create new class 'AmbientSound'";
4742     throw SquirrelError(v, msg.str());
4743   }
4744   sq_pushstring(v, "set_pos", -1);
4745   sq_newclosure(v, &AmbientSound_set_pos_wrapper, 0);
4746   if(SQ_FAILED(sq_createslot(v, -3))) {
4747     throw SquirrelError(v, "Couldn't register function 'set_pos'");
4748   }
4749
4750   sq_pushstring(v, "get_pos_x", -1);
4751   sq_newclosure(v, &AmbientSound_get_pos_x_wrapper, 0);
4752   if(SQ_FAILED(sq_createslot(v, -3))) {
4753     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
4754   }
4755
4756   sq_pushstring(v, "get_pos_y", -1);
4757   sq_newclosure(v, &AmbientSound_get_pos_y_wrapper, 0);
4758   if(SQ_FAILED(sq_createslot(v, -3))) {
4759     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
4760   }
4761
4762   if(SQ_FAILED(sq_createslot(v, -3))) {
4763     throw SquirrelError(v, "Couldn't register class 'AmbientSound'");
4764   }
4765
4766   // Register class Thunderstorm
4767   sq_pushstring(v, "Thunderstorm", -1);
4768   if(sq_newclass(v, SQFalse) < 0) {
4769     std::ostringstream msg;
4770     msg << "Couldn't create new class 'Thunderstorm'";
4771     throw SquirrelError(v, msg.str());
4772   }
4773   sq_pushstring(v, "start", -1);
4774   sq_newclosure(v, &Thunderstorm_start_wrapper, 0);
4775   if(SQ_FAILED(sq_createslot(v, -3))) {
4776     throw SquirrelError(v, "Couldn't register function 'start'");
4777   }
4778
4779   sq_pushstring(v, "stop", -1);
4780   sq_newclosure(v, &Thunderstorm_stop_wrapper, 0);
4781   if(SQ_FAILED(sq_createslot(v, -3))) {
4782     throw SquirrelError(v, "Couldn't register function 'stop'");
4783   }
4784
4785   sq_pushstring(v, "thunder", -1);
4786   sq_newclosure(v, &Thunderstorm_thunder_wrapper, 0);
4787   if(SQ_FAILED(sq_createslot(v, -3))) {
4788     throw SquirrelError(v, "Couldn't register function 'thunder'");
4789   }
4790
4791   sq_pushstring(v, "lightning", -1);
4792   sq_newclosure(v, &Thunderstorm_lightning_wrapper, 0);
4793   if(SQ_FAILED(sq_createslot(v, -3))) {
4794     throw SquirrelError(v, "Couldn't register function 'lightning'");
4795   }
4796
4797   sq_pushstring(v, "flash", -1);
4798   sq_newclosure(v, &Thunderstorm_flash_wrapper, 0);
4799   if(SQ_FAILED(sq_createslot(v, -3))) {
4800     throw SquirrelError(v, "Couldn't register function 'flash'");
4801   }
4802
4803   sq_pushstring(v, "electrify", -1);
4804   sq_newclosure(v, &Thunderstorm_electrify_wrapper, 0);
4805   if(SQ_FAILED(sq_createslot(v, -3))) {
4806     throw SquirrelError(v, "Couldn't register function 'electrify'");
4807   }
4808
4809   if(SQ_FAILED(sq_createslot(v, -3))) {
4810     throw SquirrelError(v, "Couldn't register class 'Thunderstorm'");
4811   }
4812
4813   // Register class TileMap
4814   sq_pushstring(v, "TileMap", -1);
4815   if(sq_newclass(v, SQFalse) < 0) {
4816     std::ostringstream msg;
4817     msg << "Couldn't create new class 'TileMap'";
4818     throw SquirrelError(v, msg.str());
4819   }
4820   sq_pushstring(v, "goto_node", -1);
4821   sq_newclosure(v, &TileMap_goto_node_wrapper, 0);
4822   if(SQ_FAILED(sq_createslot(v, -3))) {
4823     throw SquirrelError(v, "Couldn't register function 'goto_node'");
4824   }
4825
4826   sq_pushstring(v, "start_moving", -1);
4827   sq_newclosure(v, &TileMap_start_moving_wrapper, 0);
4828   if(SQ_FAILED(sq_createslot(v, -3))) {
4829     throw SquirrelError(v, "Couldn't register function 'start_moving'");
4830   }
4831
4832   sq_pushstring(v, "stop_moving", -1);
4833   sq_newclosure(v, &TileMap_stop_moving_wrapper, 0);
4834   if(SQ_FAILED(sq_createslot(v, -3))) {
4835     throw SquirrelError(v, "Couldn't register function 'stop_moving'");
4836   }
4837
4838   sq_pushstring(v, "fade", -1);
4839   sq_newclosure(v, &TileMap_fade_wrapper, 0);
4840   if(SQ_FAILED(sq_createslot(v, -3))) {
4841     throw SquirrelError(v, "Couldn't register function 'fade'");
4842   }
4843
4844   sq_pushstring(v, "set_alpha", -1);
4845   sq_newclosure(v, &TileMap_set_alpha_wrapper, 0);
4846   if(SQ_FAILED(sq_createslot(v, -3))) {
4847     throw SquirrelError(v, "Couldn't register function 'set_alpha'");
4848   }
4849
4850   sq_pushstring(v, "get_alpha", -1);
4851   sq_newclosure(v, &TileMap_get_alpha_wrapper, 0);
4852   if(SQ_FAILED(sq_createslot(v, -3))) {
4853     throw SquirrelError(v, "Couldn't register function 'get_alpha'");
4854   }
4855
4856   if(SQ_FAILED(sq_createslot(v, -3))) {
4857     throw SquirrelError(v, "Couldn't register class 'TileMap'");
4858   }
4859
4860   // Register class SSector
4861   sq_pushstring(v, "SSector", -1);
4862   if(sq_newclass(v, SQFalse) < 0) {
4863     std::ostringstream msg;
4864     msg << "Couldn't create new class 'SSector'";
4865     throw SquirrelError(v, msg.str());
4866   }
4867   sq_pushstring(v, "set_ambient_light", -1);
4868   sq_newclosure(v, &SSector_set_ambient_light_wrapper, 0);
4869   if(SQ_FAILED(sq_createslot(v, -3))) {
4870     throw SquirrelError(v, "Couldn't register function 'set_ambient_light'");
4871   }
4872
4873   sq_pushstring(v, "get_ambient_red", -1);
4874   sq_newclosure(v, &SSector_get_ambient_red_wrapper, 0);
4875   if(SQ_FAILED(sq_createslot(v, -3))) {
4876     throw SquirrelError(v, "Couldn't register function 'get_ambient_red'");
4877   }
4878
4879   sq_pushstring(v, "get_ambient_green", -1);
4880   sq_newclosure(v, &SSector_get_ambient_green_wrapper, 0);
4881   if(SQ_FAILED(sq_createslot(v, -3))) {
4882     throw SquirrelError(v, "Couldn't register function 'get_ambient_green'");
4883   }
4884
4885   sq_pushstring(v, "get_ambient_blue", -1);
4886   sq_newclosure(v, &SSector_get_ambient_blue_wrapper, 0);
4887   if(SQ_FAILED(sq_createslot(v, -3))) {
4888     throw SquirrelError(v, "Couldn't register function 'get_ambient_blue'");
4889   }
4890
4891   if(SQ_FAILED(sq_createslot(v, -3))) {
4892     throw SquirrelError(v, "Couldn't register class 'SSector'");
4893   }
4894
4895   // Register class LevelTime
4896   sq_pushstring(v, "LevelTime", -1);
4897   if(sq_newclass(v, SQFalse) < 0) {
4898     std::ostringstream msg;
4899     msg << "Couldn't create new class 'LevelTime'";
4900     throw SquirrelError(v, msg.str());
4901   }
4902   sq_pushstring(v, "start", -1);
4903   sq_newclosure(v, &LevelTime_start_wrapper, 0);
4904   if(SQ_FAILED(sq_createslot(v, -3))) {
4905     throw SquirrelError(v, "Couldn't register function 'start'");
4906   }
4907
4908   sq_pushstring(v, "stop", -1);
4909   sq_newclosure(v, &LevelTime_stop_wrapper, 0);
4910   if(SQ_FAILED(sq_createslot(v, -3))) {
4911     throw SquirrelError(v, "Couldn't register function 'stop'");
4912   }
4913
4914   sq_pushstring(v, "get_time", -1);
4915   sq_newclosure(v, &LevelTime_get_time_wrapper, 0);
4916   if(SQ_FAILED(sq_createslot(v, -3))) {
4917     throw SquirrelError(v, "Couldn't register function 'get_time'");
4918   }
4919
4920   sq_pushstring(v, "set_time", -1);
4921   sq_newclosure(v, &LevelTime_set_time_wrapper, 0);
4922   if(SQ_FAILED(sq_createslot(v, -3))) {
4923     throw SquirrelError(v, "Couldn't register function 'set_time'");
4924   }
4925
4926   if(SQ_FAILED(sq_createslot(v, -3))) {
4927     throw SquirrelError(v, "Couldn't register class 'LevelTime'");
4928   }
4929
4930 }
4931
4932 } // end of namespace Scripting