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