src/scripting/wrapper.cpp

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