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 FloatingImage_release_hook(SQUserPointer ptr, SQInteger )
1345 {
1346   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (ptr);
1347   delete _this;
1348   return 0;
1349 }
1350
1351 static SQInteger FloatingImage_constructor_wrapper(HSQUIRRELVM vm)
1352 {
1353   const SQChar* arg0;
1354   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1355     sq_throwerror(vm, _SC("Argument 1 not a string"));
1356     return SQ_ERROR;
1357   }
1358
1359   try {
1360     Scripting::FloatingImage* _this = new Scripting::FloatingImage(arg0);
1361   if(SQ_FAILED(sq_setinstanceup(vm, 1, _this))) {
1362     sq_throwerror(vm, _SC("Couldn't setup instance of 'FloatingImage' class"));
1363     return SQ_ERROR;
1364   }
1365   sq_setreleasehook(vm, 1, FloatingImage_release_hook);
1366
1367     return 0;
1368
1369   } catch(std::exception& e) {
1370     sq_throwerror(vm, e.what());
1371     return SQ_ERROR;
1372   } catch(...) {
1373     sq_throwerror(vm, _SC("Unexpected exception while executing function 'constructor'"));
1374     return SQ_ERROR;
1375   }
1376
1377 }
1378
1379 static SQInteger FloatingImage_set_layer_wrapper(HSQUIRRELVM vm)
1380 {
1381   SQUserPointer data;
1382   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1383     sq_throwerror(vm, _SC("'set_layer' called without instance"));
1384     return SQ_ERROR;
1385   }
1386   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1387   SQInteger arg0;
1388   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
1389     sq_throwerror(vm, _SC("Argument 1 not an integer"));
1390     return SQ_ERROR;
1391   }
1392
1393   try {
1394     _this->set_layer(static_cast<int> (arg0));
1395
1396     return 0;
1397
1398   } catch(std::exception& e) {
1399     sq_throwerror(vm, e.what());
1400     return SQ_ERROR;
1401   } catch(...) {
1402     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_layer'"));
1403     return SQ_ERROR;
1404   }
1405
1406 }
1407
1408 static SQInteger FloatingImage_get_layer_wrapper(HSQUIRRELVM vm)
1409 {
1410   SQUserPointer data;
1411   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1412     sq_throwerror(vm, _SC("'get_layer' called without instance"));
1413     return SQ_ERROR;
1414   }
1415   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1416
1417   try {
1418     int return_value = _this->get_layer();
1419
1420     sq_pushinteger(vm, return_value);
1421     return 1;
1422
1423   } catch(std::exception& e) {
1424     sq_throwerror(vm, e.what());
1425     return SQ_ERROR;
1426   } catch(...) {
1427     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_layer'"));
1428     return SQ_ERROR;
1429   }
1430
1431 }
1432
1433 static SQInteger FloatingImage_set_pos_wrapper(HSQUIRRELVM vm)
1434 {
1435   SQUserPointer data;
1436   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1437     sq_throwerror(vm, _SC("'set_pos' called without instance"));
1438     return SQ_ERROR;
1439   }
1440   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1441   SQFloat arg0;
1442   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
1443     sq_throwerror(vm, _SC("Argument 1 not a float"));
1444     return SQ_ERROR;
1445   }
1446   SQFloat arg1;
1447   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
1448     sq_throwerror(vm, _SC("Argument 2 not a float"));
1449     return SQ_ERROR;
1450   }
1451
1452   try {
1453     _this->set_pos(static_cast<float> (arg0), static_cast<float> (arg1));
1454
1455     return 0;
1456
1457   } catch(std::exception& e) {
1458     sq_throwerror(vm, e.what());
1459     return SQ_ERROR;
1460   } catch(...) {
1461     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_pos'"));
1462     return SQ_ERROR;
1463   }
1464
1465 }
1466
1467 static SQInteger FloatingImage_get_pos_x_wrapper(HSQUIRRELVM vm)
1468 {
1469   SQUserPointer data;
1470   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1471     sq_throwerror(vm, _SC("'get_pos_x' called without instance"));
1472     return SQ_ERROR;
1473   }
1474   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1475
1476   try {
1477     float return_value = _this->get_pos_x();
1478
1479     sq_pushfloat(vm, return_value);
1480     return 1;
1481
1482   } catch(std::exception& e) {
1483     sq_throwerror(vm, e.what());
1484     return SQ_ERROR;
1485   } catch(...) {
1486     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_x'"));
1487     return SQ_ERROR;
1488   }
1489
1490 }
1491
1492 static SQInteger FloatingImage_get_pos_y_wrapper(HSQUIRRELVM vm)
1493 {
1494   SQUserPointer data;
1495   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1496     sq_throwerror(vm, _SC("'get_pos_y' called without instance"));
1497     return SQ_ERROR;
1498   }
1499   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1500
1501   try {
1502     float return_value = _this->get_pos_y();
1503
1504     sq_pushfloat(vm, return_value);
1505     return 1;
1506
1507   } catch(std::exception& e) {
1508     sq_throwerror(vm, e.what());
1509     return SQ_ERROR;
1510   } catch(...) {
1511     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_y'"));
1512     return SQ_ERROR;
1513   }
1514
1515 }
1516
1517 static SQInteger FloatingImage_set_anchor_point_wrapper(HSQUIRRELVM vm)
1518 {
1519   SQUserPointer data;
1520   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1521     sq_throwerror(vm, _SC("'set_anchor_point' called without instance"));
1522     return SQ_ERROR;
1523   }
1524   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1525   SQInteger arg0;
1526   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
1527     sq_throwerror(vm, _SC("Argument 1 not an integer"));
1528     return SQ_ERROR;
1529   }
1530
1531   try {
1532     _this->set_anchor_point(static_cast<int> (arg0));
1533
1534     return 0;
1535
1536   } catch(std::exception& e) {
1537     sq_throwerror(vm, e.what());
1538     return SQ_ERROR;
1539   } catch(...) {
1540     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_anchor_point'"));
1541     return SQ_ERROR;
1542   }
1543
1544 }
1545
1546 static SQInteger FloatingImage_get_anchor_point_wrapper(HSQUIRRELVM vm)
1547 {
1548   SQUserPointer data;
1549   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1550     sq_throwerror(vm, _SC("'get_anchor_point' called without instance"));
1551     return SQ_ERROR;
1552   }
1553   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1554
1555   try {
1556     int return_value = _this->get_anchor_point();
1557
1558     sq_pushinteger(vm, return_value);
1559     return 1;
1560
1561   } catch(std::exception& e) {
1562     sq_throwerror(vm, e.what());
1563     return SQ_ERROR;
1564   } catch(...) {
1565     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_anchor_point'"));
1566     return SQ_ERROR;
1567   }
1568
1569 }
1570
1571 static SQInteger FloatingImage_set_visible_wrapper(HSQUIRRELVM vm)
1572 {
1573   SQUserPointer data;
1574   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1575     sq_throwerror(vm, _SC("'set_visible' called without instance"));
1576     return SQ_ERROR;
1577   }
1578   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1579   SQBool arg0;
1580   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1581     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1582     return SQ_ERROR;
1583   }
1584
1585   try {
1586     _this->set_visible(arg0 == SQTrue);
1587
1588     return 0;
1589
1590   } catch(std::exception& e) {
1591     sq_throwerror(vm, e.what());
1592     return SQ_ERROR;
1593   } catch(...) {
1594     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_visible'"));
1595     return SQ_ERROR;
1596   }
1597
1598 }
1599
1600 static SQInteger FloatingImage_get_visible_wrapper(HSQUIRRELVM vm)
1601 {
1602   SQUserPointer data;
1603   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1604     sq_throwerror(vm, _SC("'get_visible' called without instance"));
1605     return SQ_ERROR;
1606   }
1607   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1608
1609   try {
1610     bool return_value = _this->get_visible();
1611
1612     sq_pushbool(vm, return_value);
1613     return 1;
1614
1615   } catch(std::exception& e) {
1616     sq_throwerror(vm, e.what());
1617     return SQ_ERROR;
1618   } catch(...) {
1619     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_visible'"));
1620     return SQ_ERROR;
1621   }
1622
1623 }
1624
1625 static SQInteger FloatingImage_set_action_wrapper(HSQUIRRELVM vm)
1626 {
1627   SQUserPointer data;
1628   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1629     sq_throwerror(vm, _SC("'set_action' called without instance"));
1630     return SQ_ERROR;
1631   }
1632   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1633   const SQChar* arg0;
1634   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1635     sq_throwerror(vm, _SC("Argument 1 not a string"));
1636     return SQ_ERROR;
1637   }
1638
1639   try {
1640     _this->set_action(arg0);
1641
1642     return 0;
1643
1644   } catch(std::exception& e) {
1645     sq_throwerror(vm, e.what());
1646     return SQ_ERROR;
1647   } catch(...) {
1648     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_action'"));
1649     return SQ_ERROR;
1650   }
1651
1652 }
1653
1654 static SQInteger FloatingImage_get_action_wrapper(HSQUIRRELVM vm)
1655 {
1656   SQUserPointer data;
1657   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1658     sq_throwerror(vm, _SC("'get_action' called without instance"));
1659     return SQ_ERROR;
1660   }
1661   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1662
1663   try {
1664     std::string return_value = _this->get_action();
1665
1666     sq_pushstring(vm, return_value.c_str(), return_value.size());
1667     return 1;
1668
1669   } catch(std::exception& e) {
1670     sq_throwerror(vm, e.what());
1671     return SQ_ERROR;
1672   } catch(...) {
1673     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_action'"));
1674     return SQ_ERROR;
1675   }
1676
1677 }
1678
1679 static SQInteger Platform_release_hook(SQUserPointer ptr, SQInteger )
1680 {
1681   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (ptr);
1682   delete _this;
1683   return 0;
1684 }
1685
1686 static SQInteger Platform_goto_node_wrapper(HSQUIRRELVM vm)
1687 {
1688   SQUserPointer data;
1689   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1690     sq_throwerror(vm, _SC("'goto_node' called without instance"));
1691     return SQ_ERROR;
1692   }
1693   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (data);
1694   SQInteger arg0;
1695   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
1696     sq_throwerror(vm, _SC("Argument 1 not an integer"));
1697     return SQ_ERROR;
1698   }
1699
1700   try {
1701     _this->goto_node(static_cast<int> (arg0));
1702
1703     return 0;
1704
1705   } catch(std::exception& e) {
1706     sq_throwerror(vm, e.what());
1707     return SQ_ERROR;
1708   } catch(...) {
1709     sq_throwerror(vm, _SC("Unexpected exception while executing function 'goto_node'"));
1710     return SQ_ERROR;
1711   }
1712
1713 }
1714
1715 static SQInteger Platform_start_moving_wrapper(HSQUIRRELVM vm)
1716 {
1717   SQUserPointer data;
1718   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1719     sq_throwerror(vm, _SC("'start_moving' called without instance"));
1720     return SQ_ERROR;
1721   }
1722   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (data);
1723
1724   try {
1725     _this->start_moving();
1726
1727     return 0;
1728
1729   } catch(std::exception& e) {
1730     sq_throwerror(vm, e.what());
1731     return SQ_ERROR;
1732   } catch(...) {
1733     sq_throwerror(vm, _SC("Unexpected exception while executing function 'start_moving'"));
1734     return SQ_ERROR;
1735   }
1736
1737 }
1738
1739 static SQInteger Platform_stop_moving_wrapper(HSQUIRRELVM vm)
1740 {
1741   SQUserPointer data;
1742   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1743     sq_throwerror(vm, _SC("'stop_moving' called without instance"));
1744     return SQ_ERROR;
1745   }
1746   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (data);
1747
1748   try {
1749     _this->stop_moving();
1750
1751     return 0;
1752
1753   } catch(std::exception& e) {
1754     sq_throwerror(vm, e.what());
1755     return SQ_ERROR;
1756   } catch(...) {
1757     sq_throwerror(vm, _SC("Unexpected exception while executing function 'stop_moving'"));
1758     return SQ_ERROR;
1759   }
1760
1761 }
1762
1763 static SQInteger Candle_release_hook(SQUserPointer ptr, SQInteger )
1764 {
1765   Scripting::Candle* _this = reinterpret_cast<Scripting::Candle*> (ptr);
1766   delete _this;
1767   return 0;
1768 }
1769
1770 static SQInteger Candle_get_burning_wrapper(HSQUIRRELVM vm)
1771 {
1772   SQUserPointer data;
1773   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1774     sq_throwerror(vm, _SC("'get_burning' called without instance"));
1775     return SQ_ERROR;
1776   }
1777   Scripting::Candle* _this = reinterpret_cast<Scripting::Candle*> (data);
1778
1779   try {
1780     bool return_value = _this->get_burning();
1781
1782     sq_pushbool(vm, return_value);
1783     return 1;
1784
1785   } catch(std::exception& e) {
1786     sq_throwerror(vm, e.what());
1787     return SQ_ERROR;
1788   } catch(...) {
1789     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_burning'"));
1790     return SQ_ERROR;
1791   }
1792
1793 }
1794
1795 static SQInteger Candle_set_burning_wrapper(HSQUIRRELVM vm)
1796 {
1797   SQUserPointer data;
1798   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1799     sq_throwerror(vm, _SC("'set_burning' called without instance"));
1800     return SQ_ERROR;
1801   }
1802   Scripting::Candle* _this = reinterpret_cast<Scripting::Candle*> (data);
1803   SQBool arg0;
1804   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1805     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1806     return SQ_ERROR;
1807   }
1808
1809   try {
1810     _this->set_burning(arg0 == SQTrue);
1811
1812     return 0;
1813
1814   } catch(std::exception& e) {
1815     sq_throwerror(vm, e.what());
1816     return SQ_ERROR;
1817   } catch(...) {
1818     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_burning'"));
1819     return SQ_ERROR;
1820   }
1821
1822 }
1823
1824 static SQInteger Wind_release_hook(SQUserPointer ptr, SQInteger )
1825 {
1826   Scripting::Wind* _this = reinterpret_cast<Scripting::Wind*> (ptr);
1827   delete _this;
1828   return 0;
1829 }
1830
1831 static SQInteger Wind_start_wrapper(HSQUIRRELVM vm)
1832 {
1833   SQUserPointer data;
1834   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1835     sq_throwerror(vm, _SC("'start' called without instance"));
1836     return SQ_ERROR;
1837   }
1838   Scripting::Wind* _this = reinterpret_cast<Scripting::Wind*> (data);
1839
1840   try {
1841     _this->start();
1842
1843     return 0;
1844
1845   } catch(std::exception& e) {
1846     sq_throwerror(vm, e.what());
1847     return SQ_ERROR;
1848   } catch(...) {
1849     sq_throwerror(vm, _SC("Unexpected exception while executing function 'start'"));
1850     return SQ_ERROR;
1851   }
1852
1853 }
1854
1855 static SQInteger Wind_stop_wrapper(HSQUIRRELVM vm)
1856 {
1857   SQUserPointer data;
1858   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1859     sq_throwerror(vm, _SC("'stop' called without instance"));
1860     return SQ_ERROR;
1861   }
1862   Scripting::Wind* _this = reinterpret_cast<Scripting::Wind*> (data);
1863
1864   try {
1865     _this->stop();
1866
1867     return 0;
1868
1869   } catch(std::exception& e) {
1870     sq_throwerror(vm, e.what());
1871     return SQ_ERROR;
1872   } catch(...) {
1873     sq_throwerror(vm, _SC("Unexpected exception while executing function 'stop'"));
1874     return SQ_ERROR;
1875   }
1876
1877 }
1878
1879 static SQInteger display_wrapper(HSQUIRRELVM vm)
1880 {
1881   return Scripting::display(vm);
1882 }
1883
1884 static SQInteger print_stacktrace_wrapper(HSQUIRRELVM vm)
1885 {
1886   HSQUIRRELVM arg0 = vm;
1887
1888   try {
1889     Scripting::print_stacktrace(arg0);
1890
1891     return 0;
1892
1893   } catch(std::exception& e) {
1894     sq_throwerror(vm, e.what());
1895     return SQ_ERROR;
1896   } catch(...) {
1897     sq_throwerror(vm, _SC("Unexpected exception while executing function 'print_stacktrace'"));
1898     return SQ_ERROR;
1899   }
1900
1901 }
1902
1903 static SQInteger get_current_thread_wrapper(HSQUIRRELVM vm)
1904 {
1905   return Scripting::get_current_thread(vm);
1906 }
1907
1908 static SQInteger display_text_file_wrapper(HSQUIRRELVM vm)
1909 {
1910   const SQChar* arg0;
1911   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1912     sq_throwerror(vm, _SC("Argument 1 not a string"));
1913     return SQ_ERROR;
1914   }
1915
1916   try {
1917     Scripting::display_text_file(arg0);
1918
1919     return 0;
1920
1921   } catch(std::exception& e) {
1922     sq_throwerror(vm, e.what());
1923     return SQ_ERROR;
1924   } catch(...) {
1925     sq_throwerror(vm, _SC("Unexpected exception while executing function 'display_text_file'"));
1926     return SQ_ERROR;
1927   }
1928
1929 }
1930
1931 static SQInteger load_worldmap_wrapper(HSQUIRRELVM vm)
1932 {
1933   const SQChar* arg0;
1934   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1935     sq_throwerror(vm, _SC("Argument 1 not a string"));
1936     return SQ_ERROR;
1937   }
1938
1939   try {
1940     Scripting::load_worldmap(arg0);
1941
1942     return 0;
1943
1944   } catch(std::exception& e) {
1945     sq_throwerror(vm, e.what());
1946     return SQ_ERROR;
1947   } catch(...) {
1948     sq_throwerror(vm, _SC("Unexpected exception while executing function 'load_worldmap'"));
1949     return SQ_ERROR;
1950   }
1951
1952 }
1953
1954 static SQInteger load_level_wrapper(HSQUIRRELVM vm)
1955 {
1956   const SQChar* arg0;
1957   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1958     sq_throwerror(vm, _SC("Argument 1 not a string"));
1959     return SQ_ERROR;
1960   }
1961
1962   try {
1963     Scripting::load_level(arg0);
1964
1965     return 0;
1966
1967   } catch(std::exception& e) {
1968     sq_throwerror(vm, e.what());
1969     return SQ_ERROR;
1970   } catch(...) {
1971     sq_throwerror(vm, _SC("Unexpected exception while executing function 'load_level'"));
1972     return SQ_ERROR;
1973   }
1974
1975 }
1976
1977 static SQInteger wait_wrapper(HSQUIRRELVM vm)
1978 {
1979   HSQUIRRELVM arg0 = vm;
1980   SQFloat arg1;
1981   if(SQ_FAILED(sq_getfloat(vm, 2, &arg1))) {
1982     sq_throwerror(vm, _SC("Argument 1 not a float"));
1983     return SQ_ERROR;
1984   }
1985
1986   try {
1987     Scripting::wait(arg0, static_cast<float> (arg1));
1988
1989     return sq_suspendvm(vm);
1990
1991   } catch(std::exception& e) {
1992     sq_throwerror(vm, e.what());
1993     return SQ_ERROR;
1994   } catch(...) {
1995     sq_throwerror(vm, _SC("Unexpected exception while executing function 'wait'"));
1996     return SQ_ERROR;
1997   }
1998
1999 }
2000
2001 static SQInteger wait_for_screenswitch_wrapper(HSQUIRRELVM vm)
2002 {
2003   HSQUIRRELVM arg0 = vm;
2004
2005   try {
2006     Scripting::wait_for_screenswitch(arg0);
2007
2008     return sq_suspendvm(vm);
2009
2010   } catch(std::exception& e) {
2011     sq_throwerror(vm, e.what());
2012     return SQ_ERROR;
2013   } catch(...) {
2014     sq_throwerror(vm, _SC("Unexpected exception while executing function 'wait_for_screenswitch'"));
2015     return SQ_ERROR;
2016   }
2017
2018 }
2019
2020 static SQInteger exit_screen_wrapper(HSQUIRRELVM vm)
2021 {
2022   (void) vm;
2023
2024   try {
2025     Scripting::exit_screen();
2026
2027     return 0;
2028
2029   } catch(std::exception& e) {
2030     sq_throwerror(vm, e.what());
2031     return SQ_ERROR;
2032   } catch(...) {
2033     sq_throwerror(vm, _SC("Unexpected exception while executing function 'exit_screen'"));
2034     return SQ_ERROR;
2035   }
2036
2037 }
2038
2039 static SQInteger fadeout_screen_wrapper(HSQUIRRELVM vm)
2040 {
2041   SQFloat arg0;
2042   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
2043     sq_throwerror(vm, _SC("Argument 1 not a float"));
2044     return SQ_ERROR;
2045   }
2046
2047   try {
2048     Scripting::fadeout_screen(static_cast<float> (arg0));
2049
2050     return 0;
2051
2052   } catch(std::exception& e) {
2053     sq_throwerror(vm, e.what());
2054     return SQ_ERROR;
2055   } catch(...) {
2056     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fadeout_screen'"));
2057     return SQ_ERROR;
2058   }
2059
2060 }
2061
2062 static SQInteger shrink_screen_wrapper(HSQUIRRELVM vm)
2063 {
2064   SQFloat arg0;
2065   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
2066     sq_throwerror(vm, _SC("Argument 1 not a float"));
2067     return SQ_ERROR;
2068   }
2069   SQFloat arg1;
2070   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
2071     sq_throwerror(vm, _SC("Argument 2 not a float"));
2072     return SQ_ERROR;
2073   }
2074   SQFloat arg2;
2075   if(SQ_FAILED(sq_getfloat(vm, 4, &arg2))) {
2076     sq_throwerror(vm, _SC("Argument 3 not a float"));
2077     return SQ_ERROR;
2078   }
2079
2080   try {
2081     Scripting::shrink_screen(static_cast<float> (arg0), static_cast<float> (arg1), static_cast<float> (arg2));
2082
2083     return 0;
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 'shrink_screen'"));
2090     return SQ_ERROR;
2091   }
2092
2093 }
2094
2095 static SQInteger translate_wrapper(HSQUIRRELVM vm)
2096 {
2097   const SQChar* arg0;
2098   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2099     sq_throwerror(vm, _SC("Argument 1 not a string"));
2100     return SQ_ERROR;
2101   }
2102
2103   try {
2104     std::string return_value = Scripting::translate(arg0);
2105
2106     sq_pushstring(vm, return_value.c_str(), return_value.size());
2107     return 1;
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 'translate'"));
2114     return SQ_ERROR;
2115   }
2116
2117 }
2118
2119 static SQInteger import_wrapper(HSQUIRRELVM vm)
2120 {
2121   HSQUIRRELVM arg0 = vm;
2122   const SQChar* arg1;
2123   if(SQ_FAILED(sq_getstring(vm, 2, &arg1))) {
2124     sq_throwerror(vm, _SC("Argument 1 not a string"));
2125     return SQ_ERROR;
2126   }
2127
2128   try {
2129     Scripting::import(arg0, arg1);
2130
2131     return 0;
2132
2133   } catch(std::exception& e) {
2134     sq_throwerror(vm, e.what());
2135     return SQ_ERROR;
2136   } catch(...) {
2137     sq_throwerror(vm, _SC("Unexpected exception while executing function 'import'"));
2138     return SQ_ERROR;
2139   }
2140
2141 }
2142
2143 static SQInteger save_state_wrapper(HSQUIRRELVM vm)
2144 {
2145   (void) vm;
2146
2147   try {
2148     Scripting::save_state();
2149
2150     return 0;
2151
2152   } catch(std::exception& e) {
2153     sq_throwerror(vm, e.what());
2154     return SQ_ERROR;
2155   } catch(...) {
2156     sq_throwerror(vm, _SC("Unexpected exception while executing function 'save_state'"));
2157     return SQ_ERROR;
2158   }
2159
2160 }
2161
2162 static SQInteger debug_collrects_wrapper(HSQUIRRELVM vm)
2163 {
2164   SQBool arg0;
2165   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
2166     sq_throwerror(vm, _SC("Argument 1 not a bool"));
2167     return SQ_ERROR;
2168   }
2169
2170   try {
2171     Scripting::debug_collrects(arg0 == SQTrue);
2172
2173     return 0;
2174
2175   } catch(std::exception& e) {
2176     sq_throwerror(vm, e.what());
2177     return SQ_ERROR;
2178   } catch(...) {
2179     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_collrects'"));
2180     return SQ_ERROR;
2181   }
2182
2183 }
2184
2185 static SQInteger debug_show_fps_wrapper(HSQUIRRELVM vm)
2186 {
2187   SQBool arg0;
2188   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
2189     sq_throwerror(vm, _SC("Argument 1 not a bool"));
2190     return SQ_ERROR;
2191   }
2192
2193   try {
2194     Scripting::debug_show_fps(arg0 == SQTrue);
2195
2196     return 0;
2197
2198   } catch(std::exception& e) {
2199     sq_throwerror(vm, e.what());
2200     return SQ_ERROR;
2201   } catch(...) {
2202     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_show_fps'"));
2203     return SQ_ERROR;
2204   }
2205
2206 }
2207
2208 static SQInteger debug_draw_solids_only_wrapper(HSQUIRRELVM vm)
2209 {
2210   SQBool arg0;
2211   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
2212     sq_throwerror(vm, _SC("Argument 1 not a bool"));
2213     return SQ_ERROR;
2214   }
2215
2216   try {
2217     Scripting::debug_draw_solids_only(arg0 == SQTrue);
2218
2219     return 0;
2220
2221   } catch(std::exception& e) {
2222     sq_throwerror(vm, e.what());
2223     return SQ_ERROR;
2224   } catch(...) {
2225     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_draw_solids_only'"));
2226     return SQ_ERROR;
2227   }
2228
2229 }
2230
2231 static SQInteger play_music_wrapper(HSQUIRRELVM vm)
2232 {
2233   const SQChar* arg0;
2234   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2235     sq_throwerror(vm, _SC("Argument 1 not a string"));
2236     return SQ_ERROR;
2237   }
2238
2239   try {
2240     Scripting::play_music(arg0);
2241
2242     return 0;
2243
2244   } catch(std::exception& e) {
2245     sq_throwerror(vm, e.what());
2246     return SQ_ERROR;
2247   } catch(...) {
2248     sq_throwerror(vm, _SC("Unexpected exception while executing function 'play_music'"));
2249     return SQ_ERROR;
2250   }
2251
2252 }
2253
2254 static SQInteger play_sound_wrapper(HSQUIRRELVM vm)
2255 {
2256   const SQChar* arg0;
2257   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2258     sq_throwerror(vm, _SC("Argument 1 not a string"));
2259     return SQ_ERROR;
2260   }
2261
2262   try {
2263     Scripting::play_sound(arg0);
2264
2265     return 0;
2266
2267   } catch(std::exception& e) {
2268     sq_throwerror(vm, e.what());
2269     return SQ_ERROR;
2270   } catch(...) {
2271     sq_throwerror(vm, _SC("Unexpected exception while executing function 'play_sound'"));
2272     return SQ_ERROR;
2273   }
2274
2275 }
2276
2277 static SQInteger grease_wrapper(HSQUIRRELVM vm)
2278 {
2279   (void) vm;
2280
2281   try {
2282     Scripting::grease();
2283
2284     return 0;
2285
2286   } catch(std::exception& e) {
2287     sq_throwerror(vm, e.what());
2288     return SQ_ERROR;
2289   } catch(...) {
2290     sq_throwerror(vm, _SC("Unexpected exception while executing function 'grease'"));
2291     return SQ_ERROR;
2292   }
2293
2294 }
2295
2296 static SQInteger invincible_wrapper(HSQUIRRELVM vm)
2297 {
2298   (void) vm;
2299
2300   try {
2301     Scripting::invincible();
2302
2303     return 0;
2304
2305   } catch(std::exception& e) {
2306     sq_throwerror(vm, e.what());
2307     return SQ_ERROR;
2308   } catch(...) {
2309     sq_throwerror(vm, _SC("Unexpected exception while executing function 'invincible'"));
2310     return SQ_ERROR;
2311   }
2312
2313 }
2314
2315 static SQInteger ghost_wrapper(HSQUIRRELVM vm)
2316 {
2317   (void) vm;
2318
2319   try {
2320     Scripting::ghost();
2321
2322     return 0;
2323
2324   } catch(std::exception& e) {
2325     sq_throwerror(vm, e.what());
2326     return SQ_ERROR;
2327   } catch(...) {
2328     sq_throwerror(vm, _SC("Unexpected exception while executing function 'ghost'"));
2329     return SQ_ERROR;
2330   }
2331
2332 }
2333
2334 static SQInteger mortal_wrapper(HSQUIRRELVM vm)
2335 {
2336   (void) vm;
2337
2338   try {
2339     Scripting::mortal();
2340
2341     return 0;
2342
2343   } catch(std::exception& e) {
2344     sq_throwerror(vm, e.what());
2345     return SQ_ERROR;
2346   } catch(...) {
2347     sq_throwerror(vm, _SC("Unexpected exception while executing function 'mortal'"));
2348     return SQ_ERROR;
2349   }
2350
2351 }
2352
2353 static SQInteger restart_wrapper(HSQUIRRELVM vm)
2354 {
2355   (void) vm;
2356
2357   try {
2358     Scripting::restart();
2359
2360     return 0;
2361
2362   } catch(std::exception& e) {
2363     sq_throwerror(vm, e.what());
2364     return SQ_ERROR;
2365   } catch(...) {
2366     sq_throwerror(vm, _SC("Unexpected exception while executing function 'restart'"));
2367     return SQ_ERROR;
2368   }
2369
2370 }
2371
2372 static SQInteger whereami_wrapper(HSQUIRRELVM vm)
2373 {
2374   (void) vm;
2375
2376   try {
2377     Scripting::whereami();
2378
2379     return 0;
2380
2381   } catch(std::exception& e) {
2382     sq_throwerror(vm, e.what());
2383     return SQ_ERROR;
2384   } catch(...) {
2385     sq_throwerror(vm, _SC("Unexpected exception while executing function 'whereami'"));
2386     return SQ_ERROR;
2387   }
2388
2389 }
2390
2391 static SQInteger gotoend_wrapper(HSQUIRRELVM vm)
2392 {
2393   (void) vm;
2394
2395   try {
2396     Scripting::gotoend();
2397
2398     return 0;
2399
2400   } catch(std::exception& e) {
2401     sq_throwerror(vm, e.what());
2402     return SQ_ERROR;
2403   } catch(...) {
2404     sq_throwerror(vm, _SC("Unexpected exception while executing function 'gotoend'"));
2405     return SQ_ERROR;
2406   }
2407
2408 }
2409
2410 static SQInteger camera_wrapper(HSQUIRRELVM vm)
2411 {
2412   (void) vm;
2413
2414   try {
2415     Scripting::camera();
2416
2417     return 0;
2418
2419   } catch(std::exception& e) {
2420     sq_throwerror(vm, e.what());
2421     return SQ_ERROR;
2422   } catch(...) {
2423     sq_throwerror(vm, _SC("Unexpected exception while executing function 'camera'"));
2424     return SQ_ERROR;
2425   }
2426
2427 }
2428
2429 static SQInteger quit_wrapper(HSQUIRRELVM vm)
2430 {
2431   (void) vm;
2432
2433   try {
2434     Scripting::quit();
2435
2436     return 0;
2437
2438   } catch(std::exception& e) {
2439     sq_throwerror(vm, e.what());
2440     return SQ_ERROR;
2441   } catch(...) {
2442     sq_throwerror(vm, _SC("Unexpected exception while executing function 'quit'"));
2443     return SQ_ERROR;
2444   }
2445
2446 }
2447
2448 static SQInteger rand_wrapper(HSQUIRRELVM vm)
2449 {
2450
2451   try {
2452     int return_value = Scripting::rand();
2453
2454     sq_pushinteger(vm, return_value);
2455     return 1;
2456
2457   } catch(std::exception& e) {
2458     sq_throwerror(vm, e.what());
2459     return SQ_ERROR;
2460   } catch(...) {
2461     sq_throwerror(vm, _SC("Unexpected exception while executing function 'rand'"));
2462     return SQ_ERROR;
2463   }
2464
2465 }
2466
2467 } // end of namespace Wrapper
2468
2469 void create_squirrel_instance(HSQUIRRELVM v, Scripting::DisplayEffect* object, bool setup_releasehook)
2470 {
2471   using namespace Wrapper;
2472
2473   sq_pushroottable(v);
2474   sq_pushstring(v, "DisplayEffect", -1);
2475   if(SQ_FAILED(sq_get(v, -2))) {
2476     std::ostringstream msg;
2477     msg << "Couldn't resolved squirrel type 'DisplayEffect'";
2478     throw SquirrelError(v, msg.str());
2479   }
2480
2481   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2482     std::ostringstream msg;
2483     msg << "Couldn't setup squirrel instance for object of type 'DisplayEffect'";
2484     throw SquirrelError(v, msg.str());
2485   }
2486   sq_remove(v, -2); // remove object name
2487
2488   if(setup_releasehook) {
2489     sq_setreleasehook(v, -1, DisplayEffect_release_hook);
2490   }
2491
2492   sq_remove(v, -2); // remove root table
2493 }
2494
2495 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Camera* object, bool setup_releasehook)
2496 {
2497   using namespace Wrapper;
2498
2499   sq_pushroottable(v);
2500   sq_pushstring(v, "Camera", -1);
2501   if(SQ_FAILED(sq_get(v, -2))) {
2502     std::ostringstream msg;
2503     msg << "Couldn't resolved squirrel type 'Camera'";
2504     throw SquirrelError(v, msg.str());
2505   }
2506
2507   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2508     std::ostringstream msg;
2509     msg << "Couldn't setup squirrel instance for object of type 'Camera'";
2510     throw SquirrelError(v, msg.str());
2511   }
2512   sq_remove(v, -2); // remove object name
2513
2514   if(setup_releasehook) {
2515     sq_setreleasehook(v, -1, Camera_release_hook);
2516   }
2517
2518   sq_remove(v, -2); // remove root table
2519 }
2520
2521 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Level* object, bool setup_releasehook)
2522 {
2523   using namespace Wrapper;
2524
2525   sq_pushroottable(v);
2526   sq_pushstring(v, "Level", -1);
2527   if(SQ_FAILED(sq_get(v, -2))) {
2528     std::ostringstream msg;
2529     msg << "Couldn't resolved squirrel type 'Level'";
2530     throw SquirrelError(v, msg.str());
2531   }
2532
2533   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2534     std::ostringstream msg;
2535     msg << "Couldn't setup squirrel instance for object of type 'Level'";
2536     throw SquirrelError(v, msg.str());
2537   }
2538   sq_remove(v, -2); // remove object name
2539
2540   if(setup_releasehook) {
2541     sq_setreleasehook(v, -1, Level_release_hook);
2542   }
2543
2544   sq_remove(v, -2); // remove root table
2545 }
2546
2547 void create_squirrel_instance(HSQUIRRELVM v, Scripting::ScriptedObject* object, bool setup_releasehook)
2548 {
2549   using namespace Wrapper;
2550
2551   sq_pushroottable(v);
2552   sq_pushstring(v, "ScriptedObject", -1);
2553   if(SQ_FAILED(sq_get(v, -2))) {
2554     std::ostringstream msg;
2555     msg << "Couldn't resolved squirrel type 'ScriptedObject'";
2556     throw SquirrelError(v, msg.str());
2557   }
2558
2559   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2560     std::ostringstream msg;
2561     msg << "Couldn't setup squirrel instance for object of type 'ScriptedObject'";
2562     throw SquirrelError(v, msg.str());
2563   }
2564   sq_remove(v, -2); // remove object name
2565
2566   if(setup_releasehook) {
2567     sq_setreleasehook(v, -1, ScriptedObject_release_hook);
2568   }
2569
2570   sq_remove(v, -2); // remove root table
2571 }
2572
2573 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Text* object, bool setup_releasehook)
2574 {
2575   using namespace Wrapper;
2576
2577   sq_pushroottable(v);
2578   sq_pushstring(v, "Text", -1);
2579   if(SQ_FAILED(sq_get(v, -2))) {
2580     std::ostringstream msg;
2581     msg << "Couldn't resolved squirrel type 'Text'";
2582     throw SquirrelError(v, msg.str());
2583   }
2584
2585   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2586     std::ostringstream msg;
2587     msg << "Couldn't setup squirrel instance for object of type 'Text'";
2588     throw SquirrelError(v, msg.str());
2589   }
2590   sq_remove(v, -2); // remove object name
2591
2592   if(setup_releasehook) {
2593     sq_setreleasehook(v, -1, Text_release_hook);
2594   }
2595
2596   sq_remove(v, -2); // remove root table
2597 }
2598
2599 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Player* object, bool setup_releasehook)
2600 {
2601   using namespace Wrapper;
2602
2603   sq_pushroottable(v);
2604   sq_pushstring(v, "Player", -1);
2605   if(SQ_FAILED(sq_get(v, -2))) {
2606     std::ostringstream msg;
2607     msg << "Couldn't resolved squirrel type 'Player'";
2608     throw SquirrelError(v, msg.str());
2609   }
2610
2611   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2612     std::ostringstream msg;
2613     msg << "Couldn't setup squirrel instance for object of type 'Player'";
2614     throw SquirrelError(v, msg.str());
2615   }
2616   sq_remove(v, -2); // remove object name
2617
2618   if(setup_releasehook) {
2619     sq_setreleasehook(v, -1, Player_release_hook);
2620   }
2621
2622   sq_remove(v, -2); // remove root table
2623 }
2624
2625 void create_squirrel_instance(HSQUIRRELVM v, Scripting::FloatingImage* object, bool setup_releasehook)
2626 {
2627   using namespace Wrapper;
2628
2629   sq_pushroottable(v);
2630   sq_pushstring(v, "FloatingImage", -1);
2631   if(SQ_FAILED(sq_get(v, -2))) {
2632     std::ostringstream msg;
2633     msg << "Couldn't resolved squirrel type 'FloatingImage'";
2634     throw SquirrelError(v, msg.str());
2635   }
2636
2637   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2638     std::ostringstream msg;
2639     msg << "Couldn't setup squirrel instance for object of type 'FloatingImage'";
2640     throw SquirrelError(v, msg.str());
2641   }
2642   sq_remove(v, -2); // remove object name
2643
2644   if(setup_releasehook) {
2645     sq_setreleasehook(v, -1, FloatingImage_release_hook);
2646   }
2647
2648   sq_remove(v, -2); // remove root table
2649 }
2650
2651 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Platform* object, bool setup_releasehook)
2652 {
2653   using namespace Wrapper;
2654
2655   sq_pushroottable(v);
2656   sq_pushstring(v, "Platform", -1);
2657   if(SQ_FAILED(sq_get(v, -2))) {
2658     std::ostringstream msg;
2659     msg << "Couldn't resolved squirrel type 'Platform'";
2660     throw SquirrelError(v, msg.str());
2661   }
2662
2663   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2664     std::ostringstream msg;
2665     msg << "Couldn't setup squirrel instance for object of type 'Platform'";
2666     throw SquirrelError(v, msg.str());
2667   }
2668   sq_remove(v, -2); // remove object name
2669
2670   if(setup_releasehook) {
2671     sq_setreleasehook(v, -1, Platform_release_hook);
2672   }
2673
2674   sq_remove(v, -2); // remove root table
2675 }
2676
2677 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Candle* object, bool setup_releasehook)
2678 {
2679   using namespace Wrapper;
2680
2681   sq_pushroottable(v);
2682   sq_pushstring(v, "Candle", -1);
2683   if(SQ_FAILED(sq_get(v, -2))) {
2684     std::ostringstream msg;
2685     msg << "Couldn't resolved squirrel type 'Candle'";
2686     throw SquirrelError(v, msg.str());
2687   }
2688
2689   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2690     std::ostringstream msg;
2691     msg << "Couldn't setup squirrel instance for object of type 'Candle'";
2692     throw SquirrelError(v, msg.str());
2693   }
2694   sq_remove(v, -2); // remove object name
2695
2696   if(setup_releasehook) {
2697     sq_setreleasehook(v, -1, Candle_release_hook);
2698   }
2699
2700   sq_remove(v, -2); // remove root table
2701 }
2702
2703 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Wind* object, bool setup_releasehook)
2704 {
2705   using namespace Wrapper;
2706
2707   sq_pushroottable(v);
2708   sq_pushstring(v, "Wind", -1);
2709   if(SQ_FAILED(sq_get(v, -2))) {
2710     std::ostringstream msg;
2711     msg << "Couldn't resolved squirrel type 'Wind'";
2712     throw SquirrelError(v, msg.str());
2713   }
2714
2715   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2716     std::ostringstream msg;
2717     msg << "Couldn't setup squirrel instance for object of type 'Wind'";
2718     throw SquirrelError(v, msg.str());
2719   }
2720   sq_remove(v, -2); // remove object name
2721
2722   if(setup_releasehook) {
2723     sq_setreleasehook(v, -1, Wind_release_hook);
2724   }
2725
2726   sq_remove(v, -2); // remove root table
2727 }
2728
2729 void register_supertux_wrapper(HSQUIRRELVM v)
2730 {
2731   using namespace Wrapper;
2732
2733   sq_pushstring(v, "ANCHOR_TOP", -1);
2734   sq_pushinteger(v, 16);
2735   if(SQ_FAILED(sq_createslot(v, -3))) {
2736     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP'");
2737   }
2738
2739   sq_pushstring(v, "ANCHOR_BOTTOM", -1);
2740   sq_pushinteger(v, 32);
2741   if(SQ_FAILED(sq_createslot(v, -3))) {
2742     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM'");
2743   }
2744
2745   sq_pushstring(v, "ANCHOR_LEFT", -1);
2746   sq_pushinteger(v, 1);
2747   if(SQ_FAILED(sq_createslot(v, -3))) {
2748     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_LEFT'");
2749   }
2750
2751   sq_pushstring(v, "ANCHOR_RIGHT", -1);
2752   sq_pushinteger(v, 2);
2753   if(SQ_FAILED(sq_createslot(v, -3))) {
2754     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_RIGHT'");
2755   }
2756
2757   sq_pushstring(v, "ANCHOR_MIDDLE", -1);
2758   sq_pushinteger(v, 0);
2759   if(SQ_FAILED(sq_createslot(v, -3))) {
2760     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_MIDDLE'");
2761   }
2762
2763   sq_pushstring(v, "ANCHOR_TOP_LEFT", -1);
2764   sq_pushinteger(v, 17);
2765   if(SQ_FAILED(sq_createslot(v, -3))) {
2766     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP_LEFT'");
2767   }
2768
2769   sq_pushstring(v, "ANCHOR_TOP_RIGHT", -1);
2770   sq_pushinteger(v, 18);
2771   if(SQ_FAILED(sq_createslot(v, -3))) {
2772     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP_RIGHT'");
2773   }
2774
2775   sq_pushstring(v, "ANCHOR_BOTTOM_LEFT", -1);
2776   sq_pushinteger(v, 33);
2777   if(SQ_FAILED(sq_createslot(v, -3))) {
2778     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM_LEFT'");
2779   }
2780
2781   sq_pushstring(v, "ANCHOR_BOTTOM_RIGHT", -1);
2782   sq_pushinteger(v, 34);
2783   if(SQ_FAILED(sq_createslot(v, -3))) {
2784     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM_RIGHT'");
2785   }
2786
2787   sq_pushstring(v, "display", -1);
2788   sq_newclosure(v, &display_wrapper, 0);
2789   if(SQ_FAILED(sq_createslot(v, -3))) {
2790     throw SquirrelError(v, "Couldn't register function 'display'");
2791   }
2792
2793   sq_pushstring(v, "print_stacktrace", -1);
2794   sq_newclosure(v, &print_stacktrace_wrapper, 0);
2795   if(SQ_FAILED(sq_createslot(v, -3))) {
2796     throw SquirrelError(v, "Couldn't register function 'print_stacktrace'");
2797   }
2798
2799   sq_pushstring(v, "get_current_thread", -1);
2800   sq_newclosure(v, &get_current_thread_wrapper, 0);
2801   if(SQ_FAILED(sq_createslot(v, -3))) {
2802     throw SquirrelError(v, "Couldn't register function 'get_current_thread'");
2803   }
2804
2805   sq_pushstring(v, "display_text_file", -1);
2806   sq_newclosure(v, &display_text_file_wrapper, 0);
2807   if(SQ_FAILED(sq_createslot(v, -3))) {
2808     throw SquirrelError(v, "Couldn't register function 'display_text_file'");
2809   }
2810
2811   sq_pushstring(v, "load_worldmap", -1);
2812   sq_newclosure(v, &load_worldmap_wrapper, 0);
2813   if(SQ_FAILED(sq_createslot(v, -3))) {
2814     throw SquirrelError(v, "Couldn't register function 'load_worldmap'");
2815   }
2816
2817   sq_pushstring(v, "load_level", -1);
2818   sq_newclosure(v, &load_level_wrapper, 0);
2819   if(SQ_FAILED(sq_createslot(v, -3))) {
2820     throw SquirrelError(v, "Couldn't register function 'load_level'");
2821   }
2822
2823   sq_pushstring(v, "wait", -1);
2824   sq_newclosure(v, &wait_wrapper, 0);
2825   if(SQ_FAILED(sq_createslot(v, -3))) {
2826     throw SquirrelError(v, "Couldn't register function 'wait'");
2827   }
2828
2829   sq_pushstring(v, "wait_for_screenswitch", -1);
2830   sq_newclosure(v, &wait_for_screenswitch_wrapper, 0);
2831   if(SQ_FAILED(sq_createslot(v, -3))) {
2832     throw SquirrelError(v, "Couldn't register function 'wait_for_screenswitch'");
2833   }
2834
2835   sq_pushstring(v, "exit_screen", -1);
2836   sq_newclosure(v, &exit_screen_wrapper, 0);
2837   if(SQ_FAILED(sq_createslot(v, -3))) {
2838     throw SquirrelError(v, "Couldn't register function 'exit_screen'");
2839   }
2840
2841   sq_pushstring(v, "fadeout_screen", -1);
2842   sq_newclosure(v, &fadeout_screen_wrapper, 0);
2843   if(SQ_FAILED(sq_createslot(v, -3))) {
2844     throw SquirrelError(v, "Couldn't register function 'fadeout_screen'");
2845   }
2846
2847   sq_pushstring(v, "shrink_screen", -1);
2848   sq_newclosure(v, &shrink_screen_wrapper, 0);
2849   if(SQ_FAILED(sq_createslot(v, -3))) {
2850     throw SquirrelError(v, "Couldn't register function 'shrink_screen'");
2851   }
2852
2853   sq_pushstring(v, "translate", -1);
2854   sq_newclosure(v, &translate_wrapper, 0);
2855   if(SQ_FAILED(sq_createslot(v, -3))) {
2856     throw SquirrelError(v, "Couldn't register function 'translate'");
2857   }
2858
2859   sq_pushstring(v, "import", -1);
2860   sq_newclosure(v, &import_wrapper, 0);
2861   if(SQ_FAILED(sq_createslot(v, -3))) {
2862     throw SquirrelError(v, "Couldn't register function 'import'");
2863   }
2864
2865   sq_pushstring(v, "save_state", -1);
2866   sq_newclosure(v, &save_state_wrapper, 0);
2867   if(SQ_FAILED(sq_createslot(v, -3))) {
2868     throw SquirrelError(v, "Couldn't register function 'save_state'");
2869   }
2870
2871   sq_pushstring(v, "debug_collrects", -1);
2872   sq_newclosure(v, &debug_collrects_wrapper, 0);
2873   if(SQ_FAILED(sq_createslot(v, -3))) {
2874     throw SquirrelError(v, "Couldn't register function 'debug_collrects'");
2875   }
2876
2877   sq_pushstring(v, "debug_show_fps", -1);
2878   sq_newclosure(v, &debug_show_fps_wrapper, 0);
2879   if(SQ_FAILED(sq_createslot(v, -3))) {
2880     throw SquirrelError(v, "Couldn't register function 'debug_show_fps'");
2881   }
2882
2883   sq_pushstring(v, "debug_draw_solids_only", -1);
2884   sq_newclosure(v, &debug_draw_solids_only_wrapper, 0);
2885   if(SQ_FAILED(sq_createslot(v, -3))) {
2886     throw SquirrelError(v, "Couldn't register function 'debug_draw_solids_only'");
2887   }
2888
2889   sq_pushstring(v, "play_music", -1);
2890   sq_newclosure(v, &play_music_wrapper, 0);
2891   if(SQ_FAILED(sq_createslot(v, -3))) {
2892     throw SquirrelError(v, "Couldn't register function 'play_music'");
2893   }
2894
2895   sq_pushstring(v, "play_sound", -1);
2896   sq_newclosure(v, &play_sound_wrapper, 0);
2897   if(SQ_FAILED(sq_createslot(v, -3))) {
2898     throw SquirrelError(v, "Couldn't register function 'play_sound'");
2899   }
2900
2901   sq_pushstring(v, "grease", -1);
2902   sq_newclosure(v, &grease_wrapper, 0);
2903   if(SQ_FAILED(sq_createslot(v, -3))) {
2904     throw SquirrelError(v, "Couldn't register function 'grease'");
2905   }
2906
2907   sq_pushstring(v, "invincible", -1);
2908   sq_newclosure(v, &invincible_wrapper, 0);
2909   if(SQ_FAILED(sq_createslot(v, -3))) {
2910     throw SquirrelError(v, "Couldn't register function 'invincible'");
2911   }
2912
2913   sq_pushstring(v, "ghost", -1);
2914   sq_newclosure(v, &ghost_wrapper, 0);
2915   if(SQ_FAILED(sq_createslot(v, -3))) {
2916     throw SquirrelError(v, "Couldn't register function 'ghost'");
2917   }
2918
2919   sq_pushstring(v, "mortal", -1);
2920   sq_newclosure(v, &mortal_wrapper, 0);
2921   if(SQ_FAILED(sq_createslot(v, -3))) {
2922     throw SquirrelError(v, "Couldn't register function 'mortal'");
2923   }
2924
2925   sq_pushstring(v, "restart", -1);
2926   sq_newclosure(v, &restart_wrapper, 0);
2927   if(SQ_FAILED(sq_createslot(v, -3))) {
2928     throw SquirrelError(v, "Couldn't register function 'restart'");
2929   }
2930
2931   sq_pushstring(v, "whereami", -1);
2932   sq_newclosure(v, &whereami_wrapper, 0);
2933   if(SQ_FAILED(sq_createslot(v, -3))) {
2934     throw SquirrelError(v, "Couldn't register function 'whereami'");
2935   }
2936
2937   sq_pushstring(v, "gotoend", -1);
2938   sq_newclosure(v, &gotoend_wrapper, 0);
2939   if(SQ_FAILED(sq_createslot(v, -3))) {
2940     throw SquirrelError(v, "Couldn't register function 'gotoend'");
2941   }
2942
2943   sq_pushstring(v, "camera", -1);
2944   sq_newclosure(v, &camera_wrapper, 0);
2945   if(SQ_FAILED(sq_createslot(v, -3))) {
2946     throw SquirrelError(v, "Couldn't register function 'camera'");
2947   }
2948
2949   sq_pushstring(v, "quit", -1);
2950   sq_newclosure(v, &quit_wrapper, 0);
2951   if(SQ_FAILED(sq_createslot(v, -3))) {
2952     throw SquirrelError(v, "Couldn't register function 'quit'");
2953   }
2954
2955   sq_pushstring(v, "rand", -1);
2956   sq_newclosure(v, &rand_wrapper, 0);
2957   if(SQ_FAILED(sq_createslot(v, -3))) {
2958     throw SquirrelError(v, "Couldn't register function 'rand'");
2959   }
2960
2961   // Register class DisplayEffect
2962   sq_pushstring(v, "DisplayEffect", -1);
2963   if(sq_newclass(v, SQFalse) < 0) {
2964     std::ostringstream msg;
2965     msg << "Couldn't create new class 'DisplayEffect'";
2966     throw SquirrelError(v, msg.str());
2967   }
2968   sq_pushstring(v, "fade_out", -1);
2969   sq_newclosure(v, &DisplayEffect_fade_out_wrapper, 0);
2970   if(SQ_FAILED(sq_createslot(v, -3))) {
2971     throw SquirrelError(v, "Couldn't register function 'fade_out'");
2972   }
2973
2974   sq_pushstring(v, "fade_in", -1);
2975   sq_newclosure(v, &DisplayEffect_fade_in_wrapper, 0);
2976   if(SQ_FAILED(sq_createslot(v, -3))) {
2977     throw SquirrelError(v, "Couldn't register function 'fade_in'");
2978   }
2979
2980   sq_pushstring(v, "set_black", -1);
2981   sq_newclosure(v, &DisplayEffect_set_black_wrapper, 0);
2982   if(SQ_FAILED(sq_createslot(v, -3))) {
2983     throw SquirrelError(v, "Couldn't register function 'set_black'");
2984   }
2985
2986   sq_pushstring(v, "is_black", -1);
2987   sq_newclosure(v, &DisplayEffect_is_black_wrapper, 0);
2988   if(SQ_FAILED(sq_createslot(v, -3))) {
2989     throw SquirrelError(v, "Couldn't register function 'is_black'");
2990   }
2991
2992   sq_pushstring(v, "sixteen_to_nine", -1);
2993   sq_newclosure(v, &DisplayEffect_sixteen_to_nine_wrapper, 0);
2994   if(SQ_FAILED(sq_createslot(v, -3))) {
2995     throw SquirrelError(v, "Couldn't register function 'sixteen_to_nine'");
2996   }
2997
2998   sq_pushstring(v, "four_to_three", -1);
2999   sq_newclosure(v, &DisplayEffect_four_to_three_wrapper, 0);
3000   if(SQ_FAILED(sq_createslot(v, -3))) {
3001     throw SquirrelError(v, "Couldn't register function 'four_to_three'");
3002   }
3003
3004   if(SQ_FAILED(sq_createslot(v, -3))) {
3005     throw SquirrelError(v, "Couldn't register class 'DisplayEffect'");
3006   }
3007
3008   // Register class Camera
3009   sq_pushstring(v, "Camera", -1);
3010   if(sq_newclass(v, SQFalse) < 0) {
3011     std::ostringstream msg;
3012     msg << "Couldn't create new class 'Camera'";
3013     throw SquirrelError(v, msg.str());
3014   }
3015   sq_pushstring(v, "shake", -1);
3016   sq_newclosure(v, &Camera_shake_wrapper, 0);
3017   if(SQ_FAILED(sq_createslot(v, -3))) {
3018     throw SquirrelError(v, "Couldn't register function 'shake'");
3019   }
3020
3021   sq_pushstring(v, "set_pos", -1);
3022   sq_newclosure(v, &Camera_set_pos_wrapper, 0);
3023   if(SQ_FAILED(sq_createslot(v, -3))) {
3024     throw SquirrelError(v, "Couldn't register function 'set_pos'");
3025   }
3026
3027   sq_pushstring(v, "set_mode", -1);
3028   sq_newclosure(v, &Camera_set_mode_wrapper, 0);
3029   if(SQ_FAILED(sq_createslot(v, -3))) {
3030     throw SquirrelError(v, "Couldn't register function 'set_mode'");
3031   }
3032
3033   sq_pushstring(v, "scroll_to", -1);
3034   sq_newclosure(v, &Camera_scroll_to_wrapper, 0);
3035   if(SQ_FAILED(sq_createslot(v, -3))) {
3036     throw SquirrelError(v, "Couldn't register function 'scroll_to'");
3037   }
3038
3039   if(SQ_FAILED(sq_createslot(v, -3))) {
3040     throw SquirrelError(v, "Couldn't register class 'Camera'");
3041   }
3042
3043   // Register class Level
3044   sq_pushstring(v, "Level", -1);
3045   if(sq_newclass(v, SQFalse) < 0) {
3046     std::ostringstream msg;
3047     msg << "Couldn't create new class 'Level'";
3048     throw SquirrelError(v, msg.str());
3049   }
3050   sq_pushstring(v, "finish", -1);
3051   sq_newclosure(v, &Level_finish_wrapper, 0);
3052   if(SQ_FAILED(sq_createslot(v, -3))) {
3053     throw SquirrelError(v, "Couldn't register function 'finish'");
3054   }
3055
3056   sq_pushstring(v, "spawn", -1);
3057   sq_newclosure(v, &Level_spawn_wrapper, 0);
3058   if(SQ_FAILED(sq_createslot(v, -3))) {
3059     throw SquirrelError(v, "Couldn't register function 'spawn'");
3060   }
3061
3062   sq_pushstring(v, "flip_vertically", -1);
3063   sq_newclosure(v, &Level_flip_vertically_wrapper, 0);
3064   if(SQ_FAILED(sq_createslot(v, -3))) {
3065     throw SquirrelError(v, "Couldn't register function 'flip_vertically'");
3066   }
3067
3068   sq_pushstring(v, "toggle_pause", -1);
3069   sq_newclosure(v, &Level_toggle_pause_wrapper, 0);
3070   if(SQ_FAILED(sq_createslot(v, -3))) {
3071     throw SquirrelError(v, "Couldn't register function 'toggle_pause'");
3072   }
3073
3074   if(SQ_FAILED(sq_createslot(v, -3))) {
3075     throw SquirrelError(v, "Couldn't register class 'Level'");
3076   }
3077
3078   // Register class ScriptedObject
3079   sq_pushstring(v, "ScriptedObject", -1);
3080   if(sq_newclass(v, SQFalse) < 0) {
3081     std::ostringstream msg;
3082     msg << "Couldn't create new class 'ScriptedObject'";
3083     throw SquirrelError(v, msg.str());
3084   }
3085   sq_pushstring(v, "set_action", -1);
3086   sq_newclosure(v, &ScriptedObject_set_action_wrapper, 0);
3087   if(SQ_FAILED(sq_createslot(v, -3))) {
3088     throw SquirrelError(v, "Couldn't register function 'set_action'");
3089   }
3090
3091   sq_pushstring(v, "get_action", -1);
3092   sq_newclosure(v, &ScriptedObject_get_action_wrapper, 0);
3093   if(SQ_FAILED(sq_createslot(v, -3))) {
3094     throw SquirrelError(v, "Couldn't register function 'get_action'");
3095   }
3096
3097   sq_pushstring(v, "move", -1);
3098   sq_newclosure(v, &ScriptedObject_move_wrapper, 0);
3099   if(SQ_FAILED(sq_createslot(v, -3))) {
3100     throw SquirrelError(v, "Couldn't register function 'move'");
3101   }
3102
3103   sq_pushstring(v, "set_pos", -1);
3104   sq_newclosure(v, &ScriptedObject_set_pos_wrapper, 0);
3105   if(SQ_FAILED(sq_createslot(v, -3))) {
3106     throw SquirrelError(v, "Couldn't register function 'set_pos'");
3107   }
3108
3109   sq_pushstring(v, "get_pos_x", -1);
3110   sq_newclosure(v, &ScriptedObject_get_pos_x_wrapper, 0);
3111   if(SQ_FAILED(sq_createslot(v, -3))) {
3112     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
3113   }
3114
3115   sq_pushstring(v, "get_pos_y", -1);
3116   sq_newclosure(v, &ScriptedObject_get_pos_y_wrapper, 0);
3117   if(SQ_FAILED(sq_createslot(v, -3))) {
3118     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
3119   }
3120
3121   sq_pushstring(v, "set_velocity", -1);
3122   sq_newclosure(v, &ScriptedObject_set_velocity_wrapper, 0);
3123   if(SQ_FAILED(sq_createslot(v, -3))) {
3124     throw SquirrelError(v, "Couldn't register function 'set_velocity'");
3125   }
3126
3127   sq_pushstring(v, "get_velocity_x", -1);
3128   sq_newclosure(v, &ScriptedObject_get_velocity_x_wrapper, 0);
3129   if(SQ_FAILED(sq_createslot(v, -3))) {
3130     throw SquirrelError(v, "Couldn't register function 'get_velocity_x'");
3131   }
3132
3133   sq_pushstring(v, "get_velocity_y", -1);
3134   sq_newclosure(v, &ScriptedObject_get_velocity_y_wrapper, 0);
3135   if(SQ_FAILED(sq_createslot(v, -3))) {
3136     throw SquirrelError(v, "Couldn't register function 'get_velocity_y'");
3137   }
3138
3139   sq_pushstring(v, "set_visible", -1);
3140   sq_newclosure(v, &ScriptedObject_set_visible_wrapper, 0);
3141   if(SQ_FAILED(sq_createslot(v, -3))) {
3142     throw SquirrelError(v, "Couldn't register function 'set_visible'");
3143   }
3144
3145   sq_pushstring(v, "is_visible", -1);
3146   sq_newclosure(v, &ScriptedObject_is_visible_wrapper, 0);
3147   if(SQ_FAILED(sq_createslot(v, -3))) {
3148     throw SquirrelError(v, "Couldn't register function 'is_visible'");
3149   }
3150
3151   sq_pushstring(v, "set_solid", -1);
3152   sq_newclosure(v, &ScriptedObject_set_solid_wrapper, 0);
3153   if(SQ_FAILED(sq_createslot(v, -3))) {
3154     throw SquirrelError(v, "Couldn't register function 'set_solid'");
3155   }
3156
3157   sq_pushstring(v, "is_solid", -1);
3158   sq_newclosure(v, &ScriptedObject_is_solid_wrapper, 0);
3159   if(SQ_FAILED(sq_createslot(v, -3))) {
3160     throw SquirrelError(v, "Couldn't register function 'is_solid'");
3161   }
3162
3163   sq_pushstring(v, "get_name", -1);
3164   sq_newclosure(v, &ScriptedObject_get_name_wrapper, 0);
3165   if(SQ_FAILED(sq_createslot(v, -3))) {
3166     throw SquirrelError(v, "Couldn't register function 'get_name'");
3167   }
3168
3169   if(SQ_FAILED(sq_createslot(v, -3))) {
3170     throw SquirrelError(v, "Couldn't register class 'ScriptedObject'");
3171   }
3172
3173   // Register class Text
3174   sq_pushstring(v, "Text", -1);
3175   if(sq_newclass(v, SQFalse) < 0) {
3176     std::ostringstream msg;
3177     msg << "Couldn't create new class 'Text'";
3178     throw SquirrelError(v, msg.str());
3179   }
3180   sq_pushstring(v, "set_text", -1);
3181   sq_newclosure(v, &Text_set_text_wrapper, 0);
3182   if(SQ_FAILED(sq_createslot(v, -3))) {
3183     throw SquirrelError(v, "Couldn't register function 'set_text'");
3184   }
3185
3186   sq_pushstring(v, "set_font", -1);
3187   sq_newclosure(v, &Text_set_font_wrapper, 0);
3188   if(SQ_FAILED(sq_createslot(v, -3))) {
3189     throw SquirrelError(v, "Couldn't register function 'set_font'");
3190   }
3191
3192   sq_pushstring(v, "fade_in", -1);
3193   sq_newclosure(v, &Text_fade_in_wrapper, 0);
3194   if(SQ_FAILED(sq_createslot(v, -3))) {
3195     throw SquirrelError(v, "Couldn't register function 'fade_in'");
3196   }
3197
3198   sq_pushstring(v, "fade_out", -1);
3199   sq_newclosure(v, &Text_fade_out_wrapper, 0);
3200   if(SQ_FAILED(sq_createslot(v, -3))) {
3201     throw SquirrelError(v, "Couldn't register function 'fade_out'");
3202   }
3203
3204   sq_pushstring(v, "set_visible", -1);
3205   sq_newclosure(v, &Text_set_visible_wrapper, 0);
3206   if(SQ_FAILED(sq_createslot(v, -3))) {
3207     throw SquirrelError(v, "Couldn't register function 'set_visible'");
3208   }
3209
3210   sq_pushstring(v, "set_centered", -1);
3211   sq_newclosure(v, &Text_set_centered_wrapper, 0);
3212   if(SQ_FAILED(sq_createslot(v, -3))) {
3213     throw SquirrelError(v, "Couldn't register function 'set_centered'");
3214   }
3215
3216   if(SQ_FAILED(sq_createslot(v, -3))) {
3217     throw SquirrelError(v, "Couldn't register class 'Text'");
3218   }
3219
3220   // Register class Player
3221   sq_pushstring(v, "Player", -1);
3222   if(sq_newclass(v, SQFalse) < 0) {
3223     std::ostringstream msg;
3224     msg << "Couldn't create new class 'Player'";
3225     throw SquirrelError(v, msg.str());
3226   }
3227   sq_pushstring(v, "add_bonus", -1);
3228   sq_newclosure(v, &Player_add_bonus_wrapper, 0);
3229   if(SQ_FAILED(sq_createslot(v, -3))) {
3230     throw SquirrelError(v, "Couldn't register function 'add_bonus'");
3231   }
3232
3233   sq_pushstring(v, "add_coins", -1);
3234   sq_newclosure(v, &Player_add_coins_wrapper, 0);
3235   if(SQ_FAILED(sq_createslot(v, -3))) {
3236     throw SquirrelError(v, "Couldn't register function 'add_coins'");
3237   }
3238
3239   sq_pushstring(v, "make_invincible", -1);
3240   sq_newclosure(v, &Player_make_invincible_wrapper, 0);
3241   if(SQ_FAILED(sq_createslot(v, -3))) {
3242     throw SquirrelError(v, "Couldn't register function 'make_invincible'");
3243   }
3244
3245   sq_pushstring(v, "deactivate", -1);
3246   sq_newclosure(v, &Player_deactivate_wrapper, 0);
3247   if(SQ_FAILED(sq_createslot(v, -3))) {
3248     throw SquirrelError(v, "Couldn't register function 'deactivate'");
3249   }
3250
3251   sq_pushstring(v, "activate", -1);
3252   sq_newclosure(v, &Player_activate_wrapper, 0);
3253   if(SQ_FAILED(sq_createslot(v, -3))) {
3254     throw SquirrelError(v, "Couldn't register function 'activate'");
3255   }
3256
3257   sq_pushstring(v, "walk", -1);
3258   sq_newclosure(v, &Player_walk_wrapper, 0);
3259   if(SQ_FAILED(sq_createslot(v, -3))) {
3260     throw SquirrelError(v, "Couldn't register function 'walk'");
3261   }
3262
3263   sq_pushstring(v, "set_visible", -1);
3264   sq_newclosure(v, &Player_set_visible_wrapper, 0);
3265   if(SQ_FAILED(sq_createslot(v, -3))) {
3266     throw SquirrelError(v, "Couldn't register function 'set_visible'");
3267   }
3268
3269   sq_pushstring(v, "get_visible", -1);
3270   sq_newclosure(v, &Player_get_visible_wrapper, 0);
3271   if(SQ_FAILED(sq_createslot(v, -3))) {
3272     throw SquirrelError(v, "Couldn't register function 'get_visible'");
3273   }
3274
3275   sq_pushstring(v, "kill", -1);
3276   sq_newclosure(v, &Player_kill_wrapper, 0);
3277   if(SQ_FAILED(sq_createslot(v, -3))) {
3278     throw SquirrelError(v, "Couldn't register function 'kill'");
3279   }
3280
3281   sq_pushstring(v, "set_ghost_mode", -1);
3282   sq_newclosure(v, &Player_set_ghost_mode_wrapper, 0);
3283   if(SQ_FAILED(sq_createslot(v, -3))) {
3284     throw SquirrelError(v, "Couldn't register function 'set_ghost_mode'");
3285   }
3286
3287   sq_pushstring(v, "get_ghost_mode", -1);
3288   sq_newclosure(v, &Player_get_ghost_mode_wrapper, 0);
3289   if(SQ_FAILED(sq_createslot(v, -3))) {
3290     throw SquirrelError(v, "Couldn't register function 'get_ghost_mode'");
3291   }
3292
3293   if(SQ_FAILED(sq_createslot(v, -3))) {
3294     throw SquirrelError(v, "Couldn't register class 'Player'");
3295   }
3296
3297   // Register class FloatingImage
3298   sq_pushstring(v, "FloatingImage", -1);
3299   if(sq_newclass(v, SQFalse) < 0) {
3300     std::ostringstream msg;
3301     msg << "Couldn't create new class 'FloatingImage'";
3302     throw SquirrelError(v, msg.str());
3303   }
3304   sq_pushstring(v, "constructor", -1);
3305   sq_newclosure(v, &FloatingImage_constructor_wrapper, 0);
3306   if(SQ_FAILED(sq_createslot(v, -3))) {
3307     throw SquirrelError(v, "Couldn't register function 'constructor'");
3308   }
3309
3310   sq_pushstring(v, "set_layer", -1);
3311   sq_newclosure(v, &FloatingImage_set_layer_wrapper, 0);
3312   if(SQ_FAILED(sq_createslot(v, -3))) {
3313     throw SquirrelError(v, "Couldn't register function 'set_layer'");
3314   }
3315
3316   sq_pushstring(v, "get_layer", -1);
3317   sq_newclosure(v, &FloatingImage_get_layer_wrapper, 0);
3318   if(SQ_FAILED(sq_createslot(v, -3))) {
3319     throw SquirrelError(v, "Couldn't register function 'get_layer'");
3320   }
3321
3322   sq_pushstring(v, "set_pos", -1);
3323   sq_newclosure(v, &FloatingImage_set_pos_wrapper, 0);
3324   if(SQ_FAILED(sq_createslot(v, -3))) {
3325     throw SquirrelError(v, "Couldn't register function 'set_pos'");
3326   }
3327
3328   sq_pushstring(v, "get_pos_x", -1);
3329   sq_newclosure(v, &FloatingImage_get_pos_x_wrapper, 0);
3330   if(SQ_FAILED(sq_createslot(v, -3))) {
3331     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
3332   }
3333
3334   sq_pushstring(v, "get_pos_y", -1);
3335   sq_newclosure(v, &FloatingImage_get_pos_y_wrapper, 0);
3336   if(SQ_FAILED(sq_createslot(v, -3))) {
3337     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
3338   }
3339
3340   sq_pushstring(v, "set_anchor_point", -1);
3341   sq_newclosure(v, &FloatingImage_set_anchor_point_wrapper, 0);
3342   if(SQ_FAILED(sq_createslot(v, -3))) {
3343     throw SquirrelError(v, "Couldn't register function 'set_anchor_point'");
3344   }
3345
3346   sq_pushstring(v, "get_anchor_point", -1);
3347   sq_newclosure(v, &FloatingImage_get_anchor_point_wrapper, 0);
3348   if(SQ_FAILED(sq_createslot(v, -3))) {
3349     throw SquirrelError(v, "Couldn't register function 'get_anchor_point'");
3350   }
3351
3352   sq_pushstring(v, "set_visible", -1);
3353   sq_newclosure(v, &FloatingImage_set_visible_wrapper, 0);
3354   if(SQ_FAILED(sq_createslot(v, -3))) {
3355     throw SquirrelError(v, "Couldn't register function 'set_visible'");
3356   }
3357
3358   sq_pushstring(v, "get_visible", -1);
3359   sq_newclosure(v, &FloatingImage_get_visible_wrapper, 0);
3360   if(SQ_FAILED(sq_createslot(v, -3))) {
3361     throw SquirrelError(v, "Couldn't register function 'get_visible'");
3362   }
3363
3364   sq_pushstring(v, "set_action", -1);
3365   sq_newclosure(v, &FloatingImage_set_action_wrapper, 0);
3366   if(SQ_FAILED(sq_createslot(v, -3))) {
3367     throw SquirrelError(v, "Couldn't register function 'set_action'");
3368   }
3369
3370   sq_pushstring(v, "get_action", -1);
3371   sq_newclosure(v, &FloatingImage_get_action_wrapper, 0);
3372   if(SQ_FAILED(sq_createslot(v, -3))) {
3373     throw SquirrelError(v, "Couldn't register function 'get_action'");
3374   }
3375
3376   if(SQ_FAILED(sq_createslot(v, -3))) {
3377     throw SquirrelError(v, "Couldn't register class 'FloatingImage'");
3378   }
3379
3380   // Register class Platform
3381   sq_pushstring(v, "Platform", -1);
3382   if(sq_newclass(v, SQFalse) < 0) {
3383     std::ostringstream msg;
3384     msg << "Couldn't create new class 'Platform'";
3385     throw SquirrelError(v, msg.str());
3386   }
3387   sq_pushstring(v, "goto_node", -1);
3388   sq_newclosure(v, &Platform_goto_node_wrapper, 0);
3389   if(SQ_FAILED(sq_createslot(v, -3))) {
3390     throw SquirrelError(v, "Couldn't register function 'goto_node'");
3391   }
3392
3393   sq_pushstring(v, "start_moving", -1);
3394   sq_newclosure(v, &Platform_start_moving_wrapper, 0);
3395   if(SQ_FAILED(sq_createslot(v, -3))) {
3396     throw SquirrelError(v, "Couldn't register function 'start_moving'");
3397   }
3398
3399   sq_pushstring(v, "stop_moving", -1);
3400   sq_newclosure(v, &Platform_stop_moving_wrapper, 0);
3401   if(SQ_FAILED(sq_createslot(v, -3))) {
3402     throw SquirrelError(v, "Couldn't register function 'stop_moving'");
3403   }
3404
3405   if(SQ_FAILED(sq_createslot(v, -3))) {
3406     throw SquirrelError(v, "Couldn't register class 'Platform'");
3407   }
3408
3409   // Register class Candle
3410   sq_pushstring(v, "Candle", -1);
3411   if(sq_newclass(v, SQFalse) < 0) {
3412     std::ostringstream msg;
3413     msg << "Couldn't create new class 'Candle'";
3414     throw SquirrelError(v, msg.str());
3415   }
3416   sq_pushstring(v, "get_burning", -1);
3417   sq_newclosure(v, &Candle_get_burning_wrapper, 0);
3418   if(SQ_FAILED(sq_createslot(v, -3))) {
3419     throw SquirrelError(v, "Couldn't register function 'get_burning'");
3420   }
3421
3422   sq_pushstring(v, "set_burning", -1);
3423   sq_newclosure(v, &Candle_set_burning_wrapper, 0);
3424   if(SQ_FAILED(sq_createslot(v, -3))) {
3425     throw SquirrelError(v, "Couldn't register function 'set_burning'");
3426   }
3427
3428   if(SQ_FAILED(sq_createslot(v, -3))) {
3429     throw SquirrelError(v, "Couldn't register class 'Candle'");
3430   }
3431
3432   // Register class Wind
3433   sq_pushstring(v, "Wind", -1);
3434   if(sq_newclass(v, SQFalse) < 0) {
3435     std::ostringstream msg;
3436     msg << "Couldn't create new class 'Wind'";
3437     throw SquirrelError(v, msg.str());
3438   }
3439   sq_pushstring(v, "start", -1);
3440   sq_newclosure(v, &Wind_start_wrapper, 0);
3441   if(SQ_FAILED(sq_createslot(v, -3))) {
3442     throw SquirrelError(v, "Couldn't register function 'start'");
3443   }
3444
3445   sq_pushstring(v, "stop", -1);
3446   sq_newclosure(v, &Wind_stop_wrapper, 0);
3447   if(SQ_FAILED(sq_createslot(v, -3))) {
3448     throw SquirrelError(v, "Couldn't register function 'stop'");
3449   }
3450
3451   if(SQ_FAILED(sq_createslot(v, -3))) {
3452     throw SquirrelError(v, "Couldn't register class 'Wind'");
3453   }
3454
3455 }
3456
3457 } // end of namespace Scripting
3458