src/scripting/wrapper.cpp

   1 /**
   2  * WARNING: This file is automatically generated from:
   3  *  'src/scripting/wrapper.interface.hpp'
   4  * DO NOT CHANGE
   5  */
   6 #include <config.h>
   7
   8 #include <new>
   9 #include <assert.h>
  10 #include <string>
  11 #include <sstream>
  12 #include <squirrel.h>
  13 #include "squirrel_error.hpp"
  14 #include "wrapper.interface.hpp"
  15
  16 namespace Scripting
  17 {
  18 namespace Wrapper
  19 {
  20
  21 static SQInteger DisplayEffect_release_hook(SQUserPointer ptr, SQInteger )
  22 {
  23   Scripting::DisplayEffect* _this = reinterpret_cast<Scripting::DisplayEffect*> (ptr);
  24   delete _this;
  25   return 0;
  26 }
  27
  28 static SQInteger DisplayEffect_fade_out_wrapper(HSQUIRRELVM vm)
  29 {
  30   SQUserPointer data;
  31   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
  32     sq_throwerror(vm, _SC("'fade_out' called without instance"));
  33     return SQ_ERROR;
  34   }
  35   Scripting::DisplayEffect* _this = reinterpret_cast<Scripting::DisplayEffect*> (data);
  36   SQFloat arg0;
  37   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
  38     sq_throwerror(vm, _SC("Argument 1 not a float"));
  39     return SQ_ERROR;
  40   }
  41
  42   try {
  43     _this->fade_out(static_cast<float> (arg0));
  44
  45     return 0;
  46
  47   } catch(std::exception& e) {
  48     sq_throwerror(vm, e.what());
  49     return SQ_ERROR;
  50   } catch(...) {
  51     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fade_out'"));
  52     return SQ_ERROR;
  53   }
  54
  55 }
  56
  57 static SQInteger DisplayEffect_fade_in_wrapper(HSQUIRRELVM vm)
  58 {
  59   SQUserPointer data;
  60   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
  61     sq_throwerror(vm, _SC("'fade_in' called without instance"));
  62     return SQ_ERROR;
  63   }
  64   Scripting::DisplayEffect* _this = reinterpret_cast<Scripting::DisplayEffect*> (data);
  65   SQFloat arg0;
  66   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
  67     sq_throwerror(vm, _SC("Argument 1 not a float"));
  68     return SQ_ERROR;
  69   }
  70
  71   try {
  72     _this->fade_in(static_cast<float> (arg0));
  73
  74     return 0;
  75
  76   } catch(std::exception& e) {
  77     sq_throwerror(vm, e.what());
  78     return SQ_ERROR;
  79   } catch(...) {
  80     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fade_in'"));
  81     return SQ_ERROR;
  82   }
  83
  84 }
  85
  86 static SQInteger DisplayEffect_set_black_wrapper(HSQUIRRELVM vm)
  87 {
  88   SQUserPointer data;
  89   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
  90     sq_throwerror(vm, _SC("'set_black' called without instance"));
  91     return SQ_ERROR;
  92   }
  93   Scripting::DisplayEffect* _this = reinterpret_cast<Scripting::DisplayEffect*> (data);
  94   SQBool arg0;
  95   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
  96     sq_throwerror(vm, _SC("Argument 1 not a bool"));
  97     return SQ_ERROR;
  98   }
  99
 100   try {
 101     _this->set_black(arg0 == SQTrue);
 102
 103     return 0;
 104
 105   } catch(std::exception& e) {
 106     sq_throwerror(vm, e.what());
 107     return SQ_ERROR;
 108   } catch(...) {
 109     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_black'"));
 110     return SQ_ERROR;
 111   }
 112
 113 }
 114
 115 static SQInteger DisplayEffect_is_black_wrapper(HSQUIRRELVM vm)
 116 {
 117   SQUserPointer data;
 118   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 119     sq_throwerror(vm, _SC("'is_black' called without instance"));
 120     return SQ_ERROR;
 121   }
 122   Scripting::DisplayEffect* _this = reinterpret_cast<Scripting::DisplayEffect*> (data);
 123
 124   try {
 125     bool return_value = _this->is_black();
 126
 127     sq_pushbool(vm, return_value);
 128     return 1;
 129
 130   } catch(std::exception& e) {
 131     sq_throwerror(vm, e.what());
 132     return SQ_ERROR;
 133   } catch(...) {
 134     sq_throwerror(vm, _SC("Unexpected exception while executing function 'is_black'"));
 135     return SQ_ERROR;
 136   }
 137
 138 }
 139
 140 static SQInteger DisplayEffect_sixteen_to_nine_wrapper(HSQUIRRELVM vm)
 141 {
 142   SQUserPointer data;
 143   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 144     sq_throwerror(vm, _SC("'sixteen_to_nine' called without instance"));
 145     return SQ_ERROR;
 146   }
 147   Scripting::DisplayEffect* _this = reinterpret_cast<Scripting::DisplayEffect*> (data);
 148   SQFloat arg0;
 149   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 150     sq_throwerror(vm, _SC("Argument 1 not a float"));
 151     return SQ_ERROR;
 152   }
 153
 154   try {
 155     _this->sixteen_to_nine(static_cast<float> (arg0));
 156
 157     return 0;
 158
 159   } catch(std::exception& e) {
 160     sq_throwerror(vm, e.what());
 161     return SQ_ERROR;
 162   } catch(...) {
 163     sq_throwerror(vm, _SC("Unexpected exception while executing function 'sixteen_to_nine'"));
 164     return SQ_ERROR;
 165   }
 166
 167 }
 168
 169 static SQInteger DisplayEffect_four_to_three_wrapper(HSQUIRRELVM vm)
 170 {
 171   SQUserPointer data;
 172   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 173     sq_throwerror(vm, _SC("'four_to_three' called without instance"));
 174     return SQ_ERROR;
 175   }
 176   Scripting::DisplayEffect* _this = reinterpret_cast<Scripting::DisplayEffect*> (data);
 177   SQFloat arg0;
 178   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 179     sq_throwerror(vm, _SC("Argument 1 not a float"));
 180     return SQ_ERROR;
 181   }
 182
 183   try {
 184     _this->four_to_three(static_cast<float> (arg0));
 185
 186     return 0;
 187
 188   } catch(std::exception& e) {
 189     sq_throwerror(vm, e.what());
 190     return SQ_ERROR;
 191   } catch(...) {
 192     sq_throwerror(vm, _SC("Unexpected exception while executing function 'four_to_three'"));
 193     return SQ_ERROR;
 194   }
 195
 196 }
 197
 198 static SQInteger Camera_release_hook(SQUserPointer ptr, SQInteger )
 199 {
 200   Scripting::Camera* _this = reinterpret_cast<Scripting::Camera*> (ptr);
 201   delete _this;
 202   return 0;
 203 }
 204
 205 static SQInteger Camera_shake_wrapper(HSQUIRRELVM vm)
 206 {
 207   SQUserPointer data;
 208   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 209     sq_throwerror(vm, _SC("'shake' called without instance"));
 210     return SQ_ERROR;
 211   }
 212   Scripting::Camera* _this = reinterpret_cast<Scripting::Camera*> (data);
 213   SQFloat arg0;
 214   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 215     sq_throwerror(vm, _SC("Argument 1 not a float"));
 216     return SQ_ERROR;
 217   }
 218   SQFloat arg1;
 219   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
 220     sq_throwerror(vm, _SC("Argument 2 not a float"));
 221     return SQ_ERROR;
 222   }
 223   SQFloat arg2;
 224   if(SQ_FAILED(sq_getfloat(vm, 4, &arg2))) {
 225     sq_throwerror(vm, _SC("Argument 3 not a float"));
 226     return SQ_ERROR;
 227   }
 228
 229   try {
 230     _this->shake(static_cast<float> (arg0), static_cast<float> (arg1), static_cast<float> (arg2));
 231
 232     return 0;
 233
 234   } catch(std::exception& e) {
 235     sq_throwerror(vm, e.what());
 236     return SQ_ERROR;
 237   } catch(...) {
 238     sq_throwerror(vm, _SC("Unexpected exception while executing function 'shake'"));
 239     return SQ_ERROR;
 240   }
 241
 242 }
 243
 244 static SQInteger Camera_set_pos_wrapper(HSQUIRRELVM vm)
 245 {
 246   SQUserPointer data;
 247   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 248     sq_throwerror(vm, _SC("'set_pos' called without instance"));
 249     return SQ_ERROR;
 250   }
 251   Scripting::Camera* _this = reinterpret_cast<Scripting::Camera*> (data);
 252   SQFloat arg0;
 253   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 254     sq_throwerror(vm, _SC("Argument 1 not a float"));
 255     return SQ_ERROR;
 256   }
 257   SQFloat arg1;
 258   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
 259     sq_throwerror(vm, _SC("Argument 2 not a float"));
 260     return SQ_ERROR;
 261   }
 262
 263   try {
 264     _this->set_pos(static_cast<float> (arg0), static_cast<float> (arg1));
 265
 266     return 0;
 267
 268   } catch(std::exception& e) {
 269     sq_throwerror(vm, e.what());
 270     return SQ_ERROR;
 271   } catch(...) {
 272     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_pos'"));
 273     return SQ_ERROR;
 274   }
 275
 276 }
 277
 278 static SQInteger Camera_set_mode_wrapper(HSQUIRRELVM vm)
 279 {
 280   SQUserPointer data;
 281   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 282     sq_throwerror(vm, _SC("'set_mode' called without instance"));
 283     return SQ_ERROR;
 284   }
 285   Scripting::Camera* _this = reinterpret_cast<Scripting::Camera*> (data);
 286   const SQChar* arg0;
 287   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
 288     sq_throwerror(vm, _SC("Argument 1 not a string"));
 289     return SQ_ERROR;
 290   }
 291
 292   try {
 293     _this->set_mode(arg0);
 294
 295     return 0;
 296
 297   } catch(std::exception& e) {
 298     sq_throwerror(vm, e.what());
 299     return SQ_ERROR;
 300   } catch(...) {
 301     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_mode'"));
 302     return SQ_ERROR;
 303   }
 304
 305 }
 306
 307 static SQInteger Camera_scroll_to_wrapper(HSQUIRRELVM vm)
 308 {
 309   SQUserPointer data;
 310   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 311     sq_throwerror(vm, _SC("'scroll_to' called without instance"));
 312     return SQ_ERROR;
 313   }
 314   Scripting::Camera* _this = reinterpret_cast<Scripting::Camera*> (data);
 315   SQFloat arg0;
 316   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 317     sq_throwerror(vm, _SC("Argument 1 not a float"));
 318     return SQ_ERROR;
 319   }
 320   SQFloat arg1;
 321   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
 322     sq_throwerror(vm, _SC("Argument 2 not a float"));
 323     return SQ_ERROR;
 324   }
 325   SQFloat arg2;
 326   if(SQ_FAILED(sq_getfloat(vm, 4, &arg2))) {
 327     sq_throwerror(vm, _SC("Argument 3 not a float"));
 328     return SQ_ERROR;
 329   }
 330
 331   try {
 332     _this->scroll_to(static_cast<float> (arg0), static_cast<float> (arg1), static_cast<float> (arg2));
 333
 334     return 0;
 335
 336   } catch(std::exception& e) {
 337     sq_throwerror(vm, e.what());
 338     return SQ_ERROR;
 339   } catch(...) {
 340     sq_throwerror(vm, _SC("Unexpected exception while executing function 'scroll_to'"));
 341     return SQ_ERROR;
 342   }
 343
 344 }
 345
 346 static SQInteger Level_release_hook(SQUserPointer ptr, SQInteger )
 347 {
 348   Scripting::Level* _this = reinterpret_cast<Scripting::Level*> (ptr);
 349   delete _this;
 350   return 0;
 351 }
 352
 353 static SQInteger Level_finish_wrapper(HSQUIRRELVM vm)
 354 {
 355   SQUserPointer data;
 356   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 357     sq_throwerror(vm, _SC("'finish' called without instance"));
 358     return SQ_ERROR;
 359   }
 360   Scripting::Level* _this = reinterpret_cast<Scripting::Level*> (data);
 361   SQBool arg0;
 362   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
 363     sq_throwerror(vm, _SC("Argument 1 not a bool"));
 364     return SQ_ERROR;
 365   }
 366
 367   try {
 368     _this->finish(arg0 == SQTrue);
 369
 370     return 0;
 371
 372   } catch(std::exception& e) {
 373     sq_throwerror(vm, e.what());
 374     return SQ_ERROR;
 375   } catch(...) {
 376     sq_throwerror(vm, _SC("Unexpected exception while executing function 'finish'"));
 377     return SQ_ERROR;
 378   }
 379
 380 }
 381
 382 static SQInteger Level_spawn_wrapper(HSQUIRRELVM vm)
 383 {
 384   SQUserPointer data;
 385   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 386     sq_throwerror(vm, _SC("'spawn' called without instance"));
 387     return SQ_ERROR;
 388   }
 389   Scripting::Level* _this = reinterpret_cast<Scripting::Level*> (data);
 390   const SQChar* arg0;
 391   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
 392     sq_throwerror(vm, _SC("Argument 1 not a string"));
 393     return SQ_ERROR;
 394   }
 395   const SQChar* arg1;
 396   if(SQ_FAILED(sq_getstring(vm, 3, &arg1))) {
 397     sq_throwerror(vm, _SC("Argument 2 not a string"));
 398     return SQ_ERROR;
 399   }
 400
 401   try {
 402     _this->spawn(arg0, arg1);
 403
 404     return 0;
 405
 406   } catch(std::exception& e) {
 407     sq_throwerror(vm, e.what());
 408     return SQ_ERROR;
 409   } catch(...) {
 410     sq_throwerror(vm, _SC("Unexpected exception while executing function 'spawn'"));
 411     return SQ_ERROR;
 412   }
 413
 414 }
 415
 416 static SQInteger Level_flip_vertically_wrapper(HSQUIRRELVM vm)
 417 {
 418   SQUserPointer data;
 419   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 420     sq_throwerror(vm, _SC("'flip_vertically' called without instance"));
 421     return SQ_ERROR;
 422   }
 423   Scripting::Level* _this = reinterpret_cast<Scripting::Level*> (data);
 424
 425   try {
 426     _this->flip_vertically();
 427
 428     return 0;
 429
 430   } catch(std::exception& e) {
 431     sq_throwerror(vm, e.what());
 432     return SQ_ERROR;
 433   } catch(...) {
 434     sq_throwerror(vm, _SC("Unexpected exception while executing function 'flip_vertically'"));
 435     return SQ_ERROR;
 436   }
 437
 438 }
 439
 440 static SQInteger Level_toggle_pause_wrapper(HSQUIRRELVM vm)
 441 {
 442   SQUserPointer data;
 443   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 444     sq_throwerror(vm, _SC("'toggle_pause' called without instance"));
 445     return SQ_ERROR;
 446   }
 447   Scripting::Level* _this = reinterpret_cast<Scripting::Level*> (data);
 448
 449   try {
 450     _this->toggle_pause();
 451
 452     return 0;
 453
 454   } catch(std::exception& e) {
 455     sq_throwerror(vm, e.what());
 456     return SQ_ERROR;
 457   } catch(...) {
 458     sq_throwerror(vm, _SC("Unexpected exception while executing function 'toggle_pause'"));
 459     return SQ_ERROR;
 460   }
 461
 462 }
 463
 464 static SQInteger ScriptedObject_release_hook(SQUserPointer ptr, SQInteger )
 465 {
 466   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (ptr);
 467   delete _this;
 468   return 0;
 469 }
 470
 471 static SQInteger ScriptedObject_set_action_wrapper(HSQUIRRELVM vm)
 472 {
 473   SQUserPointer data;
 474   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 475     sq_throwerror(vm, _SC("'set_action' called without instance"));
 476     return SQ_ERROR;
 477   }
 478   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
 479   const SQChar* arg0;
 480   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
 481     sq_throwerror(vm, _SC("Argument 1 not a string"));
 482     return SQ_ERROR;
 483   }
 484
 485   try {
 486     _this->set_action(arg0);
 487
 488     return 0;
 489
 490   } catch(std::exception& e) {
 491     sq_throwerror(vm, e.what());
 492     return SQ_ERROR;
 493   } catch(...) {
 494     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_action'"));
 495     return SQ_ERROR;
 496   }
 497
 498 }
 499
 500 static SQInteger ScriptedObject_get_action_wrapper(HSQUIRRELVM vm)
 501 {
 502   SQUserPointer data;
 503   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 504     sq_throwerror(vm, _SC("'get_action' called without instance"));
 505     return SQ_ERROR;
 506   }
 507   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
 508
 509   try {
 510     std::string return_value = _this->get_action();
 511
 512     sq_pushstring(vm, return_value.c_str(), return_value.size());
 513     return 1;
 514
 515   } catch(std::exception& e) {
 516     sq_throwerror(vm, e.what());
 517     return SQ_ERROR;
 518   } catch(...) {
 519     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_action'"));
 520     return SQ_ERROR;
 521   }
 522
 523 }
 524
 525 static SQInteger ScriptedObject_move_wrapper(HSQUIRRELVM vm)
 526 {
 527   SQUserPointer data;
 528   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 529     sq_throwerror(vm, _SC("'move' called without instance"));
 530     return SQ_ERROR;
 531   }
 532   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
 533   SQFloat arg0;
 534   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 535     sq_throwerror(vm, _SC("Argument 1 not a float"));
 536     return SQ_ERROR;
 537   }
 538   SQFloat arg1;
 539   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
 540     sq_throwerror(vm, _SC("Argument 2 not a float"));
 541     return SQ_ERROR;
 542   }
 543
 544   try {
 545     _this->move(static_cast<float> (arg0), static_cast<float> (arg1));
 546
 547     return 0;
 548
 549   } catch(std::exception& e) {
 550     sq_throwerror(vm, e.what());
 551     return SQ_ERROR;
 552   } catch(...) {
 553     sq_throwerror(vm, _SC("Unexpected exception while executing function 'move'"));
 554     return SQ_ERROR;
 555   }
 556
 557 }
 558
 559 static SQInteger ScriptedObject_set_pos_wrapper(HSQUIRRELVM vm)
 560 {
 561   SQUserPointer data;
 562   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 563     sq_throwerror(vm, _SC("'set_pos' called without instance"));
 564     return SQ_ERROR;
 565   }
 566   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
 567   SQFloat arg0;
 568   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 569     sq_throwerror(vm, _SC("Argument 1 not a float"));
 570     return SQ_ERROR;
 571   }
 572   SQFloat arg1;
 573   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
 574     sq_throwerror(vm, _SC("Argument 2 not a float"));
 575     return SQ_ERROR;
 576   }
 577
 578   try {
 579     _this->set_pos(static_cast<float> (arg0), static_cast<float> (arg1));
 580
 581     return 0;
 582
 583   } catch(std::exception& e) {
 584     sq_throwerror(vm, e.what());
 585     return SQ_ERROR;
 586   } catch(...) {
 587     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_pos'"));
 588     return SQ_ERROR;
 589   }
 590
 591 }
 592
 593 static SQInteger ScriptedObject_get_pos_x_wrapper(HSQUIRRELVM vm)
 594 {
 595   SQUserPointer data;
 596   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 597     sq_throwerror(vm, _SC("'get_pos_x' called without instance"));
 598     return SQ_ERROR;
 599   }
 600   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
 601
 602   try {
 603     float return_value = _this->get_pos_x();
 604
 605     sq_pushfloat(vm, return_value);
 606     return 1;
 607
 608   } catch(std::exception& e) {
 609     sq_throwerror(vm, e.what());
 610     return SQ_ERROR;
 611   } catch(...) {
 612     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_x'"));
 613     return SQ_ERROR;
 614   }
 615
 616 }
 617
 618 static SQInteger ScriptedObject_get_pos_y_wrapper(HSQUIRRELVM vm)
 619 {
 620   SQUserPointer data;
 621   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 622     sq_throwerror(vm, _SC("'get_pos_y' called without instance"));
 623     return SQ_ERROR;
 624   }
 625   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
 626
 627   try {
 628     float return_value = _this->get_pos_y();
 629
 630     sq_pushfloat(vm, return_value);
 631     return 1;
 632
 633   } catch(std::exception& e) {
 634     sq_throwerror(vm, e.what());
 635     return SQ_ERROR;
 636   } catch(...) {
 637     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_y'"));
 638     return SQ_ERROR;
 639   }
 640
 641 }
 642
 643 static SQInteger ScriptedObject_set_velocity_wrapper(HSQUIRRELVM vm)
 644 {
 645   SQUserPointer data;
 646   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 647     sq_throwerror(vm, _SC("'set_velocity' called without instance"));
 648     return SQ_ERROR;
 649   }
 650   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
 651   SQFloat arg0;
 652   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 653     sq_throwerror(vm, _SC("Argument 1 not a float"));
 654     return SQ_ERROR;
 655   }
 656   SQFloat arg1;
 657   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
 658     sq_throwerror(vm, _SC("Argument 2 not a float"));
 659     return SQ_ERROR;
 660   }
 661
 662   try {
 663     _this->set_velocity(static_cast<float> (arg0), static_cast<float> (arg1));
 664
 665     return 0;
 666
 667   } catch(std::exception& e) {
 668     sq_throwerror(vm, e.what());
 669     return SQ_ERROR;
 670   } catch(...) {
 671     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_velocity'"));
 672     return SQ_ERROR;
 673   }
 674
 675 }
 676
 677 static SQInteger ScriptedObject_get_velocity_x_wrapper(HSQUIRRELVM vm)
 678 {
 679   SQUserPointer data;
 680   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 681     sq_throwerror(vm, _SC("'get_velocity_x' called without instance"));
 682     return SQ_ERROR;
 683   }
 684   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
 685
 686   try {
 687     float return_value = _this->get_velocity_x();
 688
 689     sq_pushfloat(vm, return_value);
 690     return 1;
 691
 692   } catch(std::exception& e) {
 693     sq_throwerror(vm, e.what());
 694     return SQ_ERROR;
 695   } catch(...) {
 696     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_velocity_x'"));
 697     return SQ_ERROR;
 698   }
 699
 700 }
 701
 702 static SQInteger ScriptedObject_get_velocity_y_wrapper(HSQUIRRELVM vm)
 703 {
 704   SQUserPointer data;
 705   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 706     sq_throwerror(vm, _SC("'get_velocity_y' called without instance"));
 707     return SQ_ERROR;
 708   }
 709   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
 710
 711   try {
 712     float return_value = _this->get_velocity_y();
 713
 714     sq_pushfloat(vm, return_value);
 715     return 1;
 716
 717   } catch(std::exception& e) {
 718     sq_throwerror(vm, e.what());
 719     return SQ_ERROR;
 720   } catch(...) {
 721     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_velocity_y'"));
 722     return SQ_ERROR;
 723   }
 724
 725 }
 726
 727 static SQInteger ScriptedObject_set_visible_wrapper(HSQUIRRELVM vm)
 728 {
 729   SQUserPointer data;
 730   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 731     sq_throwerror(vm, _SC("'set_visible' called without instance"));
 732     return SQ_ERROR;
 733   }
 734   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
 735   SQBool arg0;
 736   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
 737     sq_throwerror(vm, _SC("Argument 1 not a bool"));
 738     return SQ_ERROR;
 739   }
 740
 741   try {
 742     _this->set_visible(arg0 == SQTrue);
 743
 744     return 0;
 745
 746   } catch(std::exception& e) {
 747     sq_throwerror(vm, e.what());
 748     return SQ_ERROR;
 749   } catch(...) {
 750     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_visible'"));
 751     return SQ_ERROR;
 752   }
 753
 754 }
 755
 756 static SQInteger ScriptedObject_is_visible_wrapper(HSQUIRRELVM vm)
 757 {
 758   SQUserPointer data;
 759   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 760     sq_throwerror(vm, _SC("'is_visible' called without instance"));
 761     return SQ_ERROR;
 762   }
 763   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
 764
 765   try {
 766     bool return_value = _this->is_visible();
 767
 768     sq_pushbool(vm, return_value);
 769     return 1;
 770
 771   } catch(std::exception& e) {
 772     sq_throwerror(vm, e.what());
 773     return SQ_ERROR;
 774   } catch(...) {
 775     sq_throwerror(vm, _SC("Unexpected exception while executing function 'is_visible'"));
 776     return SQ_ERROR;
 777   }
 778
 779 }
 780
 781 static SQInteger ScriptedObject_get_name_wrapper(HSQUIRRELVM vm)
 782 {
 783   SQUserPointer data;
 784   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 785     sq_throwerror(vm, _SC("'get_name' called without instance"));
 786     return SQ_ERROR;
 787   }
 788   Scripting::ScriptedObject* _this = reinterpret_cast<Scripting::ScriptedObject*> (data);
 789
 790   try {
 791     std::string return_value = _this->get_name();
 792
 793     sq_pushstring(vm, return_value.c_str(), return_value.size());
 794     return 1;
 795
 796   } catch(std::exception& e) {
 797     sq_throwerror(vm, e.what());
 798     return SQ_ERROR;
 799   } catch(...) {
 800     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_name'"));
 801     return SQ_ERROR;
 802   }
 803
 804 }
 805
 806 static SQInteger Text_release_hook(SQUserPointer ptr, SQInteger )
 807 {
 808   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (ptr);
 809   delete _this;
 810   return 0;
 811 }
 812
 813 static SQInteger Text_set_text_wrapper(HSQUIRRELVM vm)
 814 {
 815   SQUserPointer data;
 816   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 817     sq_throwerror(vm, _SC("'set_text' called without instance"));
 818     return SQ_ERROR;
 819   }
 820   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
 821   const SQChar* arg0;
 822   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
 823     sq_throwerror(vm, _SC("Argument 1 not a string"));
 824     return SQ_ERROR;
 825   }
 826
 827   try {
 828     _this->set_text(arg0);
 829
 830     return 0;
 831
 832   } catch(std::exception& e) {
 833     sq_throwerror(vm, e.what());
 834     return SQ_ERROR;
 835   } catch(...) {
 836     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_text'"));
 837     return SQ_ERROR;
 838   }
 839
 840 }
 841
 842 static SQInteger Text_set_font_wrapper(HSQUIRRELVM vm)
 843 {
 844   SQUserPointer data;
 845   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 846     sq_throwerror(vm, _SC("'set_font' called without instance"));
 847     return SQ_ERROR;
 848   }
 849   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
 850   const SQChar* arg0;
 851   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
 852     sq_throwerror(vm, _SC("Argument 1 not a string"));
 853     return SQ_ERROR;
 854   }
 855
 856   try {
 857     _this->set_font(arg0);
 858
 859     return 0;
 860
 861   } catch(std::exception& e) {
 862     sq_throwerror(vm, e.what());
 863     return SQ_ERROR;
 864   } catch(...) {
 865     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_font'"));
 866     return SQ_ERROR;
 867   }
 868
 869 }
 870
 871 static SQInteger Text_fade_in_wrapper(HSQUIRRELVM vm)
 872 {
 873   SQUserPointer data;
 874   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 875     sq_throwerror(vm, _SC("'fade_in' called without instance"));
 876     return SQ_ERROR;
 877   }
 878   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
 879   SQFloat arg0;
 880   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 881     sq_throwerror(vm, _SC("Argument 1 not a float"));
 882     return SQ_ERROR;
 883   }
 884
 885   try {
 886     _this->fade_in(static_cast<float> (arg0));
 887
 888     return 0;
 889
 890   } catch(std::exception& e) {
 891     sq_throwerror(vm, e.what());
 892     return SQ_ERROR;
 893   } catch(...) {
 894     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fade_in'"));
 895     return SQ_ERROR;
 896   }
 897
 898 }
 899
 900 static SQInteger Text_fade_out_wrapper(HSQUIRRELVM vm)
 901 {
 902   SQUserPointer data;
 903   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 904     sq_throwerror(vm, _SC("'fade_out' called without instance"));
 905     return SQ_ERROR;
 906   }
 907   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
 908   SQFloat arg0;
 909   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
 910     sq_throwerror(vm, _SC("Argument 1 not a float"));
 911     return SQ_ERROR;
 912   }
 913
 914   try {
 915     _this->fade_out(static_cast<float> (arg0));
 916
 917     return 0;
 918
 919   } catch(std::exception& e) {
 920     sq_throwerror(vm, e.what());
 921     return SQ_ERROR;
 922   } catch(...) {
 923     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fade_out'"));
 924     return SQ_ERROR;
 925   }
 926
 927 }
 928
 929 static SQInteger Text_set_visible_wrapper(HSQUIRRELVM vm)
 930 {
 931   SQUserPointer data;
 932   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 933     sq_throwerror(vm, _SC("'set_visible' called without instance"));
 934     return SQ_ERROR;
 935   }
 936   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
 937   SQBool arg0;
 938   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
 939     sq_throwerror(vm, _SC("Argument 1 not a bool"));
 940     return SQ_ERROR;
 941   }
 942
 943   try {
 944     _this->set_visible(arg0 == SQTrue);
 945
 946     return 0;
 947
 948   } catch(std::exception& e) {
 949     sq_throwerror(vm, e.what());
 950     return SQ_ERROR;
 951   } catch(...) {
 952     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_visible'"));
 953     return SQ_ERROR;
 954   }
 955
 956 }
 957
 958 static SQInteger Text_set_centered_wrapper(HSQUIRRELVM vm)
 959 {
 960   SQUserPointer data;
 961   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 962     sq_throwerror(vm, _SC("'set_centered' called without instance"));
 963     return SQ_ERROR;
 964   }
 965   Scripting::Text* _this = reinterpret_cast<Scripting::Text*> (data);
 966   SQBool arg0;
 967   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
 968     sq_throwerror(vm, _SC("Argument 1 not a bool"));
 969     return SQ_ERROR;
 970   }
 971
 972   try {
 973     _this->set_centered(arg0 == SQTrue);
 974
 975     return 0;
 976
 977   } catch(std::exception& e) {
 978     sq_throwerror(vm, e.what());
 979     return SQ_ERROR;
 980   } catch(...) {
 981     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_centered'"));
 982     return SQ_ERROR;
 983   }
 984
 985 }
 986
 987 static SQInteger Player_release_hook(SQUserPointer ptr, SQInteger )
 988 {
 989   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (ptr);
 990   delete _this;
 991   return 0;
 992 }
 993
 994 static SQInteger Player_add_bonus_wrapper(HSQUIRRELVM vm)
 995 {
 996   SQUserPointer data;
 997   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
 998     sq_throwerror(vm, _SC("'add_bonus' called without instance"));
 999     return SQ_ERROR;
1000   }
1001   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1002   const SQChar* arg0;
1003   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1004     sq_throwerror(vm, _SC("Argument 1 not a string"));
1005     return SQ_ERROR;
1006   }
1007
1008   try {
1009     _this->add_bonus(arg0);
1010
1011     return 0;
1012
1013   } catch(std::exception& e) {
1014     sq_throwerror(vm, e.what());
1015     return SQ_ERROR;
1016   } catch(...) {
1017     sq_throwerror(vm, _SC("Unexpected exception while executing function 'add_bonus'"));
1018     return SQ_ERROR;
1019   }
1020
1021 }
1022
1023 static SQInteger Player_add_coins_wrapper(HSQUIRRELVM vm)
1024 {
1025   SQUserPointer data;
1026   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1027     sq_throwerror(vm, _SC("'add_coins' called without instance"));
1028     return SQ_ERROR;
1029   }
1030   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1031   SQInteger arg0;
1032   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
1033     sq_throwerror(vm, _SC("Argument 1 not an integer"));
1034     return SQ_ERROR;
1035   }
1036
1037   try {
1038     _this->add_coins(static_cast<int> (arg0));
1039
1040     return 0;
1041
1042   } catch(std::exception& e) {
1043     sq_throwerror(vm, e.what());
1044     return SQ_ERROR;
1045   } catch(...) {
1046     sq_throwerror(vm, _SC("Unexpected exception while executing function 'add_coins'"));
1047     return SQ_ERROR;
1048   }
1049
1050 }
1051
1052 static SQInteger Player_make_invincible_wrapper(HSQUIRRELVM vm)
1053 {
1054   SQUserPointer data;
1055   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1056     sq_throwerror(vm, _SC("'make_invincible' called without instance"));
1057     return SQ_ERROR;
1058   }
1059   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1060
1061   try {
1062     _this->make_invincible();
1063
1064     return 0;
1065
1066   } catch(std::exception& e) {
1067     sq_throwerror(vm, e.what());
1068     return SQ_ERROR;
1069   } catch(...) {
1070     sq_throwerror(vm, _SC("Unexpected exception while executing function 'make_invincible'"));
1071     return SQ_ERROR;
1072   }
1073
1074 }
1075
1076 static SQInteger Player_deactivate_wrapper(HSQUIRRELVM vm)
1077 {
1078   SQUserPointer data;
1079   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1080     sq_throwerror(vm, _SC("'deactivate' called without instance"));
1081     return SQ_ERROR;
1082   }
1083   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1084
1085   try {
1086     _this->deactivate();
1087
1088     return 0;
1089
1090   } catch(std::exception& e) {
1091     sq_throwerror(vm, e.what());
1092     return SQ_ERROR;
1093   } catch(...) {
1094     sq_throwerror(vm, _SC("Unexpected exception while executing function 'deactivate'"));
1095     return SQ_ERROR;
1096   }
1097
1098 }
1099
1100 static SQInteger Player_activate_wrapper(HSQUIRRELVM vm)
1101 {
1102   SQUserPointer data;
1103   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1104     sq_throwerror(vm, _SC("'activate' called without instance"));
1105     return SQ_ERROR;
1106   }
1107   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1108
1109   try {
1110     _this->activate();
1111
1112     return 0;
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 'activate'"));
1119     return SQ_ERROR;
1120   }
1121
1122 }
1123
1124 static SQInteger Player_walk_wrapper(HSQUIRRELVM vm)
1125 {
1126   SQUserPointer data;
1127   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1128     sq_throwerror(vm, _SC("'walk' called without instance"));
1129     return SQ_ERROR;
1130   }
1131   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1132   SQFloat arg0;
1133   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
1134     sq_throwerror(vm, _SC("Argument 1 not a float"));
1135     return SQ_ERROR;
1136   }
1137
1138   try {
1139     _this->walk(static_cast<float> (arg0));
1140
1141     return 0;
1142
1143   } catch(std::exception& e) {
1144     sq_throwerror(vm, e.what());
1145     return SQ_ERROR;
1146   } catch(...) {
1147     sq_throwerror(vm, _SC("Unexpected exception while executing function 'walk'"));
1148     return SQ_ERROR;
1149   }
1150
1151 }
1152
1153 static SQInteger Player_set_visible_wrapper(HSQUIRRELVM vm)
1154 {
1155   SQUserPointer data;
1156   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1157     sq_throwerror(vm, _SC("'set_visible' called without instance"));
1158     return SQ_ERROR;
1159   }
1160   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1161   SQBool arg0;
1162   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1163     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1164     return SQ_ERROR;
1165   }
1166
1167   try {
1168     _this->set_visible(arg0 == SQTrue);
1169
1170     return 0;
1171
1172   } catch(std::exception& e) {
1173     sq_throwerror(vm, e.what());
1174     return SQ_ERROR;
1175   } catch(...) {
1176     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_visible'"));
1177     return SQ_ERROR;
1178   }
1179
1180 }
1181
1182 static SQInteger Player_get_visible_wrapper(HSQUIRRELVM vm)
1183 {
1184   SQUserPointer data;
1185   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1186     sq_throwerror(vm, _SC("'get_visible' called without instance"));
1187     return SQ_ERROR;
1188   }
1189   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1190
1191   try {
1192     bool return_value = _this->get_visible();
1193
1194     sq_pushbool(vm, return_value);
1195     return 1;
1196
1197   } catch(std::exception& e) {
1198     sq_throwerror(vm, e.what());
1199     return SQ_ERROR;
1200   } catch(...) {
1201     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_visible'"));
1202     return SQ_ERROR;
1203   }
1204
1205 }
1206
1207 static SQInteger Player_kill_wrapper(HSQUIRRELVM vm)
1208 {
1209   SQUserPointer data;
1210   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1211     sq_throwerror(vm, _SC("'kill' called without instance"));
1212     return SQ_ERROR;
1213   }
1214   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1215   SQBool arg0;
1216   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1217     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1218     return SQ_ERROR;
1219   }
1220
1221   try {
1222     _this->kill(arg0 == SQTrue);
1223
1224     return 0;
1225
1226   } catch(std::exception& e) {
1227     sq_throwerror(vm, e.what());
1228     return SQ_ERROR;
1229   } catch(...) {
1230     sq_throwerror(vm, _SC("Unexpected exception while executing function 'kill'"));
1231     return SQ_ERROR;
1232   }
1233
1234 }
1235
1236 static SQInteger Player_set_ghost_mode_wrapper(HSQUIRRELVM vm)
1237 {
1238   SQUserPointer data;
1239   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1240     sq_throwerror(vm, _SC("'set_ghost_mode' called without instance"));
1241     return SQ_ERROR;
1242   }
1243   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1244   SQBool arg0;
1245   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1246     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1247     return SQ_ERROR;
1248   }
1249
1250   try {
1251     _this->set_ghost_mode(arg0 == SQTrue);
1252
1253     return 0;
1254
1255   } catch(std::exception& e) {
1256     sq_throwerror(vm, e.what());
1257     return SQ_ERROR;
1258   } catch(...) {
1259     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_ghost_mode'"));
1260     return SQ_ERROR;
1261   }
1262
1263 }
1264
1265 static SQInteger Player_get_ghost_mode_wrapper(HSQUIRRELVM vm)
1266 {
1267   SQUserPointer data;
1268   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1269     sq_throwerror(vm, _SC("'get_ghost_mode' called without instance"));
1270     return SQ_ERROR;
1271   }
1272   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1273
1274   try {
1275     bool return_value = _this->get_ghost_mode();
1276
1277     sq_pushbool(vm, return_value);
1278     return 1;
1279
1280   } catch(std::exception& e) {
1281     sq_throwerror(vm, e.what());
1282     return SQ_ERROR;
1283   } catch(...) {
1284     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_ghost_mode'"));
1285     return SQ_ERROR;
1286   }
1287
1288 }
1289
1290 static SQInteger FloatingImage_release_hook(SQUserPointer ptr, SQInteger )
1291 {
1292   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (ptr);
1293   delete _this;
1294   return 0;
1295 }
1296
1297 static SQInteger FloatingImage_constructor_wrapper(HSQUIRRELVM vm)
1298 {
1299   const SQChar* arg0;
1300   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1301     sq_throwerror(vm, _SC("Argument 1 not a string"));
1302     return SQ_ERROR;
1303   }
1304
1305   try {
1306     Scripting::FloatingImage* _this = new Scripting::FloatingImage(arg0);
1307   if(SQ_FAILED(sq_setinstanceup(vm, 1, _this))) {
1308     sq_throwerror(vm, _SC("Couldn't setup instance of 'FloatingImage' class"));
1309     return SQ_ERROR;
1310   }
1311   sq_setreleasehook(vm, 1, FloatingImage_release_hook);
1312
1313     return 0;
1314
1315   } catch(std::exception& e) {
1316     sq_throwerror(vm, e.what());
1317     return SQ_ERROR;
1318   } catch(...) {
1319     sq_throwerror(vm, _SC("Unexpected exception while executing function 'constructor'"));
1320     return SQ_ERROR;
1321   }
1322
1323 }
1324
1325 static SQInteger FloatingImage_set_layer_wrapper(HSQUIRRELVM vm)
1326 {
1327   SQUserPointer data;
1328   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1329     sq_throwerror(vm, _SC("'set_layer' called without instance"));
1330     return SQ_ERROR;
1331   }
1332   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1333   SQInteger arg0;
1334   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
1335     sq_throwerror(vm, _SC("Argument 1 not an integer"));
1336     return SQ_ERROR;
1337   }
1338
1339   try {
1340     _this->set_layer(static_cast<int> (arg0));
1341
1342     return 0;
1343
1344   } catch(std::exception& e) {
1345     sq_throwerror(vm, e.what());
1346     return SQ_ERROR;
1347   } catch(...) {
1348     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_layer'"));
1349     return SQ_ERROR;
1350   }
1351
1352 }
1353
1354 static SQInteger FloatingImage_get_layer_wrapper(HSQUIRRELVM vm)
1355 {
1356   SQUserPointer data;
1357   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1358     sq_throwerror(vm, _SC("'get_layer' called without instance"));
1359     return SQ_ERROR;
1360   }
1361   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1362
1363   try {
1364     int return_value = _this->get_layer();
1365
1366     sq_pushinteger(vm, return_value);
1367     return 1;
1368
1369   } catch(std::exception& e) {
1370     sq_throwerror(vm, e.what());
1371     return SQ_ERROR;
1372   } catch(...) {
1373     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_layer'"));
1374     return SQ_ERROR;
1375   }
1376
1377 }
1378
1379 static SQInteger FloatingImage_set_pos_wrapper(HSQUIRRELVM vm)
1380 {
1381   SQUserPointer data;
1382   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1383     sq_throwerror(vm, _SC("'set_pos' called without instance"));
1384     return SQ_ERROR;
1385   }
1386   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1387   SQFloat arg0;
1388   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
1389     sq_throwerror(vm, _SC("Argument 1 not a float"));
1390     return SQ_ERROR;
1391   }
1392   SQFloat arg1;
1393   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
1394     sq_throwerror(vm, _SC("Argument 2 not a float"));
1395     return SQ_ERROR;
1396   }
1397
1398   try {
1399     _this->set_pos(static_cast<float> (arg0), static_cast<float> (arg1));
1400
1401     return 0;
1402
1403   } catch(std::exception& e) {
1404     sq_throwerror(vm, e.what());
1405     return SQ_ERROR;
1406   } catch(...) {
1407     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_pos'"));
1408     return SQ_ERROR;
1409   }
1410
1411 }
1412
1413 static SQInteger FloatingImage_get_pos_x_wrapper(HSQUIRRELVM vm)
1414 {
1415   SQUserPointer data;
1416   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1417     sq_throwerror(vm, _SC("'get_pos_x' called without instance"));
1418     return SQ_ERROR;
1419   }
1420   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1421
1422   try {
1423     float return_value = _this->get_pos_x();
1424
1425     sq_pushfloat(vm, return_value);
1426     return 1;
1427
1428   } catch(std::exception& e) {
1429     sq_throwerror(vm, e.what());
1430     return SQ_ERROR;
1431   } catch(...) {
1432     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_x'"));
1433     return SQ_ERROR;
1434   }
1435
1436 }
1437
1438 static SQInteger FloatingImage_get_pos_y_wrapper(HSQUIRRELVM vm)
1439 {
1440   SQUserPointer data;
1441   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1442     sq_throwerror(vm, _SC("'get_pos_y' called without instance"));
1443     return SQ_ERROR;
1444   }
1445   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1446
1447   try {
1448     float return_value = _this->get_pos_y();
1449
1450     sq_pushfloat(vm, return_value);
1451     return 1;
1452
1453   } catch(std::exception& e) {
1454     sq_throwerror(vm, e.what());
1455     return SQ_ERROR;
1456   } catch(...) {
1457     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_y'"));
1458     return SQ_ERROR;
1459   }
1460
1461 }
1462
1463 static SQInteger FloatingImage_set_anchor_point_wrapper(HSQUIRRELVM vm)
1464 {
1465   SQUserPointer data;
1466   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1467     sq_throwerror(vm, _SC("'set_anchor_point' called without instance"));
1468     return SQ_ERROR;
1469   }
1470   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1471   SQInteger arg0;
1472   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
1473     sq_throwerror(vm, _SC("Argument 1 not an integer"));
1474     return SQ_ERROR;
1475   }
1476
1477   try {
1478     _this->set_anchor_point(static_cast<int> (arg0));
1479
1480     return 0;
1481
1482   } catch(std::exception& e) {
1483     sq_throwerror(vm, e.what());
1484     return SQ_ERROR;
1485   } catch(...) {
1486     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_anchor_point'"));
1487     return SQ_ERROR;
1488   }
1489
1490 }
1491
1492 static SQInteger FloatingImage_get_anchor_point_wrapper(HSQUIRRELVM vm)
1493 {
1494   SQUserPointer data;
1495   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1496     sq_throwerror(vm, _SC("'get_anchor_point' called without instance"));
1497     return SQ_ERROR;
1498   }
1499   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1500
1501   try {
1502     int return_value = _this->get_anchor_point();
1503
1504     sq_pushinteger(vm, return_value);
1505     return 1;
1506
1507   } catch(std::exception& e) {
1508     sq_throwerror(vm, e.what());
1509     return SQ_ERROR;
1510   } catch(...) {
1511     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_anchor_point'"));
1512     return SQ_ERROR;
1513   }
1514
1515 }
1516
1517 static SQInteger FloatingImage_set_visible_wrapper(HSQUIRRELVM vm)
1518 {
1519   SQUserPointer data;
1520   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1521     sq_throwerror(vm, _SC("'set_visible' called without instance"));
1522     return SQ_ERROR;
1523   }
1524   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1525   SQBool arg0;
1526   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1527     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1528     return SQ_ERROR;
1529   }
1530
1531   try {
1532     _this->set_visible(arg0 == SQTrue);
1533
1534     return 0;
1535
1536   } catch(std::exception& e) {
1537     sq_throwerror(vm, e.what());
1538     return SQ_ERROR;
1539   } catch(...) {
1540     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_visible'"));
1541     return SQ_ERROR;
1542   }
1543
1544 }
1545
1546 static SQInteger FloatingImage_get_visible_wrapper(HSQUIRRELVM vm)
1547 {
1548   SQUserPointer data;
1549   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1550     sq_throwerror(vm, _SC("'get_visible' called without instance"));
1551     return SQ_ERROR;
1552   }
1553   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1554
1555   try {
1556     bool return_value = _this->get_visible();
1557
1558     sq_pushbool(vm, return_value);
1559     return 1;
1560
1561   } catch(std::exception& e) {
1562     sq_throwerror(vm, e.what());
1563     return SQ_ERROR;
1564   } catch(...) {
1565     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_visible'"));
1566     return SQ_ERROR;
1567   }
1568
1569 }
1570
1571 static SQInteger FloatingImage_set_action_wrapper(HSQUIRRELVM vm)
1572 {
1573   SQUserPointer data;
1574   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1575     sq_throwerror(vm, _SC("'set_action' called without instance"));
1576     return SQ_ERROR;
1577   }
1578   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1579   const SQChar* arg0;
1580   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1581     sq_throwerror(vm, _SC("Argument 1 not a string"));
1582     return SQ_ERROR;
1583   }
1584
1585   try {
1586     _this->set_action(arg0);
1587
1588     return 0;
1589
1590   } catch(std::exception& e) {
1591     sq_throwerror(vm, e.what());
1592     return SQ_ERROR;
1593   } catch(...) {
1594     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_action'"));
1595     return SQ_ERROR;
1596   }
1597
1598 }
1599
1600 static SQInteger FloatingImage_get_action_wrapper(HSQUIRRELVM vm)
1601 {
1602   SQUserPointer data;
1603   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1604     sq_throwerror(vm, _SC("'get_action' called without instance"));
1605     return SQ_ERROR;
1606   }
1607   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1608
1609   try {
1610     std::string return_value = _this->get_action();
1611
1612     sq_pushstring(vm, return_value.c_str(), return_value.size());
1613     return 1;
1614
1615   } catch(std::exception& e) {
1616     sq_throwerror(vm, e.what());
1617     return SQ_ERROR;
1618   } catch(...) {
1619     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_action'"));
1620     return SQ_ERROR;
1621   }
1622
1623 }
1624
1625 static SQInteger Platform_release_hook(SQUserPointer ptr, SQInteger )
1626 {
1627   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (ptr);
1628   delete _this;
1629   return 0;
1630 }
1631
1632 static SQInteger Platform_goto_node_wrapper(HSQUIRRELVM vm)
1633 {
1634   SQUserPointer data;
1635   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1636     sq_throwerror(vm, _SC("'goto_node' called without instance"));
1637     return SQ_ERROR;
1638   }
1639   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (data);
1640   SQInteger arg0;
1641   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
1642     sq_throwerror(vm, _SC("Argument 1 not an integer"));
1643     return SQ_ERROR;
1644   }
1645
1646   try {
1647     _this->goto_node(static_cast<int> (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 'goto_node'"));
1656     return SQ_ERROR;
1657   }
1658
1659 }
1660
1661 static SQInteger Platform_start_moving_wrapper(HSQUIRRELVM vm)
1662 {
1663   SQUserPointer data;
1664   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1665     sq_throwerror(vm, _SC("'start_moving' called without instance"));
1666     return SQ_ERROR;
1667   }
1668   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (data);
1669
1670   try {
1671     _this->start_moving();
1672
1673     return 0;
1674
1675   } catch(std::exception& e) {
1676     sq_throwerror(vm, e.what());
1677     return SQ_ERROR;
1678   } catch(...) {
1679     sq_throwerror(vm, _SC("Unexpected exception while executing function 'start_moving'"));
1680     return SQ_ERROR;
1681   }
1682
1683 }
1684
1685 static SQInteger Platform_stop_moving_wrapper(HSQUIRRELVM vm)
1686 {
1687   SQUserPointer data;
1688   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1689     sq_throwerror(vm, _SC("'stop_moving' called without instance"));
1690     return SQ_ERROR;
1691   }
1692   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (data);
1693
1694   try {
1695     _this->stop_moving();
1696
1697     return 0;
1698
1699   } catch(std::exception& e) {
1700     sq_throwerror(vm, e.what());
1701     return SQ_ERROR;
1702   } catch(...) {
1703     sq_throwerror(vm, _SC("Unexpected exception while executing function 'stop_moving'"));
1704     return SQ_ERROR;
1705   }
1706
1707 }
1708
1709 static SQInteger display_wrapper(HSQUIRRELVM vm)
1710 {
1711   return Scripting::display(vm);
1712 }
1713
1714 static SQInteger print_stacktrace_wrapper(HSQUIRRELVM vm)
1715 {
1716   HSQUIRRELVM arg0 = vm;
1717
1718   try {
1719     Scripting::print_stacktrace(arg0);
1720
1721     return 0;
1722
1723   } catch(std::exception& e) {
1724     sq_throwerror(vm, e.what());
1725     return SQ_ERROR;
1726   } catch(...) {
1727     sq_throwerror(vm, _SC("Unexpected exception while executing function 'print_stacktrace'"));
1728     return SQ_ERROR;
1729   }
1730
1731 }
1732
1733 static SQInteger get_current_thread_wrapper(HSQUIRRELVM vm)
1734 {
1735   return Scripting::get_current_thread(vm);
1736 }
1737
1738 static SQInteger display_text_file_wrapper(HSQUIRRELVM vm)
1739 {
1740   const SQChar* arg0;
1741   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1742     sq_throwerror(vm, _SC("Argument 1 not a string"));
1743     return SQ_ERROR;
1744   }
1745
1746   try {
1747     Scripting::display_text_file(arg0);
1748
1749     return 0;
1750
1751   } catch(std::exception& e) {
1752     sq_throwerror(vm, e.what());
1753     return SQ_ERROR;
1754   } catch(...) {
1755     sq_throwerror(vm, _SC("Unexpected exception while executing function 'display_text_file'"));
1756     return SQ_ERROR;
1757   }
1758
1759 }
1760
1761 static SQInteger load_worldmap_wrapper(HSQUIRRELVM vm)
1762 {
1763   const SQChar* arg0;
1764   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1765     sq_throwerror(vm, _SC("Argument 1 not a string"));
1766     return SQ_ERROR;
1767   }
1768
1769   try {
1770     Scripting::load_worldmap(arg0);
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 'load_worldmap'"));
1779     return SQ_ERROR;
1780   }
1781
1782 }
1783
1784 static SQInteger load_level_wrapper(HSQUIRRELVM vm)
1785 {
1786   const SQChar* arg0;
1787   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1788     sq_throwerror(vm, _SC("Argument 1 not a string"));
1789     return SQ_ERROR;
1790   }
1791
1792   try {
1793     Scripting::load_level(arg0);
1794
1795     return 0;
1796
1797   } catch(std::exception& e) {
1798     sq_throwerror(vm, e.what());
1799     return SQ_ERROR;
1800   } catch(...) {
1801     sq_throwerror(vm, _SC("Unexpected exception while executing function 'load_level'"));
1802     return SQ_ERROR;
1803   }
1804
1805 }
1806
1807 static SQInteger wait_wrapper(HSQUIRRELVM vm)
1808 {
1809   HSQUIRRELVM arg0 = vm;
1810   SQFloat arg1;
1811   if(SQ_FAILED(sq_getfloat(vm, 2, &arg1))) {
1812     sq_throwerror(vm, _SC("Argument 1 not a float"));
1813     return SQ_ERROR;
1814   }
1815
1816   try {
1817     Scripting::wait(arg0, static_cast<float> (arg1));
1818
1819     return sq_suspendvm(vm);
1820
1821   } catch(std::exception& e) {
1822     sq_throwerror(vm, e.what());
1823     return SQ_ERROR;
1824   } catch(...) {
1825     sq_throwerror(vm, _SC("Unexpected exception while executing function 'wait'"));
1826     return SQ_ERROR;
1827   }
1828
1829 }
1830
1831 static SQInteger wait_for_screenswitch_wrapper(HSQUIRRELVM vm)
1832 {
1833   HSQUIRRELVM arg0 = vm;
1834
1835   try {
1836     Scripting::wait_for_screenswitch(arg0);
1837
1838     return sq_suspendvm(vm);
1839
1840   } catch(std::exception& e) {
1841     sq_throwerror(vm, e.what());
1842     return SQ_ERROR;
1843   } catch(...) {
1844     sq_throwerror(vm, _SC("Unexpected exception while executing function 'wait_for_screenswitch'"));
1845     return SQ_ERROR;
1846   }
1847
1848 }
1849
1850 static SQInteger exit_screen_wrapper(HSQUIRRELVM vm)
1851 {
1852   (void) vm;
1853
1854   try {
1855     Scripting::exit_screen();
1856
1857     return 0;
1858
1859   } catch(std::exception& e) {
1860     sq_throwerror(vm, e.what());
1861     return SQ_ERROR;
1862   } catch(...) {
1863     sq_throwerror(vm, _SC("Unexpected exception while executing function 'exit_screen'"));
1864     return SQ_ERROR;
1865   }
1866
1867 }
1868
1869 static SQInteger fadeout_screen_wrapper(HSQUIRRELVM vm)
1870 {
1871   SQFloat arg0;
1872   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
1873     sq_throwerror(vm, _SC("Argument 1 not a float"));
1874     return SQ_ERROR;
1875   }
1876
1877   try {
1878     Scripting::fadeout_screen(static_cast<float> (arg0));
1879
1880     return 0;
1881
1882   } catch(std::exception& e) {
1883     sq_throwerror(vm, e.what());
1884     return SQ_ERROR;
1885   } catch(...) {
1886     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fadeout_screen'"));
1887     return SQ_ERROR;
1888   }
1889
1890 }
1891
1892 static SQInteger shrink_screen_wrapper(HSQUIRRELVM vm)
1893 {
1894   SQFloat arg0;
1895   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
1896     sq_throwerror(vm, _SC("Argument 1 not a float"));
1897     return SQ_ERROR;
1898   }
1899   SQFloat arg1;
1900   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
1901     sq_throwerror(vm, _SC("Argument 2 not a float"));
1902     return SQ_ERROR;
1903   }
1904   SQFloat arg2;
1905   if(SQ_FAILED(sq_getfloat(vm, 4, &arg2))) {
1906     sq_throwerror(vm, _SC("Argument 3 not a float"));
1907     return SQ_ERROR;
1908   }
1909
1910   try {
1911     Scripting::shrink_screen(static_cast<float> (arg0), static_cast<float> (arg1), static_cast<float> (arg2));
1912
1913     return 0;
1914
1915   } catch(std::exception& e) {
1916     sq_throwerror(vm, e.what());
1917     return SQ_ERROR;
1918   } catch(...) {
1919     sq_throwerror(vm, _SC("Unexpected exception while executing function 'shrink_screen'"));
1920     return SQ_ERROR;
1921   }
1922
1923 }
1924
1925 static SQInteger translate_wrapper(HSQUIRRELVM vm)
1926 {
1927   const SQChar* arg0;
1928   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1929     sq_throwerror(vm, _SC("Argument 1 not a string"));
1930     return SQ_ERROR;
1931   }
1932
1933   try {
1934     std::string return_value = Scripting::translate(arg0);
1935
1936     sq_pushstring(vm, return_value.c_str(), return_value.size());
1937     return 1;
1938
1939   } catch(std::exception& e) {
1940     sq_throwerror(vm, e.what());
1941     return SQ_ERROR;
1942   } catch(...) {
1943     sq_throwerror(vm, _SC("Unexpected exception while executing function 'translate'"));
1944     return SQ_ERROR;
1945   }
1946
1947 }
1948
1949 static SQInteger import_wrapper(HSQUIRRELVM vm)
1950 {
1951   HSQUIRRELVM arg0 = vm;
1952   const SQChar* arg1;
1953   if(SQ_FAILED(sq_getstring(vm, 2, &arg1))) {
1954     sq_throwerror(vm, _SC("Argument 1 not a string"));
1955     return SQ_ERROR;
1956   }
1957
1958   try {
1959     Scripting::import(arg0, arg1);
1960
1961     return 0;
1962
1963   } catch(std::exception& e) {
1964     sq_throwerror(vm, e.what());
1965     return SQ_ERROR;
1966   } catch(...) {
1967     sq_throwerror(vm, _SC("Unexpected exception while executing function 'import'"));
1968     return SQ_ERROR;
1969   }
1970
1971 }
1972
1973 static SQInteger save_state_wrapper(HSQUIRRELVM vm)
1974 {
1975   (void) vm;
1976
1977   try {
1978     Scripting::save_state();
1979
1980     return 0;
1981
1982   } catch(std::exception& e) {
1983     sq_throwerror(vm, e.what());
1984     return SQ_ERROR;
1985   } catch(...) {
1986     sq_throwerror(vm, _SC("Unexpected exception while executing function 'save_state'"));
1987     return SQ_ERROR;
1988   }
1989
1990 }
1991
1992 static SQInteger debug_collrects_wrapper(HSQUIRRELVM vm)
1993 {
1994   SQBool arg0;
1995   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1996     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1997     return SQ_ERROR;
1998   }
1999
2000   try {
2001     Scripting::debug_collrects(arg0 == SQTrue);
2002
2003     return 0;
2004
2005   } catch(std::exception& e) {
2006     sq_throwerror(vm, e.what());
2007     return SQ_ERROR;
2008   } catch(...) {
2009     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_collrects'"));
2010     return SQ_ERROR;
2011   }
2012
2013 }
2014
2015 static SQInteger debug_show_fps_wrapper(HSQUIRRELVM vm)
2016 {
2017   SQBool arg0;
2018   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
2019     sq_throwerror(vm, _SC("Argument 1 not a bool"));
2020     return SQ_ERROR;
2021   }
2022
2023   try {
2024     Scripting::debug_show_fps(arg0 == SQTrue);
2025
2026     return 0;
2027
2028   } catch(std::exception& e) {
2029     sq_throwerror(vm, e.what());
2030     return SQ_ERROR;
2031   } catch(...) {
2032     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_show_fps'"));
2033     return SQ_ERROR;
2034   }
2035
2036 }
2037
2038 static SQInteger debug_draw_solids_only_wrapper(HSQUIRRELVM vm)
2039 {
2040   SQBool arg0;
2041   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
2042     sq_throwerror(vm, _SC("Argument 1 not a bool"));
2043     return SQ_ERROR;
2044   }
2045
2046   try {
2047     Scripting::debug_draw_solids_only(arg0 == SQTrue);
2048
2049     return 0;
2050
2051   } catch(std::exception& e) {
2052     sq_throwerror(vm, e.what());
2053     return SQ_ERROR;
2054   } catch(...) {
2055     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_draw_solids_only'"));
2056     return SQ_ERROR;
2057   }
2058
2059 }
2060
2061 static SQInteger play_music_wrapper(HSQUIRRELVM vm)
2062 {
2063   const SQChar* arg0;
2064   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2065     sq_throwerror(vm, _SC("Argument 1 not a string"));
2066     return SQ_ERROR;
2067   }
2068
2069   try {
2070     Scripting::play_music(arg0);
2071
2072     return 0;
2073
2074   } catch(std::exception& e) {
2075     sq_throwerror(vm, e.what());
2076     return SQ_ERROR;
2077   } catch(...) {
2078     sq_throwerror(vm, _SC("Unexpected exception while executing function 'play_music'"));
2079     return SQ_ERROR;
2080   }
2081
2082 }
2083
2084 static SQInteger play_sound_wrapper(HSQUIRRELVM vm)
2085 {
2086   const SQChar* arg0;
2087   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2088     sq_throwerror(vm, _SC("Argument 1 not a string"));
2089     return SQ_ERROR;
2090   }
2091
2092   try {
2093     Scripting::play_sound(arg0);
2094
2095     return 0;
2096
2097   } catch(std::exception& e) {
2098     sq_throwerror(vm, e.what());
2099     return SQ_ERROR;
2100   } catch(...) {
2101     sq_throwerror(vm, _SC("Unexpected exception while executing function 'play_sound'"));
2102     return SQ_ERROR;
2103   }
2104
2105 }
2106
2107 static SQInteger grease_wrapper(HSQUIRRELVM vm)
2108 {
2109   (void) vm;
2110
2111   try {
2112     Scripting::grease();
2113
2114     return 0;
2115
2116   } catch(std::exception& e) {
2117     sq_throwerror(vm, e.what());
2118     return SQ_ERROR;
2119   } catch(...) {
2120     sq_throwerror(vm, _SC("Unexpected exception while executing function 'grease'"));
2121     return SQ_ERROR;
2122   }
2123
2124 }
2125
2126 static SQInteger invincible_wrapper(HSQUIRRELVM vm)
2127 {
2128   (void) vm;
2129
2130   try {
2131     Scripting::invincible();
2132
2133     return 0;
2134
2135   } catch(std::exception& e) {
2136     sq_throwerror(vm, e.what());
2137     return SQ_ERROR;
2138   } catch(...) {
2139     sq_throwerror(vm, _SC("Unexpected exception while executing function 'invincible'"));
2140     return SQ_ERROR;
2141   }
2142
2143 }
2144
2145 static SQInteger ghost_wrapper(HSQUIRRELVM vm)
2146 {
2147   (void) vm;
2148
2149   try {
2150     Scripting::ghost();
2151
2152     return 0;
2153
2154   } catch(std::exception& e) {
2155     sq_throwerror(vm, e.what());
2156     return SQ_ERROR;
2157   } catch(...) {
2158     sq_throwerror(vm, _SC("Unexpected exception while executing function 'ghost'"));
2159     return SQ_ERROR;
2160   }
2161
2162 }
2163
2164 static SQInteger mortal_wrapper(HSQUIRRELVM vm)
2165 {
2166   (void) vm;
2167
2168   try {
2169     Scripting::mortal();
2170
2171     return 0;
2172
2173   } catch(std::exception& e) {
2174     sq_throwerror(vm, e.what());
2175     return SQ_ERROR;
2176   } catch(...) {
2177     sq_throwerror(vm, _SC("Unexpected exception while executing function 'mortal'"));
2178     return SQ_ERROR;
2179   }
2180
2181 }
2182
2183 static SQInteger restart_wrapper(HSQUIRRELVM vm)
2184 {
2185   (void) vm;
2186
2187   try {
2188     Scripting::restart();
2189
2190     return 0;
2191
2192   } catch(std::exception& e) {
2193     sq_throwerror(vm, e.what());
2194     return SQ_ERROR;
2195   } catch(...) {
2196     sq_throwerror(vm, _SC("Unexpected exception while executing function 'restart'"));
2197     return SQ_ERROR;
2198   }
2199
2200 }
2201
2202 static SQInteger whereami_wrapper(HSQUIRRELVM vm)
2203 {
2204   (void) vm;
2205
2206   try {
2207     Scripting::whereami();
2208
2209     return 0;
2210
2211   } catch(std::exception& e) {
2212     sq_throwerror(vm, e.what());
2213     return SQ_ERROR;
2214   } catch(...) {
2215     sq_throwerror(vm, _SC("Unexpected exception while executing function 'whereami'"));
2216     return SQ_ERROR;
2217   }
2218
2219 }
2220
2221 static SQInteger gotoend_wrapper(HSQUIRRELVM vm)
2222 {
2223   (void) vm;
2224
2225   try {
2226     Scripting::gotoend();
2227
2228     return 0;
2229
2230   } catch(std::exception& e) {
2231     sq_throwerror(vm, e.what());
2232     return SQ_ERROR;
2233   } catch(...) {
2234     sq_throwerror(vm, _SC("Unexpected exception while executing function 'gotoend'"));
2235     return SQ_ERROR;
2236   }
2237
2238 }
2239
2240 static SQInteger camera_wrapper(HSQUIRRELVM vm)
2241 {
2242   (void) vm;
2243
2244   try {
2245     Scripting::camera();
2246
2247     return 0;
2248
2249   } catch(std::exception& e) {
2250     sq_throwerror(vm, e.what());
2251     return SQ_ERROR;
2252   } catch(...) {
2253     sq_throwerror(vm, _SC("Unexpected exception while executing function 'camera'"));
2254     return SQ_ERROR;
2255   }
2256
2257 }
2258
2259 static SQInteger quit_wrapper(HSQUIRRELVM vm)
2260 {
2261   (void) vm;
2262
2263   try {
2264     Scripting::quit();
2265
2266     return 0;
2267
2268   } catch(std::exception& e) {
2269     sq_throwerror(vm, e.what());
2270     return SQ_ERROR;
2271   } catch(...) {
2272     sq_throwerror(vm, _SC("Unexpected exception while executing function 'quit'"));
2273     return SQ_ERROR;
2274   }
2275
2276 }
2277
2278 static SQInteger rand_wrapper(HSQUIRRELVM vm)
2279 {
2280
2281   try {
2282     int return_value = Scripting::rand();
2283
2284     sq_pushinteger(vm, return_value);
2285     return 1;
2286
2287   } catch(std::exception& e) {
2288     sq_throwerror(vm, e.what());
2289     return SQ_ERROR;
2290   } catch(...) {
2291     sq_throwerror(vm, _SC("Unexpected exception while executing function 'rand'"));
2292     return SQ_ERROR;
2293   }
2294
2295 }
2296
2297 } // end of namespace Wrapper
2298
2299 void create_squirrel_instance(HSQUIRRELVM v, Scripting::DisplayEffect* object, bool setup_releasehook)
2300 {
2301   using namespace Wrapper;
2302
2303   sq_pushroottable(v);
2304   sq_pushstring(v, "DisplayEffect", -1);
2305   if(SQ_FAILED(sq_get(v, -2))) {
2306     std::ostringstream msg;
2307     msg << "Couldn't resolved squirrel type 'DisplayEffect'";
2308     throw SquirrelError(v, msg.str());
2309   }
2310
2311   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2312     std::ostringstream msg;
2313     msg << "Couldn't setup squirrel instance for object of type 'DisplayEffect'";
2314     throw SquirrelError(v, msg.str());
2315   }
2316   sq_remove(v, -2); // remove object name
2317
2318   if(setup_releasehook) {
2319     sq_setreleasehook(v, -1, DisplayEffect_release_hook);
2320   }
2321
2322   sq_remove(v, -2); // remove root table
2323 }
2324
2325 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Camera* object, bool setup_releasehook)
2326 {
2327   using namespace Wrapper;
2328
2329   sq_pushroottable(v);
2330   sq_pushstring(v, "Camera", -1);
2331   if(SQ_FAILED(sq_get(v, -2))) {
2332     std::ostringstream msg;
2333     msg << "Couldn't resolved squirrel type 'Camera'";
2334     throw SquirrelError(v, msg.str());
2335   }
2336
2337   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2338     std::ostringstream msg;
2339     msg << "Couldn't setup squirrel instance for object of type 'Camera'";
2340     throw SquirrelError(v, msg.str());
2341   }
2342   sq_remove(v, -2); // remove object name
2343
2344   if(setup_releasehook) {
2345     sq_setreleasehook(v, -1, Camera_release_hook);
2346   }
2347
2348   sq_remove(v, -2); // remove root table
2349 }
2350
2351 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Level* object, bool setup_releasehook)
2352 {
2353   using namespace Wrapper;
2354
2355   sq_pushroottable(v);
2356   sq_pushstring(v, "Level", -1);
2357   if(SQ_FAILED(sq_get(v, -2))) {
2358     std::ostringstream msg;
2359     msg << "Couldn't resolved squirrel type 'Level'";
2360     throw SquirrelError(v, msg.str());
2361   }
2362
2363   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2364     std::ostringstream msg;
2365     msg << "Couldn't setup squirrel instance for object of type 'Level'";
2366     throw SquirrelError(v, msg.str());
2367   }
2368   sq_remove(v, -2); // remove object name
2369
2370   if(setup_releasehook) {
2371     sq_setreleasehook(v, -1, Level_release_hook);
2372   }
2373
2374   sq_remove(v, -2); // remove root table
2375 }
2376
2377 void create_squirrel_instance(HSQUIRRELVM v, Scripting::ScriptedObject* object, bool setup_releasehook)
2378 {
2379   using namespace Wrapper;
2380
2381   sq_pushroottable(v);
2382   sq_pushstring(v, "ScriptedObject", -1);
2383   if(SQ_FAILED(sq_get(v, -2))) {
2384     std::ostringstream msg;
2385     msg << "Couldn't resolved squirrel type 'ScriptedObject'";
2386     throw SquirrelError(v, msg.str());
2387   }
2388
2389   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2390     std::ostringstream msg;
2391     msg << "Couldn't setup squirrel instance for object of type 'ScriptedObject'";
2392     throw SquirrelError(v, msg.str());
2393   }
2394   sq_remove(v, -2); // remove object name
2395
2396   if(setup_releasehook) {
2397     sq_setreleasehook(v, -1, ScriptedObject_release_hook);
2398   }
2399
2400   sq_remove(v, -2); // remove root table
2401 }
2402
2403 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Text* object, bool setup_releasehook)
2404 {
2405   using namespace Wrapper;
2406
2407   sq_pushroottable(v);
2408   sq_pushstring(v, "Text", -1);
2409   if(SQ_FAILED(sq_get(v, -2))) {
2410     std::ostringstream msg;
2411     msg << "Couldn't resolved squirrel type 'Text'";
2412     throw SquirrelError(v, msg.str());
2413   }
2414
2415   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2416     std::ostringstream msg;
2417     msg << "Couldn't setup squirrel instance for object of type 'Text'";
2418     throw SquirrelError(v, msg.str());
2419   }
2420   sq_remove(v, -2); // remove object name
2421
2422   if(setup_releasehook) {
2423     sq_setreleasehook(v, -1, Text_release_hook);
2424   }
2425
2426   sq_remove(v, -2); // remove root table
2427 }
2428
2429 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Player* object, bool setup_releasehook)
2430 {
2431   using namespace Wrapper;
2432
2433   sq_pushroottable(v);
2434   sq_pushstring(v, "Player", -1);
2435   if(SQ_FAILED(sq_get(v, -2))) {
2436     std::ostringstream msg;
2437     msg << "Couldn't resolved squirrel type 'Player'";
2438     throw SquirrelError(v, msg.str());
2439   }
2440
2441   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2442     std::ostringstream msg;
2443     msg << "Couldn't setup squirrel instance for object of type 'Player'";
2444     throw SquirrelError(v, msg.str());
2445   }
2446   sq_remove(v, -2); // remove object name
2447
2448   if(setup_releasehook) {
2449     sq_setreleasehook(v, -1, Player_release_hook);
2450   }
2451
2452   sq_remove(v, -2); // remove root table
2453 }
2454
2455 void create_squirrel_instance(HSQUIRRELVM v, Scripting::FloatingImage* object, bool setup_releasehook)
2456 {
2457   using namespace Wrapper;
2458
2459   sq_pushroottable(v);
2460   sq_pushstring(v, "FloatingImage", -1);
2461   if(SQ_FAILED(sq_get(v, -2))) {
2462     std::ostringstream msg;
2463     msg << "Couldn't resolved squirrel type 'FloatingImage'";
2464     throw SquirrelError(v, msg.str());
2465   }
2466
2467   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2468     std::ostringstream msg;
2469     msg << "Couldn't setup squirrel instance for object of type 'FloatingImage'";
2470     throw SquirrelError(v, msg.str());
2471   }
2472   sq_remove(v, -2); // remove object name
2473
2474   if(setup_releasehook) {
2475     sq_setreleasehook(v, -1, FloatingImage_release_hook);
2476   }
2477
2478   sq_remove(v, -2); // remove root table
2479 }
2480
2481 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Platform* object, bool setup_releasehook)
2482 {
2483   using namespace Wrapper;
2484
2485   sq_pushroottable(v);
2486   sq_pushstring(v, "Platform", -1);
2487   if(SQ_FAILED(sq_get(v, -2))) {
2488     std::ostringstream msg;
2489     msg << "Couldn't resolved squirrel type 'Platform'";
2490     throw SquirrelError(v, msg.str());
2491   }
2492
2493   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2494     std::ostringstream msg;
2495     msg << "Couldn't setup squirrel instance for object of type 'Platform'";
2496     throw SquirrelError(v, msg.str());
2497   }
2498   sq_remove(v, -2); // remove object name
2499
2500   if(setup_releasehook) {
2501     sq_setreleasehook(v, -1, Platform_release_hook);
2502   }
2503
2504   sq_remove(v, -2); // remove root table
2505 }
2506
2507 void register_supertux_wrapper(HSQUIRRELVM v)
2508 {
2509   using namespace Wrapper;
2510
2511   sq_pushstring(v, "ANCHOR_TOP", -1);
2512   sq_pushinteger(v, 16);
2513   if(SQ_FAILED(sq_createslot(v, -3))) {
2514     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP'");
2515   }
2516
2517   sq_pushstring(v, "ANCHOR_BOTTOM", -1);
2518   sq_pushinteger(v, 32);
2519   if(SQ_FAILED(sq_createslot(v, -3))) {
2520     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM'");
2521   }
2522
2523   sq_pushstring(v, "ANCHOR_LEFT", -1);
2524   sq_pushinteger(v, 1);
2525   if(SQ_FAILED(sq_createslot(v, -3))) {
2526     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_LEFT'");
2527   }
2528
2529   sq_pushstring(v, "ANCHOR_RIGHT", -1);
2530   sq_pushinteger(v, 2);
2531   if(SQ_FAILED(sq_createslot(v, -3))) {
2532     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_RIGHT'");
2533   }
2534
2535   sq_pushstring(v, "ANCHOR_MIDDLE", -1);
2536   sq_pushinteger(v, 0);
2537   if(SQ_FAILED(sq_createslot(v, -3))) {
2538     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_MIDDLE'");
2539   }
2540
2541   sq_pushstring(v, "ANCHOR_TOP_LEFT", -1);
2542   sq_pushinteger(v, 17);
2543   if(SQ_FAILED(sq_createslot(v, -3))) {
2544     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP_LEFT'");
2545   }
2546
2547   sq_pushstring(v, "ANCHOR_TOP_RIGHT", -1);
2548   sq_pushinteger(v, 18);
2549   if(SQ_FAILED(sq_createslot(v, -3))) {
2550     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP_RIGHT'");
2551   }
2552
2553   sq_pushstring(v, "ANCHOR_BOTTOM_LEFT", -1);
2554   sq_pushinteger(v, 33);
2555   if(SQ_FAILED(sq_createslot(v, -3))) {
2556     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM_LEFT'");
2557   }
2558
2559   sq_pushstring(v, "ANCHOR_BOTTOM_RIGHT", -1);
2560   sq_pushinteger(v, 34);
2561   if(SQ_FAILED(sq_createslot(v, -3))) {
2562     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM_RIGHT'");
2563   }
2564
2565   sq_pushstring(v, "display", -1);
2566   sq_newclosure(v, &display_wrapper, 0);
2567   if(SQ_FAILED(sq_createslot(v, -3))) {
2568     throw SquirrelError(v, "Couldn't register function 'display'");
2569   }
2570
2571   sq_pushstring(v, "print_stacktrace", -1);
2572   sq_newclosure(v, &print_stacktrace_wrapper, 0);
2573   if(SQ_FAILED(sq_createslot(v, -3))) {
2574     throw SquirrelError(v, "Couldn't register function 'print_stacktrace'");
2575   }
2576
2577   sq_pushstring(v, "get_current_thread", -1);
2578   sq_newclosure(v, &get_current_thread_wrapper, 0);
2579   if(SQ_FAILED(sq_createslot(v, -3))) {
2580     throw SquirrelError(v, "Couldn't register function 'get_current_thread'");
2581   }
2582
2583   sq_pushstring(v, "display_text_file", -1);
2584   sq_newclosure(v, &display_text_file_wrapper, 0);
2585   if(SQ_FAILED(sq_createslot(v, -3))) {
2586     throw SquirrelError(v, "Couldn't register function 'display_text_file'");
2587   }
2588
2589   sq_pushstring(v, "load_worldmap", -1);
2590   sq_newclosure(v, &load_worldmap_wrapper, 0);
2591   if(SQ_FAILED(sq_createslot(v, -3))) {
2592     throw SquirrelError(v, "Couldn't register function 'load_worldmap'");
2593   }
2594
2595   sq_pushstring(v, "load_level", -1);
2596   sq_newclosure(v, &load_level_wrapper, 0);
2597   if(SQ_FAILED(sq_createslot(v, -3))) {
2598     throw SquirrelError(v, "Couldn't register function 'load_level'");
2599   }
2600
2601   sq_pushstring(v, "wait", -1);
2602   sq_newclosure(v, &wait_wrapper, 0);
2603   if(SQ_FAILED(sq_createslot(v, -3))) {
2604     throw SquirrelError(v, "Couldn't register function 'wait'");
2605   }
2606
2607   sq_pushstring(v, "wait_for_screenswitch", -1);
2608   sq_newclosure(v, &wait_for_screenswitch_wrapper, 0);
2609   if(SQ_FAILED(sq_createslot(v, -3))) {
2610     throw SquirrelError(v, "Couldn't register function 'wait_for_screenswitch'");
2611   }
2612
2613   sq_pushstring(v, "exit_screen", -1);
2614   sq_newclosure(v, &exit_screen_wrapper, 0);
2615   if(SQ_FAILED(sq_createslot(v, -3))) {
2616     throw SquirrelError(v, "Couldn't register function 'exit_screen'");
2617   }
2618
2619   sq_pushstring(v, "fadeout_screen", -1);
2620   sq_newclosure(v, &fadeout_screen_wrapper, 0);
2621   if(SQ_FAILED(sq_createslot(v, -3))) {
2622     throw SquirrelError(v, "Couldn't register function 'fadeout_screen'");
2623   }
2624
2625   sq_pushstring(v, "shrink_screen", -1);
2626   sq_newclosure(v, &shrink_screen_wrapper, 0);
2627   if(SQ_FAILED(sq_createslot(v, -3))) {
2628     throw SquirrelError(v, "Couldn't register function 'shrink_screen'");
2629   }
2630
2631   sq_pushstring(v, "translate", -1);
2632   sq_newclosure(v, &translate_wrapper, 0);
2633   if(SQ_FAILED(sq_createslot(v, -3))) {
2634     throw SquirrelError(v, "Couldn't register function 'translate'");
2635   }
2636
2637   sq_pushstring(v, "import", -1);
2638   sq_newclosure(v, &import_wrapper, 0);
2639   if(SQ_FAILED(sq_createslot(v, -3))) {
2640     throw SquirrelError(v, "Couldn't register function 'import'");
2641   }
2642
2643   sq_pushstring(v, "save_state", -1);
2644   sq_newclosure(v, &save_state_wrapper, 0);
2645   if(SQ_FAILED(sq_createslot(v, -3))) {
2646     throw SquirrelError(v, "Couldn't register function 'save_state'");
2647   }
2648
2649   sq_pushstring(v, "debug_collrects", -1);
2650   sq_newclosure(v, &debug_collrects_wrapper, 0);
2651   if(SQ_FAILED(sq_createslot(v, -3))) {
2652     throw SquirrelError(v, "Couldn't register function 'debug_collrects'");
2653   }
2654
2655   sq_pushstring(v, "debug_show_fps", -1);
2656   sq_newclosure(v, &debug_show_fps_wrapper, 0);
2657   if(SQ_FAILED(sq_createslot(v, -3))) {
2658     throw SquirrelError(v, "Couldn't register function 'debug_show_fps'");
2659   }
2660
2661   sq_pushstring(v, "debug_draw_solids_only", -1);
2662   sq_newclosure(v, &debug_draw_solids_only_wrapper, 0);
2663   if(SQ_FAILED(sq_createslot(v, -3))) {
2664     throw SquirrelError(v, "Couldn't register function 'debug_draw_solids_only'");
2665   }
2666
2667   sq_pushstring(v, "play_music", -1);
2668   sq_newclosure(v, &play_music_wrapper, 0);
2669   if(SQ_FAILED(sq_createslot(v, -3))) {
2670     throw SquirrelError(v, "Couldn't register function 'play_music'");
2671   }
2672
2673   sq_pushstring(v, "play_sound", -1);
2674   sq_newclosure(v, &play_sound_wrapper, 0);
2675   if(SQ_FAILED(sq_createslot(v, -3))) {
2676     throw SquirrelError(v, "Couldn't register function 'play_sound'");
2677   }
2678
2679   sq_pushstring(v, "grease", -1);
2680   sq_newclosure(v, &grease_wrapper, 0);
2681   if(SQ_FAILED(sq_createslot(v, -3))) {
2682     throw SquirrelError(v, "Couldn't register function 'grease'");
2683   }
2684
2685   sq_pushstring(v, "invincible", -1);
2686   sq_newclosure(v, &invincible_wrapper, 0);
2687   if(SQ_FAILED(sq_createslot(v, -3))) {
2688     throw SquirrelError(v, "Couldn't register function 'invincible'");
2689   }
2690
2691   sq_pushstring(v, "ghost", -1);
2692   sq_newclosure(v, &ghost_wrapper, 0);
2693   if(SQ_FAILED(sq_createslot(v, -3))) {
2694     throw SquirrelError(v, "Couldn't register function 'ghost'");
2695   }
2696
2697   sq_pushstring(v, "mortal", -1);
2698   sq_newclosure(v, &mortal_wrapper, 0);
2699   if(SQ_FAILED(sq_createslot(v, -3))) {
2700     throw SquirrelError(v, "Couldn't register function 'mortal'");
2701   }
2702
2703   sq_pushstring(v, "restart", -1);
2704   sq_newclosure(v, &restart_wrapper, 0);
2705   if(SQ_FAILED(sq_createslot(v, -3))) {
2706     throw SquirrelError(v, "Couldn't register function 'restart'");
2707   }
2708
2709   sq_pushstring(v, "whereami", -1);
2710   sq_newclosure(v, &whereami_wrapper, 0);
2711   if(SQ_FAILED(sq_createslot(v, -3))) {
2712     throw SquirrelError(v, "Couldn't register function 'whereami'");
2713   }
2714
2715   sq_pushstring(v, "gotoend", -1);
2716   sq_newclosure(v, &gotoend_wrapper, 0);
2717   if(SQ_FAILED(sq_createslot(v, -3))) {
2718     throw SquirrelError(v, "Couldn't register function 'gotoend'");
2719   }
2720
2721   sq_pushstring(v, "camera", -1);
2722   sq_newclosure(v, &camera_wrapper, 0);
2723   if(SQ_FAILED(sq_createslot(v, -3))) {
2724     throw SquirrelError(v, "Couldn't register function 'camera'");
2725   }
2726
2727   sq_pushstring(v, "quit", -1);
2728   sq_newclosure(v, &quit_wrapper, 0);
2729   if(SQ_FAILED(sq_createslot(v, -3))) {
2730     throw SquirrelError(v, "Couldn't register function 'quit'");
2731   }
2732
2733   sq_pushstring(v, "rand", -1);
2734   sq_newclosure(v, &rand_wrapper, 0);
2735   if(SQ_FAILED(sq_createslot(v, -3))) {
2736     throw SquirrelError(v, "Couldn't register function 'rand'");
2737   }
2738
2739   // Register class DisplayEffect
2740   sq_pushstring(v, "DisplayEffect", -1);
2741   if(sq_newclass(v, SQFalse) < 0) {
2742     std::ostringstream msg;
2743     msg << "Couldn't create new class 'DisplayEffect'";
2744     throw SquirrelError(v, msg.str());
2745   }
2746   sq_pushstring(v, "fade_out", -1);
2747   sq_newclosure(v, &DisplayEffect_fade_out_wrapper, 0);
2748   if(SQ_FAILED(sq_createslot(v, -3))) {
2749     throw SquirrelError(v, "Couldn't register function 'fade_out'");
2750   }
2751
2752   sq_pushstring(v, "fade_in", -1);
2753   sq_newclosure(v, &DisplayEffect_fade_in_wrapper, 0);
2754   if(SQ_FAILED(sq_createslot(v, -3))) {
2755     throw SquirrelError(v, "Couldn't register function 'fade_in'");
2756   }
2757
2758   sq_pushstring(v, "set_black", -1);
2759   sq_newclosure(v, &DisplayEffect_set_black_wrapper, 0);
2760   if(SQ_FAILED(sq_createslot(v, -3))) {
2761     throw SquirrelError(v, "Couldn't register function 'set_black'");
2762   }
2763
2764   sq_pushstring(v, "is_black", -1);
2765   sq_newclosure(v, &DisplayEffect_is_black_wrapper, 0);
2766   if(SQ_FAILED(sq_createslot(v, -3))) {
2767     throw SquirrelError(v, "Couldn't register function 'is_black'");
2768   }
2769
2770   sq_pushstring(v, "sixteen_to_nine", -1);
2771   sq_newclosure(v, &DisplayEffect_sixteen_to_nine_wrapper, 0);
2772   if(SQ_FAILED(sq_createslot(v, -3))) {
2773     throw SquirrelError(v, "Couldn't register function 'sixteen_to_nine'");
2774   }
2775
2776   sq_pushstring(v, "four_to_three", -1);
2777   sq_newclosure(v, &DisplayEffect_four_to_three_wrapper, 0);
2778   if(SQ_FAILED(sq_createslot(v, -3))) {
2779     throw SquirrelError(v, "Couldn't register function 'four_to_three'");
2780   }
2781
2782   if(SQ_FAILED(sq_createslot(v, -3))) {
2783     throw SquirrelError(v, "Couldn't register class 'DisplayEffect'");
2784   }
2785
2786   // Register class Camera
2787   sq_pushstring(v, "Camera", -1);
2788   if(sq_newclass(v, SQFalse) < 0) {
2789     std::ostringstream msg;
2790     msg << "Couldn't create new class 'Camera'";
2791     throw SquirrelError(v, msg.str());
2792   }
2793   sq_pushstring(v, "shake", -1);
2794   sq_newclosure(v, &Camera_shake_wrapper, 0);
2795   if(SQ_FAILED(sq_createslot(v, -3))) {
2796     throw SquirrelError(v, "Couldn't register function 'shake'");
2797   }
2798
2799   sq_pushstring(v, "set_pos", -1);
2800   sq_newclosure(v, &Camera_set_pos_wrapper, 0);
2801   if(SQ_FAILED(sq_createslot(v, -3))) {
2802     throw SquirrelError(v, "Couldn't register function 'set_pos'");
2803   }
2804
2805   sq_pushstring(v, "set_mode", -1);
2806   sq_newclosure(v, &Camera_set_mode_wrapper, 0);
2807   if(SQ_FAILED(sq_createslot(v, -3))) {
2808     throw SquirrelError(v, "Couldn't register function 'set_mode'");
2809   }
2810
2811   sq_pushstring(v, "scroll_to", -1);
2812   sq_newclosure(v, &Camera_scroll_to_wrapper, 0);
2813   if(SQ_FAILED(sq_createslot(v, -3))) {
2814     throw SquirrelError(v, "Couldn't register function 'scroll_to'");
2815   }
2816
2817   if(SQ_FAILED(sq_createslot(v, -3))) {
2818     throw SquirrelError(v, "Couldn't register class 'Camera'");
2819   }
2820
2821   // Register class Level
2822   sq_pushstring(v, "Level", -1);
2823   if(sq_newclass(v, SQFalse) < 0) {
2824     std::ostringstream msg;
2825     msg << "Couldn't create new class 'Level'";
2826     throw SquirrelError(v, msg.str());
2827   }
2828   sq_pushstring(v, "finish", -1);
2829   sq_newclosure(v, &Level_finish_wrapper, 0);
2830   if(SQ_FAILED(sq_createslot(v, -3))) {
2831     throw SquirrelError(v, "Couldn't register function 'finish'");
2832   }
2833
2834   sq_pushstring(v, "spawn", -1);
2835   sq_newclosure(v, &Level_spawn_wrapper, 0);
2836   if(SQ_FAILED(sq_createslot(v, -3))) {
2837     throw SquirrelError(v, "Couldn't register function 'spawn'");
2838   }
2839
2840   sq_pushstring(v, "flip_vertically", -1);
2841   sq_newclosure(v, &Level_flip_vertically_wrapper, 0);
2842   if(SQ_FAILED(sq_createslot(v, -3))) {
2843     throw SquirrelError(v, "Couldn't register function 'flip_vertically'");
2844   }
2845
2846   sq_pushstring(v, "toggle_pause", -1);
2847   sq_newclosure(v, &Level_toggle_pause_wrapper, 0);
2848   if(SQ_FAILED(sq_createslot(v, -3))) {
2849     throw SquirrelError(v, "Couldn't register function 'toggle_pause'");
2850   }
2851
2852   if(SQ_FAILED(sq_createslot(v, -3))) {
2853     throw SquirrelError(v, "Couldn't register class 'Level'");
2854   }
2855
2856   // Register class ScriptedObject
2857   sq_pushstring(v, "ScriptedObject", -1);
2858   if(sq_newclass(v, SQFalse) < 0) {
2859     std::ostringstream msg;
2860     msg << "Couldn't create new class 'ScriptedObject'";
2861     throw SquirrelError(v, msg.str());
2862   }
2863   sq_pushstring(v, "set_action", -1);
2864   sq_newclosure(v, &ScriptedObject_set_action_wrapper, 0);
2865   if(SQ_FAILED(sq_createslot(v, -3))) {
2866     throw SquirrelError(v, "Couldn't register function 'set_action'");
2867   }
2868
2869   sq_pushstring(v, "get_action", -1);
2870   sq_newclosure(v, &ScriptedObject_get_action_wrapper, 0);
2871   if(SQ_FAILED(sq_createslot(v, -3))) {
2872     throw SquirrelError(v, "Couldn't register function 'get_action'");
2873   }
2874
2875   sq_pushstring(v, "move", -1);
2876   sq_newclosure(v, &ScriptedObject_move_wrapper, 0);
2877   if(SQ_FAILED(sq_createslot(v, -3))) {
2878     throw SquirrelError(v, "Couldn't register function 'move'");
2879   }
2880
2881   sq_pushstring(v, "set_pos", -1);
2882   sq_newclosure(v, &ScriptedObject_set_pos_wrapper, 0);
2883   if(SQ_FAILED(sq_createslot(v, -3))) {
2884     throw SquirrelError(v, "Couldn't register function 'set_pos'");
2885   }
2886
2887   sq_pushstring(v, "get_pos_x", -1);
2888   sq_newclosure(v, &ScriptedObject_get_pos_x_wrapper, 0);
2889   if(SQ_FAILED(sq_createslot(v, -3))) {
2890     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
2891   }
2892
2893   sq_pushstring(v, "get_pos_y", -1);
2894   sq_newclosure(v, &ScriptedObject_get_pos_y_wrapper, 0);
2895   if(SQ_FAILED(sq_createslot(v, -3))) {
2896     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
2897   }
2898
2899   sq_pushstring(v, "set_velocity", -1);
2900   sq_newclosure(v, &ScriptedObject_set_velocity_wrapper, 0);
2901   if(SQ_FAILED(sq_createslot(v, -3))) {
2902     throw SquirrelError(v, "Couldn't register function 'set_velocity'");
2903   }
2904
2905   sq_pushstring(v, "get_velocity_x", -1);
2906   sq_newclosure(v, &ScriptedObject_get_velocity_x_wrapper, 0);
2907   if(SQ_FAILED(sq_createslot(v, -3))) {
2908     throw SquirrelError(v, "Couldn't register function 'get_velocity_x'");
2909   }
2910
2911   sq_pushstring(v, "get_velocity_y", -1);
2912   sq_newclosure(v, &ScriptedObject_get_velocity_y_wrapper, 0);
2913   if(SQ_FAILED(sq_createslot(v, -3))) {
2914     throw SquirrelError(v, "Couldn't register function 'get_velocity_y'");
2915   }
2916
2917   sq_pushstring(v, "set_visible", -1);
2918   sq_newclosure(v, &ScriptedObject_set_visible_wrapper, 0);
2919   if(SQ_FAILED(sq_createslot(v, -3))) {
2920     throw SquirrelError(v, "Couldn't register function 'set_visible'");
2921   }
2922
2923   sq_pushstring(v, "is_visible", -1);
2924   sq_newclosure(v, &ScriptedObject_is_visible_wrapper, 0);
2925   if(SQ_FAILED(sq_createslot(v, -3))) {
2926     throw SquirrelError(v, "Couldn't register function 'is_visible'");
2927   }
2928
2929   sq_pushstring(v, "get_name", -1);
2930   sq_newclosure(v, &ScriptedObject_get_name_wrapper, 0);
2931   if(SQ_FAILED(sq_createslot(v, -3))) {
2932     throw SquirrelError(v, "Couldn't register function 'get_name'");
2933   }
2934
2935   if(SQ_FAILED(sq_createslot(v, -3))) {
2936     throw SquirrelError(v, "Couldn't register class 'ScriptedObject'");
2937   }
2938
2939   // Register class Text
2940   sq_pushstring(v, "Text", -1);
2941   if(sq_newclass(v, SQFalse) < 0) {
2942     std::ostringstream msg;
2943     msg << "Couldn't create new class 'Text'";
2944     throw SquirrelError(v, msg.str());
2945   }
2946   sq_pushstring(v, "set_text", -1);
2947   sq_newclosure(v, &Text_set_text_wrapper, 0);
2948   if(SQ_FAILED(sq_createslot(v, -3))) {
2949     throw SquirrelError(v, "Couldn't register function 'set_text'");
2950   }
2951
2952   sq_pushstring(v, "set_font", -1);
2953   sq_newclosure(v, &Text_set_font_wrapper, 0);
2954   if(SQ_FAILED(sq_createslot(v, -3))) {
2955     throw SquirrelError(v, "Couldn't register function 'set_font'");
2956   }
2957
2958   sq_pushstring(v, "fade_in", -1);
2959   sq_newclosure(v, &Text_fade_in_wrapper, 0);
2960   if(SQ_FAILED(sq_createslot(v, -3))) {
2961     throw SquirrelError(v, "Couldn't register function 'fade_in'");
2962   }
2963
2964   sq_pushstring(v, "fade_out", -1);
2965   sq_newclosure(v, &Text_fade_out_wrapper, 0);
2966   if(SQ_FAILED(sq_createslot(v, -3))) {
2967     throw SquirrelError(v, "Couldn't register function 'fade_out'");
2968   }
2969
2970   sq_pushstring(v, "set_visible", -1);
2971   sq_newclosure(v, &Text_set_visible_wrapper, 0);
2972   if(SQ_FAILED(sq_createslot(v, -3))) {
2973     throw SquirrelError(v, "Couldn't register function 'set_visible'");
2974   }
2975
2976   sq_pushstring(v, "set_centered", -1);
2977   sq_newclosure(v, &Text_set_centered_wrapper, 0);
2978   if(SQ_FAILED(sq_createslot(v, -3))) {
2979     throw SquirrelError(v, "Couldn't register function 'set_centered'");
2980   }
2981
2982   if(SQ_FAILED(sq_createslot(v, -3))) {
2983     throw SquirrelError(v, "Couldn't register class 'Text'");
2984   }
2985
2986   // Register class Player
2987   sq_pushstring(v, "Player", -1);
2988   if(sq_newclass(v, SQFalse) < 0) {
2989     std::ostringstream msg;
2990     msg << "Couldn't create new class 'Player'";
2991     throw SquirrelError(v, msg.str());
2992   }
2993   sq_pushstring(v, "add_bonus", -1);
2994   sq_newclosure(v, &Player_add_bonus_wrapper, 0);
2995   if(SQ_FAILED(sq_createslot(v, -3))) {
2996     throw SquirrelError(v, "Couldn't register function 'add_bonus'");
2997   }
2998
2999   sq_pushstring(v, "add_coins", -1);
3000   sq_newclosure(v, &Player_add_coins_wrapper, 0);
3001   if(SQ_FAILED(sq_createslot(v, -3))) {
3002     throw SquirrelError(v, "Couldn't register function 'add_coins'");
3003   }
3004
3005   sq_pushstring(v, "make_invincible", -1);
3006   sq_newclosure(v, &Player_make_invincible_wrapper, 0);
3007   if(SQ_FAILED(sq_createslot(v, -3))) {
3008     throw SquirrelError(v, "Couldn't register function 'make_invincible'");
3009   }
3010
3011   sq_pushstring(v, "deactivate", -1);
3012   sq_newclosure(v, &Player_deactivate_wrapper, 0);
3013   if(SQ_FAILED(sq_createslot(v, -3))) {
3014     throw SquirrelError(v, "Couldn't register function 'deactivate'");
3015   }
3016
3017   sq_pushstring(v, "activate", -1);
3018   sq_newclosure(v, &Player_activate_wrapper, 0);
3019   if(SQ_FAILED(sq_createslot(v, -3))) {
3020     throw SquirrelError(v, "Couldn't register function 'activate'");
3021   }
3022
3023   sq_pushstring(v, "walk", -1);
3024   sq_newclosure(v, &Player_walk_wrapper, 0);
3025   if(SQ_FAILED(sq_createslot(v, -3))) {
3026     throw SquirrelError(v, "Couldn't register function 'walk'");
3027   }
3028
3029   sq_pushstring(v, "set_visible", -1);
3030   sq_newclosure(v, &Player_set_visible_wrapper, 0);
3031   if(SQ_FAILED(sq_createslot(v, -3))) {
3032     throw SquirrelError(v, "Couldn't register function 'set_visible'");
3033   }
3034
3035   sq_pushstring(v, "get_visible", -1);
3036   sq_newclosure(v, &Player_get_visible_wrapper, 0);
3037   if(SQ_FAILED(sq_createslot(v, -3))) {
3038     throw SquirrelError(v, "Couldn't register function 'get_visible'");
3039   }
3040
3041   sq_pushstring(v, "kill", -1);
3042   sq_newclosure(v, &Player_kill_wrapper, 0);
3043   if(SQ_FAILED(sq_createslot(v, -3))) {
3044     throw SquirrelError(v, "Couldn't register function 'kill'");
3045   }
3046
3047   sq_pushstring(v, "set_ghost_mode", -1);
3048   sq_newclosure(v, &Player_set_ghost_mode_wrapper, 0);
3049   if(SQ_FAILED(sq_createslot(v, -3))) {
3050     throw SquirrelError(v, "Couldn't register function 'set_ghost_mode'");
3051   }
3052
3053   sq_pushstring(v, "get_ghost_mode", -1);
3054   sq_newclosure(v, &Player_get_ghost_mode_wrapper, 0);
3055   if(SQ_FAILED(sq_createslot(v, -3))) {
3056     throw SquirrelError(v, "Couldn't register function 'get_ghost_mode'");
3057   }
3058
3059   if(SQ_FAILED(sq_createslot(v, -3))) {
3060     throw SquirrelError(v, "Couldn't register class 'Player'");
3061   }
3062
3063   // Register class FloatingImage
3064   sq_pushstring(v, "FloatingImage", -1);
3065   if(sq_newclass(v, SQFalse) < 0) {
3066     std::ostringstream msg;
3067     msg << "Couldn't create new class 'FloatingImage'";
3068     throw SquirrelError(v, msg.str());
3069   }
3070   sq_pushstring(v, "constructor", -1);
3071   sq_newclosure(v, &FloatingImage_constructor_wrapper, 0);
3072   if(SQ_FAILED(sq_createslot(v, -3))) {
3073     throw SquirrelError(v, "Couldn't register function 'constructor'");
3074   }
3075
3076   sq_pushstring(v, "set_layer", -1);
3077   sq_newclosure(v, &FloatingImage_set_layer_wrapper, 0);
3078   if(SQ_FAILED(sq_createslot(v, -3))) {
3079     throw SquirrelError(v, "Couldn't register function 'set_layer'");
3080   }
3081
3082   sq_pushstring(v, "get_layer", -1);
3083   sq_newclosure(v, &FloatingImage_get_layer_wrapper, 0);
3084   if(SQ_FAILED(sq_createslot(v, -3))) {
3085     throw SquirrelError(v, "Couldn't register function 'get_layer'");
3086   }
3087
3088   sq_pushstring(v, "set_pos", -1);
3089   sq_newclosure(v, &FloatingImage_set_pos_wrapper, 0);
3090   if(SQ_FAILED(sq_createslot(v, -3))) {
3091     throw SquirrelError(v, "Couldn't register function 'set_pos'");
3092   }
3093
3094   sq_pushstring(v, "get_pos_x", -1);
3095   sq_newclosure(v, &FloatingImage_get_pos_x_wrapper, 0);
3096   if(SQ_FAILED(sq_createslot(v, -3))) {
3097     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
3098   }
3099
3100   sq_pushstring(v, "get_pos_y", -1);
3101   sq_newclosure(v, &FloatingImage_get_pos_y_wrapper, 0);
3102   if(SQ_FAILED(sq_createslot(v, -3))) {
3103     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
3104   }
3105
3106   sq_pushstring(v, "set_anchor_point", -1);
3107   sq_newclosure(v, &FloatingImage_set_anchor_point_wrapper, 0);
3108   if(SQ_FAILED(sq_createslot(v, -3))) {
3109     throw SquirrelError(v, "Couldn't register function 'set_anchor_point'");
3110   }
3111
3112   sq_pushstring(v, "get_anchor_point", -1);
3113   sq_newclosure(v, &FloatingImage_get_anchor_point_wrapper, 0);
3114   if(SQ_FAILED(sq_createslot(v, -3))) {
3115     throw SquirrelError(v, "Couldn't register function 'get_anchor_point'");
3116   }
3117
3118   sq_pushstring(v, "set_visible", -1);
3119   sq_newclosure(v, &FloatingImage_set_visible_wrapper, 0);
3120   if(SQ_FAILED(sq_createslot(v, -3))) {
3121     throw SquirrelError(v, "Couldn't register function 'set_visible'");
3122   }
3123
3124   sq_pushstring(v, "get_visible", -1);
3125   sq_newclosure(v, &FloatingImage_get_visible_wrapper, 0);
3126   if(SQ_FAILED(sq_createslot(v, -3))) {
3127     throw SquirrelError(v, "Couldn't register function 'get_visible'");
3128   }
3129
3130   sq_pushstring(v, "set_action", -1);
3131   sq_newclosure(v, &FloatingImage_set_action_wrapper, 0);
3132   if(SQ_FAILED(sq_createslot(v, -3))) {
3133     throw SquirrelError(v, "Couldn't register function 'set_action'");
3134   }
3135
3136   sq_pushstring(v, "get_action", -1);
3137   sq_newclosure(v, &FloatingImage_get_action_wrapper, 0);
3138   if(SQ_FAILED(sq_createslot(v, -3))) {
3139     throw SquirrelError(v, "Couldn't register function 'get_action'");
3140   }
3141
3142   if(SQ_FAILED(sq_createslot(v, -3))) {
3143     throw SquirrelError(v, "Couldn't register class 'FloatingImage'");
3144   }
3145
3146   // Register class Platform
3147   sq_pushstring(v, "Platform", -1);
3148   if(sq_newclass(v, SQFalse) < 0) {
3149     std::ostringstream msg;
3150     msg << "Couldn't create new class 'Platform'";
3151     throw SquirrelError(v, msg.str());
3152   }
3153   sq_pushstring(v, "goto_node", -1);
3154   sq_newclosure(v, &Platform_goto_node_wrapper, 0);
3155   if(SQ_FAILED(sq_createslot(v, -3))) {
3156     throw SquirrelError(v, "Couldn't register function 'goto_node'");
3157   }
3158
3159   sq_pushstring(v, "start_moving", -1);
3160   sq_newclosure(v, &Platform_start_moving_wrapper, 0);
3161   if(SQ_FAILED(sq_createslot(v, -3))) {
3162     throw SquirrelError(v, "Couldn't register function 'start_moving'");
3163   }
3164
3165   sq_pushstring(v, "stop_moving", -1);
3166   sq_newclosure(v, &Platform_stop_moving_wrapper, 0);
3167   if(SQ_FAILED(sq_createslot(v, -3))) {
3168     throw SquirrelError(v, "Couldn't register function 'stop_moving'");
3169   }
3170
3171   if(SQ_FAILED(sq_createslot(v, -3))) {
3172     throw SquirrelError(v, "Couldn't register class 'Platform'");
3173   }
3174
3175 }
3176
3177 } // end of namespace Scripting
3178