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 Candle_release_hook(SQUserPointer ptr, SQInteger )
1710 {
1711   Scripting::Candle* _this = reinterpret_cast<Scripting::Candle*> (ptr);
1712   delete _this;
1713   return 0;
1714 }
1715
1716 static SQInteger Candle_get_burning_wrapper(HSQUIRRELVM vm)
1717 {
1718   SQUserPointer data;
1719   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1720     sq_throwerror(vm, _SC("'get_burning' called without instance"));
1721     return SQ_ERROR;
1722   }
1723   Scripting::Candle* _this = reinterpret_cast<Scripting::Candle*> (data);
1724
1725   try {
1726     bool return_value = _this->get_burning();
1727
1728     sq_pushbool(vm, return_value);
1729     return 1;
1730
1731   } catch(std::exception& e) {
1732     sq_throwerror(vm, e.what());
1733     return SQ_ERROR;
1734   } catch(...) {
1735     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_burning'"));
1736     return SQ_ERROR;
1737   }
1738
1739 }
1740
1741 static SQInteger Candle_set_burning_wrapper(HSQUIRRELVM vm)
1742 {
1743   SQUserPointer data;
1744   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1745     sq_throwerror(vm, _SC("'set_burning' called without instance"));
1746     return SQ_ERROR;
1747   }
1748   Scripting::Candle* _this = reinterpret_cast<Scripting::Candle*> (data);
1749   SQBool arg0;
1750   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1751     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1752     return SQ_ERROR;
1753   }
1754
1755   try {
1756     _this->set_burning(arg0 == SQTrue);
1757
1758     return 0;
1759
1760   } catch(std::exception& e) {
1761     sq_throwerror(vm, e.what());
1762     return SQ_ERROR;
1763   } catch(...) {
1764     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_burning'"));
1765     return SQ_ERROR;
1766   }
1767
1768 }
1769
1770 static SQInteger display_wrapper(HSQUIRRELVM vm)
1771 {
1772   return Scripting::display(vm);
1773 }
1774
1775 static SQInteger print_stacktrace_wrapper(HSQUIRRELVM vm)
1776 {
1777   HSQUIRRELVM arg0 = vm;
1778
1779   try {
1780     Scripting::print_stacktrace(arg0);
1781
1782     return 0;
1783
1784   } catch(std::exception& e) {
1785     sq_throwerror(vm, e.what());
1786     return SQ_ERROR;
1787   } catch(...) {
1788     sq_throwerror(vm, _SC("Unexpected exception while executing function 'print_stacktrace'"));
1789     return SQ_ERROR;
1790   }
1791
1792 }
1793
1794 static SQInteger get_current_thread_wrapper(HSQUIRRELVM vm)
1795 {
1796   return Scripting::get_current_thread(vm);
1797 }
1798
1799 static SQInteger display_text_file_wrapper(HSQUIRRELVM vm)
1800 {
1801   const SQChar* arg0;
1802   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1803     sq_throwerror(vm, _SC("Argument 1 not a string"));
1804     return SQ_ERROR;
1805   }
1806
1807   try {
1808     Scripting::display_text_file(arg0);
1809
1810     return 0;
1811
1812   } catch(std::exception& e) {
1813     sq_throwerror(vm, e.what());
1814     return SQ_ERROR;
1815   } catch(...) {
1816     sq_throwerror(vm, _SC("Unexpected exception while executing function 'display_text_file'"));
1817     return SQ_ERROR;
1818   }
1819
1820 }
1821
1822 static SQInteger load_worldmap_wrapper(HSQUIRRELVM vm)
1823 {
1824   const SQChar* arg0;
1825   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1826     sq_throwerror(vm, _SC("Argument 1 not a string"));
1827     return SQ_ERROR;
1828   }
1829
1830   try {
1831     Scripting::load_worldmap(arg0);
1832
1833     return 0;
1834
1835   } catch(std::exception& e) {
1836     sq_throwerror(vm, e.what());
1837     return SQ_ERROR;
1838   } catch(...) {
1839     sq_throwerror(vm, _SC("Unexpected exception while executing function 'load_worldmap'"));
1840     return SQ_ERROR;
1841   }
1842
1843 }
1844
1845 static SQInteger load_level_wrapper(HSQUIRRELVM vm)
1846 {
1847   const SQChar* arg0;
1848   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1849     sq_throwerror(vm, _SC("Argument 1 not a string"));
1850     return SQ_ERROR;
1851   }
1852
1853   try {
1854     Scripting::load_level(arg0);
1855
1856     return 0;
1857
1858   } catch(std::exception& e) {
1859     sq_throwerror(vm, e.what());
1860     return SQ_ERROR;
1861   } catch(...) {
1862     sq_throwerror(vm, _SC("Unexpected exception while executing function 'load_level'"));
1863     return SQ_ERROR;
1864   }
1865
1866 }
1867
1868 static SQInteger wait_wrapper(HSQUIRRELVM vm)
1869 {
1870   HSQUIRRELVM arg0 = vm;
1871   SQFloat arg1;
1872   if(SQ_FAILED(sq_getfloat(vm, 2, &arg1))) {
1873     sq_throwerror(vm, _SC("Argument 1 not a float"));
1874     return SQ_ERROR;
1875   }
1876
1877   try {
1878     Scripting::wait(arg0, static_cast<float> (arg1));
1879
1880     return sq_suspendvm(vm);
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 'wait'"));
1887     return SQ_ERROR;
1888   }
1889
1890 }
1891
1892 static SQInteger wait_for_screenswitch_wrapper(HSQUIRRELVM vm)
1893 {
1894   HSQUIRRELVM arg0 = vm;
1895
1896   try {
1897     Scripting::wait_for_screenswitch(arg0);
1898
1899     return sq_suspendvm(vm);
1900
1901   } catch(std::exception& e) {
1902     sq_throwerror(vm, e.what());
1903     return SQ_ERROR;
1904   } catch(...) {
1905     sq_throwerror(vm, _SC("Unexpected exception while executing function 'wait_for_screenswitch'"));
1906     return SQ_ERROR;
1907   }
1908
1909 }
1910
1911 static SQInteger exit_screen_wrapper(HSQUIRRELVM vm)
1912 {
1913   (void) vm;
1914
1915   try {
1916     Scripting::exit_screen();
1917
1918     return 0;
1919
1920   } catch(std::exception& e) {
1921     sq_throwerror(vm, e.what());
1922     return SQ_ERROR;
1923   } catch(...) {
1924     sq_throwerror(vm, _SC("Unexpected exception while executing function 'exit_screen'"));
1925     return SQ_ERROR;
1926   }
1927
1928 }
1929
1930 static SQInteger fadeout_screen_wrapper(HSQUIRRELVM vm)
1931 {
1932   SQFloat arg0;
1933   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
1934     sq_throwerror(vm, _SC("Argument 1 not a float"));
1935     return SQ_ERROR;
1936   }
1937
1938   try {
1939     Scripting::fadeout_screen(static_cast<float> (arg0));
1940
1941     return 0;
1942
1943   } catch(std::exception& e) {
1944     sq_throwerror(vm, e.what());
1945     return SQ_ERROR;
1946   } catch(...) {
1947     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fadeout_screen'"));
1948     return SQ_ERROR;
1949   }
1950
1951 }
1952
1953 static SQInteger shrink_screen_wrapper(HSQUIRRELVM vm)
1954 {
1955   SQFloat arg0;
1956   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
1957     sq_throwerror(vm, _SC("Argument 1 not a float"));
1958     return SQ_ERROR;
1959   }
1960   SQFloat arg1;
1961   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
1962     sq_throwerror(vm, _SC("Argument 2 not a float"));
1963     return SQ_ERROR;
1964   }
1965   SQFloat arg2;
1966   if(SQ_FAILED(sq_getfloat(vm, 4, &arg2))) {
1967     sq_throwerror(vm, _SC("Argument 3 not a float"));
1968     return SQ_ERROR;
1969   }
1970
1971   try {
1972     Scripting::shrink_screen(static_cast<float> (arg0), static_cast<float> (arg1), static_cast<float> (arg2));
1973
1974     return 0;
1975
1976   } catch(std::exception& e) {
1977     sq_throwerror(vm, e.what());
1978     return SQ_ERROR;
1979   } catch(...) {
1980     sq_throwerror(vm, _SC("Unexpected exception while executing function 'shrink_screen'"));
1981     return SQ_ERROR;
1982   }
1983
1984 }
1985
1986 static SQInteger translate_wrapper(HSQUIRRELVM vm)
1987 {
1988   const SQChar* arg0;
1989   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1990     sq_throwerror(vm, _SC("Argument 1 not a string"));
1991     return SQ_ERROR;
1992   }
1993
1994   try {
1995     std::string return_value = Scripting::translate(arg0);
1996
1997     sq_pushstring(vm, return_value.c_str(), return_value.size());
1998     return 1;
1999
2000   } catch(std::exception& e) {
2001     sq_throwerror(vm, e.what());
2002     return SQ_ERROR;
2003   } catch(...) {
2004     sq_throwerror(vm, _SC("Unexpected exception while executing function 'translate'"));
2005     return SQ_ERROR;
2006   }
2007
2008 }
2009
2010 static SQInteger import_wrapper(HSQUIRRELVM vm)
2011 {
2012   HSQUIRRELVM arg0 = vm;
2013   const SQChar* arg1;
2014   if(SQ_FAILED(sq_getstring(vm, 2, &arg1))) {
2015     sq_throwerror(vm, _SC("Argument 1 not a string"));
2016     return SQ_ERROR;
2017   }
2018
2019   try {
2020     Scripting::import(arg0, arg1);
2021
2022     return 0;
2023
2024   } catch(std::exception& e) {
2025     sq_throwerror(vm, e.what());
2026     return SQ_ERROR;
2027   } catch(...) {
2028     sq_throwerror(vm, _SC("Unexpected exception while executing function 'import'"));
2029     return SQ_ERROR;
2030   }
2031
2032 }
2033
2034 static SQInteger save_state_wrapper(HSQUIRRELVM vm)
2035 {
2036   (void) vm;
2037
2038   try {
2039     Scripting::save_state();
2040
2041     return 0;
2042
2043   } catch(std::exception& e) {
2044     sq_throwerror(vm, e.what());
2045     return SQ_ERROR;
2046   } catch(...) {
2047     sq_throwerror(vm, _SC("Unexpected exception while executing function 'save_state'"));
2048     return SQ_ERROR;
2049   }
2050
2051 }
2052
2053 static SQInteger debug_collrects_wrapper(HSQUIRRELVM vm)
2054 {
2055   SQBool arg0;
2056   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
2057     sq_throwerror(vm, _SC("Argument 1 not a bool"));
2058     return SQ_ERROR;
2059   }
2060
2061   try {
2062     Scripting::debug_collrects(arg0 == SQTrue);
2063
2064     return 0;
2065
2066   } catch(std::exception& e) {
2067     sq_throwerror(vm, e.what());
2068     return SQ_ERROR;
2069   } catch(...) {
2070     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_collrects'"));
2071     return SQ_ERROR;
2072   }
2073
2074 }
2075
2076 static SQInteger debug_show_fps_wrapper(HSQUIRRELVM vm)
2077 {
2078   SQBool arg0;
2079   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
2080     sq_throwerror(vm, _SC("Argument 1 not a bool"));
2081     return SQ_ERROR;
2082   }
2083
2084   try {
2085     Scripting::debug_show_fps(arg0 == SQTrue);
2086
2087     return 0;
2088
2089   } catch(std::exception& e) {
2090     sq_throwerror(vm, e.what());
2091     return SQ_ERROR;
2092   } catch(...) {
2093     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_show_fps'"));
2094     return SQ_ERROR;
2095   }
2096
2097 }
2098
2099 static SQInteger debug_draw_solids_only_wrapper(HSQUIRRELVM vm)
2100 {
2101   SQBool arg0;
2102   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
2103     sq_throwerror(vm, _SC("Argument 1 not a bool"));
2104     return SQ_ERROR;
2105   }
2106
2107   try {
2108     Scripting::debug_draw_solids_only(arg0 == SQTrue);
2109
2110     return 0;
2111
2112   } catch(std::exception& e) {
2113     sq_throwerror(vm, e.what());
2114     return SQ_ERROR;
2115   } catch(...) {
2116     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_draw_solids_only'"));
2117     return SQ_ERROR;
2118   }
2119
2120 }
2121
2122 static SQInteger play_music_wrapper(HSQUIRRELVM vm)
2123 {
2124   const SQChar* arg0;
2125   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2126     sq_throwerror(vm, _SC("Argument 1 not a string"));
2127     return SQ_ERROR;
2128   }
2129
2130   try {
2131     Scripting::play_music(arg0);
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 'play_music'"));
2140     return SQ_ERROR;
2141   }
2142
2143 }
2144
2145 static SQInteger play_sound_wrapper(HSQUIRRELVM vm)
2146 {
2147   const SQChar* arg0;
2148   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2149     sq_throwerror(vm, _SC("Argument 1 not a string"));
2150     return SQ_ERROR;
2151   }
2152
2153   try {
2154     Scripting::play_sound(arg0);
2155
2156     return 0;
2157
2158   } catch(std::exception& e) {
2159     sq_throwerror(vm, e.what());
2160     return SQ_ERROR;
2161   } catch(...) {
2162     sq_throwerror(vm, _SC("Unexpected exception while executing function 'play_sound'"));
2163     return SQ_ERROR;
2164   }
2165
2166 }
2167
2168 static SQInteger grease_wrapper(HSQUIRRELVM vm)
2169 {
2170   (void) vm;
2171
2172   try {
2173     Scripting::grease();
2174
2175     return 0;
2176
2177   } catch(std::exception& e) {
2178     sq_throwerror(vm, e.what());
2179     return SQ_ERROR;
2180   } catch(...) {
2181     sq_throwerror(vm, _SC("Unexpected exception while executing function 'grease'"));
2182     return SQ_ERROR;
2183   }
2184
2185 }
2186
2187 static SQInteger invincible_wrapper(HSQUIRRELVM vm)
2188 {
2189   (void) vm;
2190
2191   try {
2192     Scripting::invincible();
2193
2194     return 0;
2195
2196   } catch(std::exception& e) {
2197     sq_throwerror(vm, e.what());
2198     return SQ_ERROR;
2199   } catch(...) {
2200     sq_throwerror(vm, _SC("Unexpected exception while executing function 'invincible'"));
2201     return SQ_ERROR;
2202   }
2203
2204 }
2205
2206 static SQInteger ghost_wrapper(HSQUIRRELVM vm)
2207 {
2208   (void) vm;
2209
2210   try {
2211     Scripting::ghost();
2212
2213     return 0;
2214
2215   } catch(std::exception& e) {
2216     sq_throwerror(vm, e.what());
2217     return SQ_ERROR;
2218   } catch(...) {
2219     sq_throwerror(vm, _SC("Unexpected exception while executing function 'ghost'"));
2220     return SQ_ERROR;
2221   }
2222
2223 }
2224
2225 static SQInteger mortal_wrapper(HSQUIRRELVM vm)
2226 {
2227   (void) vm;
2228
2229   try {
2230     Scripting::mortal();
2231
2232     return 0;
2233
2234   } catch(std::exception& e) {
2235     sq_throwerror(vm, e.what());
2236     return SQ_ERROR;
2237   } catch(...) {
2238     sq_throwerror(vm, _SC("Unexpected exception while executing function 'mortal'"));
2239     return SQ_ERROR;
2240   }
2241
2242 }
2243
2244 static SQInteger restart_wrapper(HSQUIRRELVM vm)
2245 {
2246   (void) vm;
2247
2248   try {
2249     Scripting::restart();
2250
2251     return 0;
2252
2253   } catch(std::exception& e) {
2254     sq_throwerror(vm, e.what());
2255     return SQ_ERROR;
2256   } catch(...) {
2257     sq_throwerror(vm, _SC("Unexpected exception while executing function 'restart'"));
2258     return SQ_ERROR;
2259   }
2260
2261 }
2262
2263 static SQInteger whereami_wrapper(HSQUIRRELVM vm)
2264 {
2265   (void) vm;
2266
2267   try {
2268     Scripting::whereami();
2269
2270     return 0;
2271
2272   } catch(std::exception& e) {
2273     sq_throwerror(vm, e.what());
2274     return SQ_ERROR;
2275   } catch(...) {
2276     sq_throwerror(vm, _SC("Unexpected exception while executing function 'whereami'"));
2277     return SQ_ERROR;
2278   }
2279
2280 }
2281
2282 static SQInteger gotoend_wrapper(HSQUIRRELVM vm)
2283 {
2284   (void) vm;
2285
2286   try {
2287     Scripting::gotoend();
2288
2289     return 0;
2290
2291   } catch(std::exception& e) {
2292     sq_throwerror(vm, e.what());
2293     return SQ_ERROR;
2294   } catch(...) {
2295     sq_throwerror(vm, _SC("Unexpected exception while executing function 'gotoend'"));
2296     return SQ_ERROR;
2297   }
2298
2299 }
2300
2301 static SQInteger camera_wrapper(HSQUIRRELVM vm)
2302 {
2303   (void) vm;
2304
2305   try {
2306     Scripting::camera();
2307
2308     return 0;
2309
2310   } catch(std::exception& e) {
2311     sq_throwerror(vm, e.what());
2312     return SQ_ERROR;
2313   } catch(...) {
2314     sq_throwerror(vm, _SC("Unexpected exception while executing function 'camera'"));
2315     return SQ_ERROR;
2316   }
2317
2318 }
2319
2320 static SQInteger quit_wrapper(HSQUIRRELVM vm)
2321 {
2322   (void) vm;
2323
2324   try {
2325     Scripting::quit();
2326
2327     return 0;
2328
2329   } catch(std::exception& e) {
2330     sq_throwerror(vm, e.what());
2331     return SQ_ERROR;
2332   } catch(...) {
2333     sq_throwerror(vm, _SC("Unexpected exception while executing function 'quit'"));
2334     return SQ_ERROR;
2335   }
2336
2337 }
2338
2339 static SQInteger rand_wrapper(HSQUIRRELVM vm)
2340 {
2341
2342   try {
2343     int return_value = Scripting::rand();
2344
2345     sq_pushinteger(vm, return_value);
2346     return 1;
2347
2348   } catch(std::exception& e) {
2349     sq_throwerror(vm, e.what());
2350     return SQ_ERROR;
2351   } catch(...) {
2352     sq_throwerror(vm, _SC("Unexpected exception while executing function 'rand'"));
2353     return SQ_ERROR;
2354   }
2355
2356 }
2357
2358 } // end of namespace Wrapper
2359
2360 void create_squirrel_instance(HSQUIRRELVM v, Scripting::DisplayEffect* object, bool setup_releasehook)
2361 {
2362   using namespace Wrapper;
2363
2364   sq_pushroottable(v);
2365   sq_pushstring(v, "DisplayEffect", -1);
2366   if(SQ_FAILED(sq_get(v, -2))) {
2367     std::ostringstream msg;
2368     msg << "Couldn't resolved squirrel type 'DisplayEffect'";
2369     throw SquirrelError(v, msg.str());
2370   }
2371
2372   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2373     std::ostringstream msg;
2374     msg << "Couldn't setup squirrel instance for object of type 'DisplayEffect'";
2375     throw SquirrelError(v, msg.str());
2376   }
2377   sq_remove(v, -2); // remove object name
2378
2379   if(setup_releasehook) {
2380     sq_setreleasehook(v, -1, DisplayEffect_release_hook);
2381   }
2382
2383   sq_remove(v, -2); // remove root table
2384 }
2385
2386 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Camera* object, bool setup_releasehook)
2387 {
2388   using namespace Wrapper;
2389
2390   sq_pushroottable(v);
2391   sq_pushstring(v, "Camera", -1);
2392   if(SQ_FAILED(sq_get(v, -2))) {
2393     std::ostringstream msg;
2394     msg << "Couldn't resolved squirrel type 'Camera'";
2395     throw SquirrelError(v, msg.str());
2396   }
2397
2398   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2399     std::ostringstream msg;
2400     msg << "Couldn't setup squirrel instance for object of type 'Camera'";
2401     throw SquirrelError(v, msg.str());
2402   }
2403   sq_remove(v, -2); // remove object name
2404
2405   if(setup_releasehook) {
2406     sq_setreleasehook(v, -1, Camera_release_hook);
2407   }
2408
2409   sq_remove(v, -2); // remove root table
2410 }
2411
2412 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Level* object, bool setup_releasehook)
2413 {
2414   using namespace Wrapper;
2415
2416   sq_pushroottable(v);
2417   sq_pushstring(v, "Level", -1);
2418   if(SQ_FAILED(sq_get(v, -2))) {
2419     std::ostringstream msg;
2420     msg << "Couldn't resolved squirrel type 'Level'";
2421     throw SquirrelError(v, msg.str());
2422   }
2423
2424   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2425     std::ostringstream msg;
2426     msg << "Couldn't setup squirrel instance for object of type 'Level'";
2427     throw SquirrelError(v, msg.str());
2428   }
2429   sq_remove(v, -2); // remove object name
2430
2431   if(setup_releasehook) {
2432     sq_setreleasehook(v, -1, Level_release_hook);
2433   }
2434
2435   sq_remove(v, -2); // remove root table
2436 }
2437
2438 void create_squirrel_instance(HSQUIRRELVM v, Scripting::ScriptedObject* object, bool setup_releasehook)
2439 {
2440   using namespace Wrapper;
2441
2442   sq_pushroottable(v);
2443   sq_pushstring(v, "ScriptedObject", -1);
2444   if(SQ_FAILED(sq_get(v, -2))) {
2445     std::ostringstream msg;
2446     msg << "Couldn't resolved squirrel type 'ScriptedObject'";
2447     throw SquirrelError(v, msg.str());
2448   }
2449
2450   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2451     std::ostringstream msg;
2452     msg << "Couldn't setup squirrel instance for object of type 'ScriptedObject'";
2453     throw SquirrelError(v, msg.str());
2454   }
2455   sq_remove(v, -2); // remove object name
2456
2457   if(setup_releasehook) {
2458     sq_setreleasehook(v, -1, ScriptedObject_release_hook);
2459   }
2460
2461   sq_remove(v, -2); // remove root table
2462 }
2463
2464 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Text* object, bool setup_releasehook)
2465 {
2466   using namespace Wrapper;
2467
2468   sq_pushroottable(v);
2469   sq_pushstring(v, "Text", -1);
2470   if(SQ_FAILED(sq_get(v, -2))) {
2471     std::ostringstream msg;
2472     msg << "Couldn't resolved squirrel type 'Text'";
2473     throw SquirrelError(v, msg.str());
2474   }
2475
2476   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2477     std::ostringstream msg;
2478     msg << "Couldn't setup squirrel instance for object of type 'Text'";
2479     throw SquirrelError(v, msg.str());
2480   }
2481   sq_remove(v, -2); // remove object name
2482
2483   if(setup_releasehook) {
2484     sq_setreleasehook(v, -1, Text_release_hook);
2485   }
2486
2487   sq_remove(v, -2); // remove root table
2488 }
2489
2490 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Player* object, bool setup_releasehook)
2491 {
2492   using namespace Wrapper;
2493
2494   sq_pushroottable(v);
2495   sq_pushstring(v, "Player", -1);
2496   if(SQ_FAILED(sq_get(v, -2))) {
2497     std::ostringstream msg;
2498     msg << "Couldn't resolved squirrel type 'Player'";
2499     throw SquirrelError(v, msg.str());
2500   }
2501
2502   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2503     std::ostringstream msg;
2504     msg << "Couldn't setup squirrel instance for object of type 'Player'";
2505     throw SquirrelError(v, msg.str());
2506   }
2507   sq_remove(v, -2); // remove object name
2508
2509   if(setup_releasehook) {
2510     sq_setreleasehook(v, -1, Player_release_hook);
2511   }
2512
2513   sq_remove(v, -2); // remove root table
2514 }
2515
2516 void create_squirrel_instance(HSQUIRRELVM v, Scripting::FloatingImage* object, bool setup_releasehook)
2517 {
2518   using namespace Wrapper;
2519
2520   sq_pushroottable(v);
2521   sq_pushstring(v, "FloatingImage", -1);
2522   if(SQ_FAILED(sq_get(v, -2))) {
2523     std::ostringstream msg;
2524     msg << "Couldn't resolved squirrel type 'FloatingImage'";
2525     throw SquirrelError(v, msg.str());
2526   }
2527
2528   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2529     std::ostringstream msg;
2530     msg << "Couldn't setup squirrel instance for object of type 'FloatingImage'";
2531     throw SquirrelError(v, msg.str());
2532   }
2533   sq_remove(v, -2); // remove object name
2534
2535   if(setup_releasehook) {
2536     sq_setreleasehook(v, -1, FloatingImage_release_hook);
2537   }
2538
2539   sq_remove(v, -2); // remove root table
2540 }
2541
2542 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Platform* object, bool setup_releasehook)
2543 {
2544   using namespace Wrapper;
2545
2546   sq_pushroottable(v);
2547   sq_pushstring(v, "Platform", -1);
2548   if(SQ_FAILED(sq_get(v, -2))) {
2549     std::ostringstream msg;
2550     msg << "Couldn't resolved squirrel type 'Platform'";
2551     throw SquirrelError(v, msg.str());
2552   }
2553
2554   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2555     std::ostringstream msg;
2556     msg << "Couldn't setup squirrel instance for object of type 'Platform'";
2557     throw SquirrelError(v, msg.str());
2558   }
2559   sq_remove(v, -2); // remove object name
2560
2561   if(setup_releasehook) {
2562     sq_setreleasehook(v, -1, Platform_release_hook);
2563   }
2564
2565   sq_remove(v, -2); // remove root table
2566 }
2567
2568 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Candle* object, bool setup_releasehook)
2569 {
2570   using namespace Wrapper;
2571
2572   sq_pushroottable(v);
2573   sq_pushstring(v, "Candle", -1);
2574   if(SQ_FAILED(sq_get(v, -2))) {
2575     std::ostringstream msg;
2576     msg << "Couldn't resolved squirrel type 'Candle'";
2577     throw SquirrelError(v, msg.str());
2578   }
2579
2580   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2581     std::ostringstream msg;
2582     msg << "Couldn't setup squirrel instance for object of type 'Candle'";
2583     throw SquirrelError(v, msg.str());
2584   }
2585   sq_remove(v, -2); // remove object name
2586
2587   if(setup_releasehook) {
2588     sq_setreleasehook(v, -1, Candle_release_hook);
2589   }
2590
2591   sq_remove(v, -2); // remove root table
2592 }
2593
2594 void register_supertux_wrapper(HSQUIRRELVM v)
2595 {
2596   using namespace Wrapper;
2597
2598   sq_pushstring(v, "ANCHOR_TOP", -1);
2599   sq_pushinteger(v, 16);
2600   if(SQ_FAILED(sq_createslot(v, -3))) {
2601     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP'");
2602   }
2603
2604   sq_pushstring(v, "ANCHOR_BOTTOM", -1);
2605   sq_pushinteger(v, 32);
2606   if(SQ_FAILED(sq_createslot(v, -3))) {
2607     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM'");
2608   }
2609
2610   sq_pushstring(v, "ANCHOR_LEFT", -1);
2611   sq_pushinteger(v, 1);
2612   if(SQ_FAILED(sq_createslot(v, -3))) {
2613     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_LEFT'");
2614   }
2615
2616   sq_pushstring(v, "ANCHOR_RIGHT", -1);
2617   sq_pushinteger(v, 2);
2618   if(SQ_FAILED(sq_createslot(v, -3))) {
2619     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_RIGHT'");
2620   }
2621
2622   sq_pushstring(v, "ANCHOR_MIDDLE", -1);
2623   sq_pushinteger(v, 0);
2624   if(SQ_FAILED(sq_createslot(v, -3))) {
2625     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_MIDDLE'");
2626   }
2627
2628   sq_pushstring(v, "ANCHOR_TOP_LEFT", -1);
2629   sq_pushinteger(v, 17);
2630   if(SQ_FAILED(sq_createslot(v, -3))) {
2631     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP_LEFT'");
2632   }
2633
2634   sq_pushstring(v, "ANCHOR_TOP_RIGHT", -1);
2635   sq_pushinteger(v, 18);
2636   if(SQ_FAILED(sq_createslot(v, -3))) {
2637     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP_RIGHT'");
2638   }
2639
2640   sq_pushstring(v, "ANCHOR_BOTTOM_LEFT", -1);
2641   sq_pushinteger(v, 33);
2642   if(SQ_FAILED(sq_createslot(v, -3))) {
2643     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM_LEFT'");
2644   }
2645
2646   sq_pushstring(v, "ANCHOR_BOTTOM_RIGHT", -1);
2647   sq_pushinteger(v, 34);
2648   if(SQ_FAILED(sq_createslot(v, -3))) {
2649     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM_RIGHT'");
2650   }
2651
2652   sq_pushstring(v, "display", -1);
2653   sq_newclosure(v, &display_wrapper, 0);
2654   if(SQ_FAILED(sq_createslot(v, -3))) {
2655     throw SquirrelError(v, "Couldn't register function 'display'");
2656   }
2657
2658   sq_pushstring(v, "print_stacktrace", -1);
2659   sq_newclosure(v, &print_stacktrace_wrapper, 0);
2660   if(SQ_FAILED(sq_createslot(v, -3))) {
2661     throw SquirrelError(v, "Couldn't register function 'print_stacktrace'");
2662   }
2663
2664   sq_pushstring(v, "get_current_thread", -1);
2665   sq_newclosure(v, &get_current_thread_wrapper, 0);
2666   if(SQ_FAILED(sq_createslot(v, -3))) {
2667     throw SquirrelError(v, "Couldn't register function 'get_current_thread'");
2668   }
2669
2670   sq_pushstring(v, "display_text_file", -1);
2671   sq_newclosure(v, &display_text_file_wrapper, 0);
2672   if(SQ_FAILED(sq_createslot(v, -3))) {
2673     throw SquirrelError(v, "Couldn't register function 'display_text_file'");
2674   }
2675
2676   sq_pushstring(v, "load_worldmap", -1);
2677   sq_newclosure(v, &load_worldmap_wrapper, 0);
2678   if(SQ_FAILED(sq_createslot(v, -3))) {
2679     throw SquirrelError(v, "Couldn't register function 'load_worldmap'");
2680   }
2681
2682   sq_pushstring(v, "load_level", -1);
2683   sq_newclosure(v, &load_level_wrapper, 0);
2684   if(SQ_FAILED(sq_createslot(v, -3))) {
2685     throw SquirrelError(v, "Couldn't register function 'load_level'");
2686   }
2687
2688   sq_pushstring(v, "wait", -1);
2689   sq_newclosure(v, &wait_wrapper, 0);
2690   if(SQ_FAILED(sq_createslot(v, -3))) {
2691     throw SquirrelError(v, "Couldn't register function 'wait'");
2692   }
2693
2694   sq_pushstring(v, "wait_for_screenswitch", -1);
2695   sq_newclosure(v, &wait_for_screenswitch_wrapper, 0);
2696   if(SQ_FAILED(sq_createslot(v, -3))) {
2697     throw SquirrelError(v, "Couldn't register function 'wait_for_screenswitch'");
2698   }
2699
2700   sq_pushstring(v, "exit_screen", -1);
2701   sq_newclosure(v, &exit_screen_wrapper, 0);
2702   if(SQ_FAILED(sq_createslot(v, -3))) {
2703     throw SquirrelError(v, "Couldn't register function 'exit_screen'");
2704   }
2705
2706   sq_pushstring(v, "fadeout_screen", -1);
2707   sq_newclosure(v, &fadeout_screen_wrapper, 0);
2708   if(SQ_FAILED(sq_createslot(v, -3))) {
2709     throw SquirrelError(v, "Couldn't register function 'fadeout_screen'");
2710   }
2711
2712   sq_pushstring(v, "shrink_screen", -1);
2713   sq_newclosure(v, &shrink_screen_wrapper, 0);
2714   if(SQ_FAILED(sq_createslot(v, -3))) {
2715     throw SquirrelError(v, "Couldn't register function 'shrink_screen'");
2716   }
2717
2718   sq_pushstring(v, "translate", -1);
2719   sq_newclosure(v, &translate_wrapper, 0);
2720   if(SQ_FAILED(sq_createslot(v, -3))) {
2721     throw SquirrelError(v, "Couldn't register function 'translate'");
2722   }
2723
2724   sq_pushstring(v, "import", -1);
2725   sq_newclosure(v, &import_wrapper, 0);
2726   if(SQ_FAILED(sq_createslot(v, -3))) {
2727     throw SquirrelError(v, "Couldn't register function 'import'");
2728   }
2729
2730   sq_pushstring(v, "save_state", -1);
2731   sq_newclosure(v, &save_state_wrapper, 0);
2732   if(SQ_FAILED(sq_createslot(v, -3))) {
2733     throw SquirrelError(v, "Couldn't register function 'save_state'");
2734   }
2735
2736   sq_pushstring(v, "debug_collrects", -1);
2737   sq_newclosure(v, &debug_collrects_wrapper, 0);
2738   if(SQ_FAILED(sq_createslot(v, -3))) {
2739     throw SquirrelError(v, "Couldn't register function 'debug_collrects'");
2740   }
2741
2742   sq_pushstring(v, "debug_show_fps", -1);
2743   sq_newclosure(v, &debug_show_fps_wrapper, 0);
2744   if(SQ_FAILED(sq_createslot(v, -3))) {
2745     throw SquirrelError(v, "Couldn't register function 'debug_show_fps'");
2746   }
2747
2748   sq_pushstring(v, "debug_draw_solids_only", -1);
2749   sq_newclosure(v, &debug_draw_solids_only_wrapper, 0);
2750   if(SQ_FAILED(sq_createslot(v, -3))) {
2751     throw SquirrelError(v, "Couldn't register function 'debug_draw_solids_only'");
2752   }
2753
2754   sq_pushstring(v, "play_music", -1);
2755   sq_newclosure(v, &play_music_wrapper, 0);
2756   if(SQ_FAILED(sq_createslot(v, -3))) {
2757     throw SquirrelError(v, "Couldn't register function 'play_music'");
2758   }
2759
2760   sq_pushstring(v, "play_sound", -1);
2761   sq_newclosure(v, &play_sound_wrapper, 0);
2762   if(SQ_FAILED(sq_createslot(v, -3))) {
2763     throw SquirrelError(v, "Couldn't register function 'play_sound'");
2764   }
2765
2766   sq_pushstring(v, "grease", -1);
2767   sq_newclosure(v, &grease_wrapper, 0);
2768   if(SQ_FAILED(sq_createslot(v, -3))) {
2769     throw SquirrelError(v, "Couldn't register function 'grease'");
2770   }
2771
2772   sq_pushstring(v, "invincible", -1);
2773   sq_newclosure(v, &invincible_wrapper, 0);
2774   if(SQ_FAILED(sq_createslot(v, -3))) {
2775     throw SquirrelError(v, "Couldn't register function 'invincible'");
2776   }
2777
2778   sq_pushstring(v, "ghost", -1);
2779   sq_newclosure(v, &ghost_wrapper, 0);
2780   if(SQ_FAILED(sq_createslot(v, -3))) {
2781     throw SquirrelError(v, "Couldn't register function 'ghost'");
2782   }
2783
2784   sq_pushstring(v, "mortal", -1);
2785   sq_newclosure(v, &mortal_wrapper, 0);
2786   if(SQ_FAILED(sq_createslot(v, -3))) {
2787     throw SquirrelError(v, "Couldn't register function 'mortal'");
2788   }
2789
2790   sq_pushstring(v, "restart", -1);
2791   sq_newclosure(v, &restart_wrapper, 0);
2792   if(SQ_FAILED(sq_createslot(v, -3))) {
2793     throw SquirrelError(v, "Couldn't register function 'restart'");
2794   }
2795
2796   sq_pushstring(v, "whereami", -1);
2797   sq_newclosure(v, &whereami_wrapper, 0);
2798   if(SQ_FAILED(sq_createslot(v, -3))) {
2799     throw SquirrelError(v, "Couldn't register function 'whereami'");
2800   }
2801
2802   sq_pushstring(v, "gotoend", -1);
2803   sq_newclosure(v, &gotoend_wrapper, 0);
2804   if(SQ_FAILED(sq_createslot(v, -3))) {
2805     throw SquirrelError(v, "Couldn't register function 'gotoend'");
2806   }
2807
2808   sq_pushstring(v, "camera", -1);
2809   sq_newclosure(v, &camera_wrapper, 0);
2810   if(SQ_FAILED(sq_createslot(v, -3))) {
2811     throw SquirrelError(v, "Couldn't register function 'camera'");
2812   }
2813
2814   sq_pushstring(v, "quit", -1);
2815   sq_newclosure(v, &quit_wrapper, 0);
2816   if(SQ_FAILED(sq_createslot(v, -3))) {
2817     throw SquirrelError(v, "Couldn't register function 'quit'");
2818   }
2819
2820   sq_pushstring(v, "rand", -1);
2821   sq_newclosure(v, &rand_wrapper, 0);
2822   if(SQ_FAILED(sq_createslot(v, -3))) {
2823     throw SquirrelError(v, "Couldn't register function 'rand'");
2824   }
2825
2826   // Register class DisplayEffect
2827   sq_pushstring(v, "DisplayEffect", -1);
2828   if(sq_newclass(v, SQFalse) < 0) {
2829     std::ostringstream msg;
2830     msg << "Couldn't create new class 'DisplayEffect'";
2831     throw SquirrelError(v, msg.str());
2832   }
2833   sq_pushstring(v, "fade_out", -1);
2834   sq_newclosure(v, &DisplayEffect_fade_out_wrapper, 0);
2835   if(SQ_FAILED(sq_createslot(v, -3))) {
2836     throw SquirrelError(v, "Couldn't register function 'fade_out'");
2837   }
2838
2839   sq_pushstring(v, "fade_in", -1);
2840   sq_newclosure(v, &DisplayEffect_fade_in_wrapper, 0);
2841   if(SQ_FAILED(sq_createslot(v, -3))) {
2842     throw SquirrelError(v, "Couldn't register function 'fade_in'");
2843   }
2844
2845   sq_pushstring(v, "set_black", -1);
2846   sq_newclosure(v, &DisplayEffect_set_black_wrapper, 0);
2847   if(SQ_FAILED(sq_createslot(v, -3))) {
2848     throw SquirrelError(v, "Couldn't register function 'set_black'");
2849   }
2850
2851   sq_pushstring(v, "is_black", -1);
2852   sq_newclosure(v, &DisplayEffect_is_black_wrapper, 0);
2853   if(SQ_FAILED(sq_createslot(v, -3))) {
2854     throw SquirrelError(v, "Couldn't register function 'is_black'");
2855   }
2856
2857   sq_pushstring(v, "sixteen_to_nine", -1);
2858   sq_newclosure(v, &DisplayEffect_sixteen_to_nine_wrapper, 0);
2859   if(SQ_FAILED(sq_createslot(v, -3))) {
2860     throw SquirrelError(v, "Couldn't register function 'sixteen_to_nine'");
2861   }
2862
2863   sq_pushstring(v, "four_to_three", -1);
2864   sq_newclosure(v, &DisplayEffect_four_to_three_wrapper, 0);
2865   if(SQ_FAILED(sq_createslot(v, -3))) {
2866     throw SquirrelError(v, "Couldn't register function 'four_to_three'");
2867   }
2868
2869   if(SQ_FAILED(sq_createslot(v, -3))) {
2870     throw SquirrelError(v, "Couldn't register class 'DisplayEffect'");
2871   }
2872
2873   // Register class Camera
2874   sq_pushstring(v, "Camera", -1);
2875   if(sq_newclass(v, SQFalse) < 0) {
2876     std::ostringstream msg;
2877     msg << "Couldn't create new class 'Camera'";
2878     throw SquirrelError(v, msg.str());
2879   }
2880   sq_pushstring(v, "shake", -1);
2881   sq_newclosure(v, &Camera_shake_wrapper, 0);
2882   if(SQ_FAILED(sq_createslot(v, -3))) {
2883     throw SquirrelError(v, "Couldn't register function 'shake'");
2884   }
2885
2886   sq_pushstring(v, "set_pos", -1);
2887   sq_newclosure(v, &Camera_set_pos_wrapper, 0);
2888   if(SQ_FAILED(sq_createslot(v, -3))) {
2889     throw SquirrelError(v, "Couldn't register function 'set_pos'");
2890   }
2891
2892   sq_pushstring(v, "set_mode", -1);
2893   sq_newclosure(v, &Camera_set_mode_wrapper, 0);
2894   if(SQ_FAILED(sq_createslot(v, -3))) {
2895     throw SquirrelError(v, "Couldn't register function 'set_mode'");
2896   }
2897
2898   sq_pushstring(v, "scroll_to", -1);
2899   sq_newclosure(v, &Camera_scroll_to_wrapper, 0);
2900   if(SQ_FAILED(sq_createslot(v, -3))) {
2901     throw SquirrelError(v, "Couldn't register function 'scroll_to'");
2902   }
2903
2904   if(SQ_FAILED(sq_createslot(v, -3))) {
2905     throw SquirrelError(v, "Couldn't register class 'Camera'");
2906   }
2907
2908   // Register class Level
2909   sq_pushstring(v, "Level", -1);
2910   if(sq_newclass(v, SQFalse) < 0) {
2911     std::ostringstream msg;
2912     msg << "Couldn't create new class 'Level'";
2913     throw SquirrelError(v, msg.str());
2914   }
2915   sq_pushstring(v, "finish", -1);
2916   sq_newclosure(v, &Level_finish_wrapper, 0);
2917   if(SQ_FAILED(sq_createslot(v, -3))) {
2918     throw SquirrelError(v, "Couldn't register function 'finish'");
2919   }
2920
2921   sq_pushstring(v, "spawn", -1);
2922   sq_newclosure(v, &Level_spawn_wrapper, 0);
2923   if(SQ_FAILED(sq_createslot(v, -3))) {
2924     throw SquirrelError(v, "Couldn't register function 'spawn'");
2925   }
2926
2927   sq_pushstring(v, "flip_vertically", -1);
2928   sq_newclosure(v, &Level_flip_vertically_wrapper, 0);
2929   if(SQ_FAILED(sq_createslot(v, -3))) {
2930     throw SquirrelError(v, "Couldn't register function 'flip_vertically'");
2931   }
2932
2933   sq_pushstring(v, "toggle_pause", -1);
2934   sq_newclosure(v, &Level_toggle_pause_wrapper, 0);
2935   if(SQ_FAILED(sq_createslot(v, -3))) {
2936     throw SquirrelError(v, "Couldn't register function 'toggle_pause'");
2937   }
2938
2939   if(SQ_FAILED(sq_createslot(v, -3))) {
2940     throw SquirrelError(v, "Couldn't register class 'Level'");
2941   }
2942
2943   // Register class ScriptedObject
2944   sq_pushstring(v, "ScriptedObject", -1);
2945   if(sq_newclass(v, SQFalse) < 0) {
2946     std::ostringstream msg;
2947     msg << "Couldn't create new class 'ScriptedObject'";
2948     throw SquirrelError(v, msg.str());
2949   }
2950   sq_pushstring(v, "set_action", -1);
2951   sq_newclosure(v, &ScriptedObject_set_action_wrapper, 0);
2952   if(SQ_FAILED(sq_createslot(v, -3))) {
2953     throw SquirrelError(v, "Couldn't register function 'set_action'");
2954   }
2955
2956   sq_pushstring(v, "get_action", -1);
2957   sq_newclosure(v, &ScriptedObject_get_action_wrapper, 0);
2958   if(SQ_FAILED(sq_createslot(v, -3))) {
2959     throw SquirrelError(v, "Couldn't register function 'get_action'");
2960   }
2961
2962   sq_pushstring(v, "move", -1);
2963   sq_newclosure(v, &ScriptedObject_move_wrapper, 0);
2964   if(SQ_FAILED(sq_createslot(v, -3))) {
2965     throw SquirrelError(v, "Couldn't register function 'move'");
2966   }
2967
2968   sq_pushstring(v, "set_pos", -1);
2969   sq_newclosure(v, &ScriptedObject_set_pos_wrapper, 0);
2970   if(SQ_FAILED(sq_createslot(v, -3))) {
2971     throw SquirrelError(v, "Couldn't register function 'set_pos'");
2972   }
2973
2974   sq_pushstring(v, "get_pos_x", -1);
2975   sq_newclosure(v, &ScriptedObject_get_pos_x_wrapper, 0);
2976   if(SQ_FAILED(sq_createslot(v, -3))) {
2977     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
2978   }
2979
2980   sq_pushstring(v, "get_pos_y", -1);
2981   sq_newclosure(v, &ScriptedObject_get_pos_y_wrapper, 0);
2982   if(SQ_FAILED(sq_createslot(v, -3))) {
2983     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
2984   }
2985
2986   sq_pushstring(v, "set_velocity", -1);
2987   sq_newclosure(v, &ScriptedObject_set_velocity_wrapper, 0);
2988   if(SQ_FAILED(sq_createslot(v, -3))) {
2989     throw SquirrelError(v, "Couldn't register function 'set_velocity'");
2990   }
2991
2992   sq_pushstring(v, "get_velocity_x", -1);
2993   sq_newclosure(v, &ScriptedObject_get_velocity_x_wrapper, 0);
2994   if(SQ_FAILED(sq_createslot(v, -3))) {
2995     throw SquirrelError(v, "Couldn't register function 'get_velocity_x'");
2996   }
2997
2998   sq_pushstring(v, "get_velocity_y", -1);
2999   sq_newclosure(v, &ScriptedObject_get_velocity_y_wrapper, 0);
3000   if(SQ_FAILED(sq_createslot(v, -3))) {
3001     throw SquirrelError(v, "Couldn't register function 'get_velocity_y'");
3002   }
3003
3004   sq_pushstring(v, "set_visible", -1);
3005   sq_newclosure(v, &ScriptedObject_set_visible_wrapper, 0);
3006   if(SQ_FAILED(sq_createslot(v, -3))) {
3007     throw SquirrelError(v, "Couldn't register function 'set_visible'");
3008   }
3009
3010   sq_pushstring(v, "is_visible", -1);
3011   sq_newclosure(v, &ScriptedObject_is_visible_wrapper, 0);
3012   if(SQ_FAILED(sq_createslot(v, -3))) {
3013     throw SquirrelError(v, "Couldn't register function 'is_visible'");
3014   }
3015
3016   sq_pushstring(v, "get_name", -1);
3017   sq_newclosure(v, &ScriptedObject_get_name_wrapper, 0);
3018   if(SQ_FAILED(sq_createslot(v, -3))) {
3019     throw SquirrelError(v, "Couldn't register function 'get_name'");
3020   }
3021
3022   if(SQ_FAILED(sq_createslot(v, -3))) {
3023     throw SquirrelError(v, "Couldn't register class 'ScriptedObject'");
3024   }
3025
3026   // Register class Text
3027   sq_pushstring(v, "Text", -1);
3028   if(sq_newclass(v, SQFalse) < 0) {
3029     std::ostringstream msg;
3030     msg << "Couldn't create new class 'Text'";
3031     throw SquirrelError(v, msg.str());
3032   }
3033   sq_pushstring(v, "set_text", -1);
3034   sq_newclosure(v, &Text_set_text_wrapper, 0);
3035   if(SQ_FAILED(sq_createslot(v, -3))) {
3036     throw SquirrelError(v, "Couldn't register function 'set_text'");
3037   }
3038
3039   sq_pushstring(v, "set_font", -1);
3040   sq_newclosure(v, &Text_set_font_wrapper, 0);
3041   if(SQ_FAILED(sq_createslot(v, -3))) {
3042     throw SquirrelError(v, "Couldn't register function 'set_font'");
3043   }
3044
3045   sq_pushstring(v, "fade_in", -1);
3046   sq_newclosure(v, &Text_fade_in_wrapper, 0);
3047   if(SQ_FAILED(sq_createslot(v, -3))) {
3048     throw SquirrelError(v, "Couldn't register function 'fade_in'");
3049   }
3050
3051   sq_pushstring(v, "fade_out", -1);
3052   sq_newclosure(v, &Text_fade_out_wrapper, 0);
3053   if(SQ_FAILED(sq_createslot(v, -3))) {
3054     throw SquirrelError(v, "Couldn't register function 'fade_out'");
3055   }
3056
3057   sq_pushstring(v, "set_visible", -1);
3058   sq_newclosure(v, &Text_set_visible_wrapper, 0);
3059   if(SQ_FAILED(sq_createslot(v, -3))) {
3060     throw SquirrelError(v, "Couldn't register function 'set_visible'");
3061   }
3062
3063   sq_pushstring(v, "set_centered", -1);
3064   sq_newclosure(v, &Text_set_centered_wrapper, 0);
3065   if(SQ_FAILED(sq_createslot(v, -3))) {
3066     throw SquirrelError(v, "Couldn't register function 'set_centered'");
3067   }
3068
3069   if(SQ_FAILED(sq_createslot(v, -3))) {
3070     throw SquirrelError(v, "Couldn't register class 'Text'");
3071   }
3072
3073   // Register class Player
3074   sq_pushstring(v, "Player", -1);
3075   if(sq_newclass(v, SQFalse) < 0) {
3076     std::ostringstream msg;
3077     msg << "Couldn't create new class 'Player'";
3078     throw SquirrelError(v, msg.str());
3079   }
3080   sq_pushstring(v, "add_bonus", -1);
3081   sq_newclosure(v, &Player_add_bonus_wrapper, 0);
3082   if(SQ_FAILED(sq_createslot(v, -3))) {
3083     throw SquirrelError(v, "Couldn't register function 'add_bonus'");
3084   }
3085
3086   sq_pushstring(v, "add_coins", -1);
3087   sq_newclosure(v, &Player_add_coins_wrapper, 0);
3088   if(SQ_FAILED(sq_createslot(v, -3))) {
3089     throw SquirrelError(v, "Couldn't register function 'add_coins'");
3090   }
3091
3092   sq_pushstring(v, "make_invincible", -1);
3093   sq_newclosure(v, &Player_make_invincible_wrapper, 0);
3094   if(SQ_FAILED(sq_createslot(v, -3))) {
3095     throw SquirrelError(v, "Couldn't register function 'make_invincible'");
3096   }
3097
3098   sq_pushstring(v, "deactivate", -1);
3099   sq_newclosure(v, &Player_deactivate_wrapper, 0);
3100   if(SQ_FAILED(sq_createslot(v, -3))) {
3101     throw SquirrelError(v, "Couldn't register function 'deactivate'");
3102   }
3103
3104   sq_pushstring(v, "activate", -1);
3105   sq_newclosure(v, &Player_activate_wrapper, 0);
3106   if(SQ_FAILED(sq_createslot(v, -3))) {
3107     throw SquirrelError(v, "Couldn't register function 'activate'");
3108   }
3109
3110   sq_pushstring(v, "walk", -1);
3111   sq_newclosure(v, &Player_walk_wrapper, 0);
3112   if(SQ_FAILED(sq_createslot(v, -3))) {
3113     throw SquirrelError(v, "Couldn't register function 'walk'");
3114   }
3115
3116   sq_pushstring(v, "set_visible", -1);
3117   sq_newclosure(v, &Player_set_visible_wrapper, 0);
3118   if(SQ_FAILED(sq_createslot(v, -3))) {
3119     throw SquirrelError(v, "Couldn't register function 'set_visible'");
3120   }
3121
3122   sq_pushstring(v, "get_visible", -1);
3123   sq_newclosure(v, &Player_get_visible_wrapper, 0);
3124   if(SQ_FAILED(sq_createslot(v, -3))) {
3125     throw SquirrelError(v, "Couldn't register function 'get_visible'");
3126   }
3127
3128   sq_pushstring(v, "kill", -1);
3129   sq_newclosure(v, &Player_kill_wrapper, 0);
3130   if(SQ_FAILED(sq_createslot(v, -3))) {
3131     throw SquirrelError(v, "Couldn't register function 'kill'");
3132   }
3133
3134   sq_pushstring(v, "set_ghost_mode", -1);
3135   sq_newclosure(v, &Player_set_ghost_mode_wrapper, 0);
3136   if(SQ_FAILED(sq_createslot(v, -3))) {
3137     throw SquirrelError(v, "Couldn't register function 'set_ghost_mode'");
3138   }
3139
3140   sq_pushstring(v, "get_ghost_mode", -1);
3141   sq_newclosure(v, &Player_get_ghost_mode_wrapper, 0);
3142   if(SQ_FAILED(sq_createslot(v, -3))) {
3143     throw SquirrelError(v, "Couldn't register function 'get_ghost_mode'");
3144   }
3145
3146   if(SQ_FAILED(sq_createslot(v, -3))) {
3147     throw SquirrelError(v, "Couldn't register class 'Player'");
3148   }
3149
3150   // Register class FloatingImage
3151   sq_pushstring(v, "FloatingImage", -1);
3152   if(sq_newclass(v, SQFalse) < 0) {
3153     std::ostringstream msg;
3154     msg << "Couldn't create new class 'FloatingImage'";
3155     throw SquirrelError(v, msg.str());
3156   }
3157   sq_pushstring(v, "constructor", -1);
3158   sq_newclosure(v, &FloatingImage_constructor_wrapper, 0);
3159   if(SQ_FAILED(sq_createslot(v, -3))) {
3160     throw SquirrelError(v, "Couldn't register function 'constructor'");
3161   }
3162
3163   sq_pushstring(v, "set_layer", -1);
3164   sq_newclosure(v, &FloatingImage_set_layer_wrapper, 0);
3165   if(SQ_FAILED(sq_createslot(v, -3))) {
3166     throw SquirrelError(v, "Couldn't register function 'set_layer'");
3167   }
3168
3169   sq_pushstring(v, "get_layer", -1);
3170   sq_newclosure(v, &FloatingImage_get_layer_wrapper, 0);
3171   if(SQ_FAILED(sq_createslot(v, -3))) {
3172     throw SquirrelError(v, "Couldn't register function 'get_layer'");
3173   }
3174
3175   sq_pushstring(v, "set_pos", -1);
3176   sq_newclosure(v, &FloatingImage_set_pos_wrapper, 0);
3177   if(SQ_FAILED(sq_createslot(v, -3))) {
3178     throw SquirrelError(v, "Couldn't register function 'set_pos'");
3179   }
3180
3181   sq_pushstring(v, "get_pos_x", -1);
3182   sq_newclosure(v, &FloatingImage_get_pos_x_wrapper, 0);
3183   if(SQ_FAILED(sq_createslot(v, -3))) {
3184     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
3185   }
3186
3187   sq_pushstring(v, "get_pos_y", -1);
3188   sq_newclosure(v, &FloatingImage_get_pos_y_wrapper, 0);
3189   if(SQ_FAILED(sq_createslot(v, -3))) {
3190     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
3191   }
3192
3193   sq_pushstring(v, "set_anchor_point", -1);
3194   sq_newclosure(v, &FloatingImage_set_anchor_point_wrapper, 0);
3195   if(SQ_FAILED(sq_createslot(v, -3))) {
3196     throw SquirrelError(v, "Couldn't register function 'set_anchor_point'");
3197   }
3198
3199   sq_pushstring(v, "get_anchor_point", -1);
3200   sq_newclosure(v, &FloatingImage_get_anchor_point_wrapper, 0);
3201   if(SQ_FAILED(sq_createslot(v, -3))) {
3202     throw SquirrelError(v, "Couldn't register function 'get_anchor_point'");
3203   }
3204
3205   sq_pushstring(v, "set_visible", -1);
3206   sq_newclosure(v, &FloatingImage_set_visible_wrapper, 0);
3207   if(SQ_FAILED(sq_createslot(v, -3))) {
3208     throw SquirrelError(v, "Couldn't register function 'set_visible'");
3209   }
3210
3211   sq_pushstring(v, "get_visible", -1);
3212   sq_newclosure(v, &FloatingImage_get_visible_wrapper, 0);
3213   if(SQ_FAILED(sq_createslot(v, -3))) {
3214     throw SquirrelError(v, "Couldn't register function 'get_visible'");
3215   }
3216
3217   sq_pushstring(v, "set_action", -1);
3218   sq_newclosure(v, &FloatingImage_set_action_wrapper, 0);
3219   if(SQ_FAILED(sq_createslot(v, -3))) {
3220     throw SquirrelError(v, "Couldn't register function 'set_action'");
3221   }
3222
3223   sq_pushstring(v, "get_action", -1);
3224   sq_newclosure(v, &FloatingImage_get_action_wrapper, 0);
3225   if(SQ_FAILED(sq_createslot(v, -3))) {
3226     throw SquirrelError(v, "Couldn't register function 'get_action'");
3227   }
3228
3229   if(SQ_FAILED(sq_createslot(v, -3))) {
3230     throw SquirrelError(v, "Couldn't register class 'FloatingImage'");
3231   }
3232
3233   // Register class Platform
3234   sq_pushstring(v, "Platform", -1);
3235   if(sq_newclass(v, SQFalse) < 0) {
3236     std::ostringstream msg;
3237     msg << "Couldn't create new class 'Platform'";
3238     throw SquirrelError(v, msg.str());
3239   }
3240   sq_pushstring(v, "goto_node", -1);
3241   sq_newclosure(v, &Platform_goto_node_wrapper, 0);
3242   if(SQ_FAILED(sq_createslot(v, -3))) {
3243     throw SquirrelError(v, "Couldn't register function 'goto_node'");
3244   }
3245
3246   sq_pushstring(v, "start_moving", -1);
3247   sq_newclosure(v, &Platform_start_moving_wrapper, 0);
3248   if(SQ_FAILED(sq_createslot(v, -3))) {
3249     throw SquirrelError(v, "Couldn't register function 'start_moving'");
3250   }
3251
3252   sq_pushstring(v, "stop_moving", -1);
3253   sq_newclosure(v, &Platform_stop_moving_wrapper, 0);
3254   if(SQ_FAILED(sq_createslot(v, -3))) {
3255     throw SquirrelError(v, "Couldn't register function 'stop_moving'");
3256   }
3257
3258   if(SQ_FAILED(sq_createslot(v, -3))) {
3259     throw SquirrelError(v, "Couldn't register class 'Platform'");
3260   }
3261
3262   // Register class Candle
3263   sq_pushstring(v, "Candle", -1);
3264   if(sq_newclass(v, SQFalse) < 0) {
3265     std::ostringstream msg;
3266     msg << "Couldn't create new class 'Candle'";
3267     throw SquirrelError(v, msg.str());
3268   }
3269   sq_pushstring(v, "get_burning", -1);
3270   sq_newclosure(v, &Candle_get_burning_wrapper, 0);
3271   if(SQ_FAILED(sq_createslot(v, -3))) {
3272     throw SquirrelError(v, "Couldn't register function 'get_burning'");
3273   }
3274
3275   sq_pushstring(v, "set_burning", -1);
3276   sq_newclosure(v, &Candle_set_burning_wrapper, 0);
3277   if(SQ_FAILED(sq_createslot(v, -3))) {
3278     throw SquirrelError(v, "Couldn't register function 'set_burning'");
3279   }
3280
3281   if(SQ_FAILED(sq_createslot(v, -3))) {
3282     throw SquirrelError(v, "Couldn't register class 'Candle'");
3283   }
3284
3285 }
3286
3287 } // end of namespace Scripting
3288