a90bb81b88d55d1673d9ce72ae0cb1cdc9fe9f83
[supertux.git] / 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     bool return_value = _this->add_bonus(arg0);
1064   
1065     sq_pushbool(vm, return_value);
1066     return 1;
1067   
1068   } catch(std::exception& e) {
1069     sq_throwerror(vm, e.what());
1070     return SQ_ERROR;
1071   } catch(...) {
1072     sq_throwerror(vm, _SC("Unexpected exception while executing function 'add_bonus'"));
1073     return SQ_ERROR;
1074   }
1075   
1076 }
1077
1078 static SQInteger Player_add_coins_wrapper(HSQUIRRELVM vm)
1079 {
1080   SQUserPointer data;
1081   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1082     sq_throwerror(vm, _SC("'add_coins' called without instance"));
1083     return SQ_ERROR;
1084   }
1085   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1086   SQInteger arg0;
1087   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
1088     sq_throwerror(vm, _SC("Argument 1 not an integer"));
1089     return SQ_ERROR;
1090   }
1091   
1092   try {
1093     _this->add_coins(static_cast<int> (arg0));
1094   
1095     return 0;
1096   
1097   } catch(std::exception& e) {
1098     sq_throwerror(vm, e.what());
1099     return SQ_ERROR;
1100   } catch(...) {
1101     sq_throwerror(vm, _SC("Unexpected exception while executing function 'add_coins'"));
1102     return SQ_ERROR;
1103   }
1104   
1105 }
1106
1107 static SQInteger Player_make_invincible_wrapper(HSQUIRRELVM vm)
1108 {
1109   SQUserPointer data;
1110   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1111     sq_throwerror(vm, _SC("'make_invincible' called without instance"));
1112     return SQ_ERROR;
1113   }
1114   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1115   
1116   try {
1117     _this->make_invincible();
1118   
1119     return 0;
1120   
1121   } catch(std::exception& e) {
1122     sq_throwerror(vm, e.what());
1123     return SQ_ERROR;
1124   } catch(...) {
1125     sq_throwerror(vm, _SC("Unexpected exception while executing function 'make_invincible'"));
1126     return SQ_ERROR;
1127   }
1128   
1129 }
1130
1131 static SQInteger Player_deactivate_wrapper(HSQUIRRELVM vm)
1132 {
1133   SQUserPointer data;
1134   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1135     sq_throwerror(vm, _SC("'deactivate' called without instance"));
1136     return SQ_ERROR;
1137   }
1138   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1139   
1140   try {
1141     _this->deactivate();
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 'deactivate'"));
1150     return SQ_ERROR;
1151   }
1152   
1153 }
1154
1155 static SQInteger Player_activate_wrapper(HSQUIRRELVM vm)
1156 {
1157   SQUserPointer data;
1158   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1159     sq_throwerror(vm, _SC("'activate' called without instance"));
1160     return SQ_ERROR;
1161   }
1162   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1163   
1164   try {
1165     _this->activate();
1166   
1167     return 0;
1168   
1169   } catch(std::exception& e) {
1170     sq_throwerror(vm, e.what());
1171     return SQ_ERROR;
1172   } catch(...) {
1173     sq_throwerror(vm, _SC("Unexpected exception while executing function 'activate'"));
1174     return SQ_ERROR;
1175   }
1176   
1177 }
1178
1179 static SQInteger Player_walk_wrapper(HSQUIRRELVM vm)
1180 {
1181   SQUserPointer data;
1182   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1183     sq_throwerror(vm, _SC("'walk' called without instance"));
1184     return SQ_ERROR;
1185   }
1186   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1187   SQFloat arg0;
1188   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
1189     sq_throwerror(vm, _SC("Argument 1 not a float"));
1190     return SQ_ERROR;
1191   }
1192   
1193   try {
1194     _this->walk(static_cast<float> (arg0));
1195   
1196     return 0;
1197   
1198   } catch(std::exception& e) {
1199     sq_throwerror(vm, e.what());
1200     return SQ_ERROR;
1201   } catch(...) {
1202     sq_throwerror(vm, _SC("Unexpected exception while executing function 'walk'"));
1203     return SQ_ERROR;
1204   }
1205   
1206 }
1207
1208 static SQInteger Player_set_visible_wrapper(HSQUIRRELVM vm)
1209 {
1210   SQUserPointer data;
1211   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1212     sq_throwerror(vm, _SC("'set_visible' called without instance"));
1213     return SQ_ERROR;
1214   }
1215   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1216   SQBool arg0;
1217   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1218     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1219     return SQ_ERROR;
1220   }
1221   
1222   try {
1223     _this->set_visible(arg0 == SQTrue);
1224   
1225     return 0;
1226   
1227   } catch(std::exception& e) {
1228     sq_throwerror(vm, e.what());
1229     return SQ_ERROR;
1230   } catch(...) {
1231     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_visible'"));
1232     return SQ_ERROR;
1233   }
1234   
1235 }
1236
1237 static SQInteger Player_get_visible_wrapper(HSQUIRRELVM vm)
1238 {
1239   SQUserPointer data;
1240   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1241     sq_throwerror(vm, _SC("'get_visible' called without instance"));
1242     return SQ_ERROR;
1243   }
1244   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1245   
1246   try {
1247     bool return_value = _this->get_visible();
1248   
1249     sq_pushbool(vm, return_value);
1250     return 1;
1251   
1252   } catch(std::exception& e) {
1253     sq_throwerror(vm, e.what());
1254     return SQ_ERROR;
1255   } catch(...) {
1256     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_visible'"));
1257     return SQ_ERROR;
1258   }
1259   
1260 }
1261
1262 static SQInteger Player_kill_wrapper(HSQUIRRELVM vm)
1263 {
1264   SQUserPointer data;
1265   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1266     sq_throwerror(vm, _SC("'kill' called without instance"));
1267     return SQ_ERROR;
1268   }
1269   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1270   SQBool arg0;
1271   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1272     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1273     return SQ_ERROR;
1274   }
1275   
1276   try {
1277     _this->kill(arg0 == SQTrue);
1278   
1279     return 0;
1280   
1281   } catch(std::exception& e) {
1282     sq_throwerror(vm, e.what());
1283     return SQ_ERROR;
1284   } catch(...) {
1285     sq_throwerror(vm, _SC("Unexpected exception while executing function 'kill'"));
1286     return SQ_ERROR;
1287   }
1288   
1289 }
1290
1291 static SQInteger Player_set_ghost_mode_wrapper(HSQUIRRELVM vm)
1292 {
1293   SQUserPointer data;
1294   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1295     sq_throwerror(vm, _SC("'set_ghost_mode' called without instance"));
1296     return SQ_ERROR;
1297   }
1298   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1299   SQBool arg0;
1300   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1301     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1302     return SQ_ERROR;
1303   }
1304   
1305   try {
1306     _this->set_ghost_mode(arg0 == SQTrue);
1307   
1308     return 0;
1309   
1310   } catch(std::exception& e) {
1311     sq_throwerror(vm, e.what());
1312     return SQ_ERROR;
1313   } catch(...) {
1314     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_ghost_mode'"));
1315     return SQ_ERROR;
1316   }
1317   
1318 }
1319
1320 static SQInteger Player_get_ghost_mode_wrapper(HSQUIRRELVM vm)
1321 {
1322   SQUserPointer data;
1323   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1324     sq_throwerror(vm, _SC("'get_ghost_mode' called without instance"));
1325     return SQ_ERROR;
1326   }
1327   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1328   
1329   try {
1330     bool return_value = _this->get_ghost_mode();
1331   
1332     sq_pushbool(vm, return_value);
1333     return 1;
1334   
1335   } catch(std::exception& e) {
1336     sq_throwerror(vm, e.what());
1337     return SQ_ERROR;
1338   } catch(...) {
1339     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_ghost_mode'"));
1340     return SQ_ERROR;
1341   }
1342   
1343 }
1344
1345 static SQInteger Player_do_cheer_wrapper(HSQUIRRELVM vm)
1346 {
1347   SQUserPointer data;
1348   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1349     sq_throwerror(vm, _SC("'do_cheer' called without instance"));
1350     return SQ_ERROR;
1351   }
1352   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1353   
1354   try {
1355     _this->do_cheer();
1356   
1357     return 0;
1358   
1359   } catch(std::exception& e) {
1360     sq_throwerror(vm, e.what());
1361     return SQ_ERROR;
1362   } catch(...) {
1363     sq_throwerror(vm, _SC("Unexpected exception while executing function 'do_cheer'"));
1364     return SQ_ERROR;
1365   }
1366   
1367 }
1368
1369 static SQInteger Player_do_duck_wrapper(HSQUIRRELVM vm)
1370 {
1371   SQUserPointer data;
1372   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1373     sq_throwerror(vm, _SC("'do_duck' called without instance"));
1374     return SQ_ERROR;
1375   }
1376   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1377   
1378   try {
1379     _this->do_duck();
1380   
1381     return 0;
1382   
1383   } catch(std::exception& e) {
1384     sq_throwerror(vm, e.what());
1385     return SQ_ERROR;
1386   } catch(...) {
1387     sq_throwerror(vm, _SC("Unexpected exception while executing function 'do_duck'"));
1388     return SQ_ERROR;
1389   }
1390   
1391 }
1392
1393 static SQInteger Player_do_standup_wrapper(HSQUIRRELVM vm)
1394 {
1395   SQUserPointer data;
1396   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1397     sq_throwerror(vm, _SC("'do_standup' called without instance"));
1398     return SQ_ERROR;
1399   }
1400   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1401   
1402   try {
1403     _this->do_standup();
1404   
1405     return 0;
1406   
1407   } catch(std::exception& e) {
1408     sq_throwerror(vm, e.what());
1409     return SQ_ERROR;
1410   } catch(...) {
1411     sq_throwerror(vm, _SC("Unexpected exception while executing function 'do_standup'"));
1412     return SQ_ERROR;
1413   }
1414   
1415 }
1416
1417 static SQInteger Player_do_backflip_wrapper(HSQUIRRELVM vm)
1418 {
1419   SQUserPointer data;
1420   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1421     sq_throwerror(vm, _SC("'do_backflip' called without instance"));
1422     return SQ_ERROR;
1423   }
1424   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1425   
1426   try {
1427     _this->do_backflip();
1428   
1429     return 0;
1430   
1431   } catch(std::exception& e) {
1432     sq_throwerror(vm, e.what());
1433     return SQ_ERROR;
1434   } catch(...) {
1435     sq_throwerror(vm, _SC("Unexpected exception while executing function 'do_backflip'"));
1436     return SQ_ERROR;
1437   }
1438   
1439 }
1440
1441 static SQInteger Player_do_jump_wrapper(HSQUIRRELVM vm)
1442 {
1443   SQUserPointer data;
1444   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1445     sq_throwerror(vm, _SC("'do_jump' called without instance"));
1446     return SQ_ERROR;
1447   }
1448   Scripting::Player* _this = reinterpret_cast<Scripting::Player*> (data);
1449   SQFloat arg0;
1450   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
1451     sq_throwerror(vm, _SC("Argument 1 not a float"));
1452     return SQ_ERROR;
1453   }
1454   
1455   try {
1456     _this->do_jump(static_cast<float> (arg0));
1457   
1458     return 0;
1459   
1460   } catch(std::exception& e) {
1461     sq_throwerror(vm, e.what());
1462     return SQ_ERROR;
1463   } catch(...) {
1464     sq_throwerror(vm, _SC("Unexpected exception while executing function 'do_jump'"));
1465     return SQ_ERROR;
1466   }
1467   
1468 }
1469
1470 static SQInteger FloatingImage_release_hook(SQUserPointer ptr, SQInteger )
1471 {
1472   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (ptr);
1473   delete _this;
1474   return 0;
1475 }
1476
1477 static SQInteger FloatingImage_constructor_wrapper(HSQUIRRELVM vm)
1478 {
1479   const SQChar* arg0;
1480   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1481     sq_throwerror(vm, _SC("Argument 1 not a string"));
1482     return SQ_ERROR;
1483   }
1484   
1485   try {
1486     Scripting::FloatingImage* _this = new Scripting::FloatingImage(arg0);
1487   if(SQ_FAILED(sq_setinstanceup(vm, 1, _this))) {
1488     sq_throwerror(vm, _SC("Couldn't setup instance of 'FloatingImage' class"));
1489     return SQ_ERROR;
1490   }
1491   sq_setreleasehook(vm, 1, FloatingImage_release_hook);
1492   
1493     return 0;
1494   
1495   } catch(std::exception& e) {
1496     sq_throwerror(vm, e.what());
1497     return SQ_ERROR;
1498   } catch(...) {
1499     sq_throwerror(vm, _SC("Unexpected exception while executing function 'constructor'"));
1500     return SQ_ERROR;
1501   }
1502   
1503 }
1504
1505 static SQInteger FloatingImage_set_layer_wrapper(HSQUIRRELVM vm)
1506 {
1507   SQUserPointer data;
1508   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1509     sq_throwerror(vm, _SC("'set_layer' called without instance"));
1510     return SQ_ERROR;
1511   }
1512   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1513   SQInteger arg0;
1514   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
1515     sq_throwerror(vm, _SC("Argument 1 not an integer"));
1516     return SQ_ERROR;
1517   }
1518   
1519   try {
1520     _this->set_layer(static_cast<int> (arg0));
1521   
1522     return 0;
1523   
1524   } catch(std::exception& e) {
1525     sq_throwerror(vm, e.what());
1526     return SQ_ERROR;
1527   } catch(...) {
1528     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_layer'"));
1529     return SQ_ERROR;
1530   }
1531   
1532 }
1533
1534 static SQInteger FloatingImage_get_layer_wrapper(HSQUIRRELVM vm)
1535 {
1536   SQUserPointer data;
1537   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1538     sq_throwerror(vm, _SC("'get_layer' called without instance"));
1539     return SQ_ERROR;
1540   }
1541   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1542   
1543   try {
1544     int return_value = _this->get_layer();
1545   
1546     sq_pushinteger(vm, return_value);
1547     return 1;
1548   
1549   } catch(std::exception& e) {
1550     sq_throwerror(vm, e.what());
1551     return SQ_ERROR;
1552   } catch(...) {
1553     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_layer'"));
1554     return SQ_ERROR;
1555   }
1556   
1557 }
1558
1559 static SQInteger FloatingImage_set_pos_wrapper(HSQUIRRELVM vm)
1560 {
1561   SQUserPointer data;
1562   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1563     sq_throwerror(vm, _SC("'set_pos' called without instance"));
1564     return SQ_ERROR;
1565   }
1566   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1567   SQFloat arg0;
1568   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
1569     sq_throwerror(vm, _SC("Argument 1 not a float"));
1570     return SQ_ERROR;
1571   }
1572   SQFloat arg1;
1573   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
1574     sq_throwerror(vm, _SC("Argument 2 not a float"));
1575     return SQ_ERROR;
1576   }
1577   
1578   try {
1579     _this->set_pos(static_cast<float> (arg0), static_cast<float> (arg1));
1580   
1581     return 0;
1582   
1583   } catch(std::exception& e) {
1584     sq_throwerror(vm, e.what());
1585     return SQ_ERROR;
1586   } catch(...) {
1587     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_pos'"));
1588     return SQ_ERROR;
1589   }
1590   
1591 }
1592
1593 static SQInteger FloatingImage_get_pos_x_wrapper(HSQUIRRELVM vm)
1594 {
1595   SQUserPointer data;
1596   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1597     sq_throwerror(vm, _SC("'get_pos_x' called without instance"));
1598     return SQ_ERROR;
1599   }
1600   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1601   
1602   try {
1603     float return_value = _this->get_pos_x();
1604   
1605     sq_pushfloat(vm, return_value);
1606     return 1;
1607   
1608   } catch(std::exception& e) {
1609     sq_throwerror(vm, e.what());
1610     return SQ_ERROR;
1611   } catch(...) {
1612     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_x'"));
1613     return SQ_ERROR;
1614   }
1615   
1616 }
1617
1618 static SQInteger FloatingImage_get_pos_y_wrapper(HSQUIRRELVM vm)
1619 {
1620   SQUserPointer data;
1621   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1622     sq_throwerror(vm, _SC("'get_pos_y' called without instance"));
1623     return SQ_ERROR;
1624   }
1625   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1626   
1627   try {
1628     float return_value = _this->get_pos_y();
1629   
1630     sq_pushfloat(vm, return_value);
1631     return 1;
1632   
1633   } catch(std::exception& e) {
1634     sq_throwerror(vm, e.what());
1635     return SQ_ERROR;
1636   } catch(...) {
1637     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_y'"));
1638     return SQ_ERROR;
1639   }
1640   
1641 }
1642
1643 static SQInteger FloatingImage_set_anchor_point_wrapper(HSQUIRRELVM vm)
1644 {
1645   SQUserPointer data;
1646   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1647     sq_throwerror(vm, _SC("'set_anchor_point' called without instance"));
1648     return SQ_ERROR;
1649   }
1650   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1651   SQInteger arg0;
1652   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
1653     sq_throwerror(vm, _SC("Argument 1 not an integer"));
1654     return SQ_ERROR;
1655   }
1656   
1657   try {
1658     _this->set_anchor_point(static_cast<int> (arg0));
1659   
1660     return 0;
1661   
1662   } catch(std::exception& e) {
1663     sq_throwerror(vm, e.what());
1664     return SQ_ERROR;
1665   } catch(...) {
1666     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_anchor_point'"));
1667     return SQ_ERROR;
1668   }
1669   
1670 }
1671
1672 static SQInteger FloatingImage_get_anchor_point_wrapper(HSQUIRRELVM vm)
1673 {
1674   SQUserPointer data;
1675   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1676     sq_throwerror(vm, _SC("'get_anchor_point' called without instance"));
1677     return SQ_ERROR;
1678   }
1679   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1680   
1681   try {
1682     int return_value = _this->get_anchor_point();
1683   
1684     sq_pushinteger(vm, return_value);
1685     return 1;
1686   
1687   } catch(std::exception& e) {
1688     sq_throwerror(vm, e.what());
1689     return SQ_ERROR;
1690   } catch(...) {
1691     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_anchor_point'"));
1692     return SQ_ERROR;
1693   }
1694   
1695 }
1696
1697 static SQInteger FloatingImage_set_visible_wrapper(HSQUIRRELVM vm)
1698 {
1699   SQUserPointer data;
1700   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1701     sq_throwerror(vm, _SC("'set_visible' called without instance"));
1702     return SQ_ERROR;
1703   }
1704   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1705   SQBool arg0;
1706   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1707     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1708     return SQ_ERROR;
1709   }
1710   
1711   try {
1712     _this->set_visible(arg0 == SQTrue);
1713   
1714     return 0;
1715   
1716   } catch(std::exception& e) {
1717     sq_throwerror(vm, e.what());
1718     return SQ_ERROR;
1719   } catch(...) {
1720     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_visible'"));
1721     return SQ_ERROR;
1722   }
1723   
1724 }
1725
1726 static SQInteger FloatingImage_get_visible_wrapper(HSQUIRRELVM vm)
1727 {
1728   SQUserPointer data;
1729   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1730     sq_throwerror(vm, _SC("'get_visible' called without instance"));
1731     return SQ_ERROR;
1732   }
1733   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1734   
1735   try {
1736     bool return_value = _this->get_visible();
1737   
1738     sq_pushbool(vm, return_value);
1739     return 1;
1740   
1741   } catch(std::exception& e) {
1742     sq_throwerror(vm, e.what());
1743     return SQ_ERROR;
1744   } catch(...) {
1745     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_visible'"));
1746     return SQ_ERROR;
1747   }
1748   
1749 }
1750
1751 static SQInteger FloatingImage_set_action_wrapper(HSQUIRRELVM vm)
1752 {
1753   SQUserPointer data;
1754   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1755     sq_throwerror(vm, _SC("'set_action' called without instance"));
1756     return SQ_ERROR;
1757   }
1758   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1759   const SQChar* arg0;
1760   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
1761     sq_throwerror(vm, _SC("Argument 1 not a string"));
1762     return SQ_ERROR;
1763   }
1764   
1765   try {
1766     _this->set_action(arg0);
1767   
1768     return 0;
1769   
1770   } catch(std::exception& e) {
1771     sq_throwerror(vm, e.what());
1772     return SQ_ERROR;
1773   } catch(...) {
1774     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_action'"));
1775     return SQ_ERROR;
1776   }
1777   
1778 }
1779
1780 static SQInteger FloatingImage_get_action_wrapper(HSQUIRRELVM vm)
1781 {
1782   SQUserPointer data;
1783   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1784     sq_throwerror(vm, _SC("'get_action' called without instance"));
1785     return SQ_ERROR;
1786   }
1787   Scripting::FloatingImage* _this = reinterpret_cast<Scripting::FloatingImage*> (data);
1788   
1789   try {
1790     std::string return_value = _this->get_action();
1791   
1792     sq_pushstring(vm, return_value.c_str(), return_value.size());
1793     return 1;
1794   
1795   } catch(std::exception& e) {
1796     sq_throwerror(vm, e.what());
1797     return SQ_ERROR;
1798   } catch(...) {
1799     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_action'"));
1800     return SQ_ERROR;
1801   }
1802   
1803 }
1804
1805 static SQInteger Platform_release_hook(SQUserPointer ptr, SQInteger )
1806 {
1807   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (ptr);
1808   delete _this;
1809   return 0;
1810 }
1811
1812 static SQInteger Platform_goto_node_wrapper(HSQUIRRELVM vm)
1813 {
1814   SQUserPointer data;
1815   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1816     sq_throwerror(vm, _SC("'goto_node' called without instance"));
1817     return SQ_ERROR;
1818   }
1819   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (data);
1820   SQInteger arg0;
1821   if(SQ_FAILED(sq_getinteger(vm, 2, &arg0))) {
1822     sq_throwerror(vm, _SC("Argument 1 not an integer"));
1823     return SQ_ERROR;
1824   }
1825   
1826   try {
1827     _this->goto_node(static_cast<int> (arg0));
1828   
1829     return 0;
1830   
1831   } catch(std::exception& e) {
1832     sq_throwerror(vm, e.what());
1833     return SQ_ERROR;
1834   } catch(...) {
1835     sq_throwerror(vm, _SC("Unexpected exception while executing function 'goto_node'"));
1836     return SQ_ERROR;
1837   }
1838   
1839 }
1840
1841 static SQInteger Platform_start_moving_wrapper(HSQUIRRELVM vm)
1842 {
1843   SQUserPointer data;
1844   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1845     sq_throwerror(vm, _SC("'start_moving' called without instance"));
1846     return SQ_ERROR;
1847   }
1848   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (data);
1849   
1850   try {
1851     _this->start_moving();
1852   
1853     return 0;
1854   
1855   } catch(std::exception& e) {
1856     sq_throwerror(vm, e.what());
1857     return SQ_ERROR;
1858   } catch(...) {
1859     sq_throwerror(vm, _SC("Unexpected exception while executing function 'start_moving'"));
1860     return SQ_ERROR;
1861   }
1862   
1863 }
1864
1865 static SQInteger Platform_stop_moving_wrapper(HSQUIRRELVM vm)
1866 {
1867   SQUserPointer data;
1868   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1869     sq_throwerror(vm, _SC("'stop_moving' called without instance"));
1870     return SQ_ERROR;
1871   }
1872   Scripting::Platform* _this = reinterpret_cast<Scripting::Platform*> (data);
1873   
1874   try {
1875     _this->stop_moving();
1876   
1877     return 0;
1878   
1879   } catch(std::exception& e) {
1880     sq_throwerror(vm, e.what());
1881     return SQ_ERROR;
1882   } catch(...) {
1883     sq_throwerror(vm, _SC("Unexpected exception while executing function 'stop_moving'"));
1884     return SQ_ERROR;
1885   }
1886   
1887 }
1888
1889 static SQInteger Candle_release_hook(SQUserPointer ptr, SQInteger )
1890 {
1891   Scripting::Candle* _this = reinterpret_cast<Scripting::Candle*> (ptr);
1892   delete _this;
1893   return 0;
1894 }
1895
1896 static SQInteger Candle_get_burning_wrapper(HSQUIRRELVM vm)
1897 {
1898   SQUserPointer data;
1899   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1900     sq_throwerror(vm, _SC("'get_burning' called without instance"));
1901     return SQ_ERROR;
1902   }
1903   Scripting::Candle* _this = reinterpret_cast<Scripting::Candle*> (data);
1904   
1905   try {
1906     bool return_value = _this->get_burning();
1907   
1908     sq_pushbool(vm, return_value);
1909     return 1;
1910   
1911   } catch(std::exception& e) {
1912     sq_throwerror(vm, e.what());
1913     return SQ_ERROR;
1914   } catch(...) {
1915     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_burning'"));
1916     return SQ_ERROR;
1917   }
1918   
1919 }
1920
1921 static SQInteger Candle_set_burning_wrapper(HSQUIRRELVM vm)
1922 {
1923   SQUserPointer data;
1924   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1925     sq_throwerror(vm, _SC("'set_burning' called without instance"));
1926     return SQ_ERROR;
1927   }
1928   Scripting::Candle* _this = reinterpret_cast<Scripting::Candle*> (data);
1929   SQBool arg0;
1930   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
1931     sq_throwerror(vm, _SC("Argument 1 not a bool"));
1932     return SQ_ERROR;
1933   }
1934   
1935   try {
1936     _this->set_burning(arg0 == SQTrue);
1937   
1938     return 0;
1939   
1940   } catch(std::exception& e) {
1941     sq_throwerror(vm, e.what());
1942     return SQ_ERROR;
1943   } catch(...) {
1944     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_burning'"));
1945     return SQ_ERROR;
1946   }
1947   
1948 }
1949
1950 static SQInteger Wind_release_hook(SQUserPointer ptr, SQInteger )
1951 {
1952   Scripting::Wind* _this = reinterpret_cast<Scripting::Wind*> (ptr);
1953   delete _this;
1954   return 0;
1955 }
1956
1957 static SQInteger Wind_start_wrapper(HSQUIRRELVM vm)
1958 {
1959   SQUserPointer data;
1960   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1961     sq_throwerror(vm, _SC("'start' called without instance"));
1962     return SQ_ERROR;
1963   }
1964   Scripting::Wind* _this = reinterpret_cast<Scripting::Wind*> (data);
1965   
1966   try {
1967     _this->start();
1968   
1969     return 0;
1970   
1971   } catch(std::exception& e) {
1972     sq_throwerror(vm, e.what());
1973     return SQ_ERROR;
1974   } catch(...) {
1975     sq_throwerror(vm, _SC("Unexpected exception while executing function 'start'"));
1976     return SQ_ERROR;
1977   }
1978   
1979 }
1980
1981 static SQInteger Wind_stop_wrapper(HSQUIRRELVM vm)
1982 {
1983   SQUserPointer data;
1984   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
1985     sq_throwerror(vm, _SC("'stop' called without instance"));
1986     return SQ_ERROR;
1987   }
1988   Scripting::Wind* _this = reinterpret_cast<Scripting::Wind*> (data);
1989   
1990   try {
1991     _this->stop();
1992   
1993     return 0;
1994   
1995   } catch(std::exception& e) {
1996     sq_throwerror(vm, e.what());
1997     return SQ_ERROR;
1998   } catch(...) {
1999     sq_throwerror(vm, _SC("Unexpected exception while executing function 'stop'"));
2000     return SQ_ERROR;
2001   }
2002   
2003 }
2004
2005 static SQInteger AmbientSound_release_hook(SQUserPointer ptr, SQInteger )
2006 {
2007   Scripting::AmbientSound* _this = reinterpret_cast<Scripting::AmbientSound*> (ptr);
2008   delete _this;
2009   return 0;
2010 }
2011
2012 static SQInteger AmbientSound_set_pos_wrapper(HSQUIRRELVM vm)
2013 {
2014   SQUserPointer data;
2015   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
2016     sq_throwerror(vm, _SC("'set_pos' called without instance"));
2017     return SQ_ERROR;
2018   }
2019   Scripting::AmbientSound* _this = reinterpret_cast<Scripting::AmbientSound*> (data);
2020   SQFloat arg0;
2021   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
2022     sq_throwerror(vm, _SC("Argument 1 not a float"));
2023     return SQ_ERROR;
2024   }
2025   SQFloat arg1;
2026   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
2027     sq_throwerror(vm, _SC("Argument 2 not a float"));
2028     return SQ_ERROR;
2029   }
2030   
2031   try {
2032     _this->set_pos(static_cast<float> (arg0), static_cast<float> (arg1));
2033   
2034     return 0;
2035   
2036   } catch(std::exception& e) {
2037     sq_throwerror(vm, e.what());
2038     return SQ_ERROR;
2039   } catch(...) {
2040     sq_throwerror(vm, _SC("Unexpected exception while executing function 'set_pos'"));
2041     return SQ_ERROR;
2042   }
2043   
2044 }
2045
2046 static SQInteger AmbientSound_get_pos_x_wrapper(HSQUIRRELVM vm)
2047 {
2048   SQUserPointer data;
2049   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
2050     sq_throwerror(vm, _SC("'get_pos_x' called without instance"));
2051     return SQ_ERROR;
2052   }
2053   Scripting::AmbientSound* _this = reinterpret_cast<Scripting::AmbientSound*> (data);
2054   
2055   try {
2056     float return_value = _this->get_pos_x();
2057   
2058     sq_pushfloat(vm, return_value);
2059     return 1;
2060   
2061   } catch(std::exception& e) {
2062     sq_throwerror(vm, e.what());
2063     return SQ_ERROR;
2064   } catch(...) {
2065     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_x'"));
2066     return SQ_ERROR;
2067   }
2068   
2069 }
2070
2071 static SQInteger AmbientSound_get_pos_y_wrapper(HSQUIRRELVM vm)
2072 {
2073   SQUserPointer data;
2074   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
2075     sq_throwerror(vm, _SC("'get_pos_y' called without instance"));
2076     return SQ_ERROR;
2077   }
2078   Scripting::AmbientSound* _this = reinterpret_cast<Scripting::AmbientSound*> (data);
2079   
2080   try {
2081     float return_value = _this->get_pos_y();
2082   
2083     sq_pushfloat(vm, return_value);
2084     return 1;
2085   
2086   } catch(std::exception& e) {
2087     sq_throwerror(vm, e.what());
2088     return SQ_ERROR;
2089   } catch(...) {
2090     sq_throwerror(vm, _SC("Unexpected exception while executing function 'get_pos_y'"));
2091     return SQ_ERROR;
2092   }
2093   
2094 }
2095
2096 static SQInteger Thunderstorm_release_hook(SQUserPointer ptr, SQInteger )
2097 {
2098   Scripting::Thunderstorm* _this = reinterpret_cast<Scripting::Thunderstorm*> (ptr);
2099   delete _this;
2100   return 0;
2101 }
2102
2103 static SQInteger Thunderstorm_start_wrapper(HSQUIRRELVM vm)
2104 {
2105   SQUserPointer data;
2106   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
2107     sq_throwerror(vm, _SC("'start' called without instance"));
2108     return SQ_ERROR;
2109   }
2110   Scripting::Thunderstorm* _this = reinterpret_cast<Scripting::Thunderstorm*> (data);
2111   
2112   try {
2113     _this->start();
2114   
2115     return 0;
2116   
2117   } catch(std::exception& e) {
2118     sq_throwerror(vm, e.what());
2119     return SQ_ERROR;
2120   } catch(...) {
2121     sq_throwerror(vm, _SC("Unexpected exception while executing function 'start'"));
2122     return SQ_ERROR;
2123   }
2124   
2125 }
2126
2127 static SQInteger Thunderstorm_stop_wrapper(HSQUIRRELVM vm)
2128 {
2129   SQUserPointer data;
2130   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
2131     sq_throwerror(vm, _SC("'stop' called without instance"));
2132     return SQ_ERROR;
2133   }
2134   Scripting::Thunderstorm* _this = reinterpret_cast<Scripting::Thunderstorm*> (data);
2135   
2136   try {
2137     _this->stop();
2138   
2139     return 0;
2140   
2141   } catch(std::exception& e) {
2142     sq_throwerror(vm, e.what());
2143     return SQ_ERROR;
2144   } catch(...) {
2145     sq_throwerror(vm, _SC("Unexpected exception while executing function 'stop'"));
2146     return SQ_ERROR;
2147   }
2148   
2149 }
2150
2151 static SQInteger Thunderstorm_thunder_wrapper(HSQUIRRELVM vm)
2152 {
2153   SQUserPointer data;
2154   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
2155     sq_throwerror(vm, _SC("'thunder' called without instance"));
2156     return SQ_ERROR;
2157   }
2158   Scripting::Thunderstorm* _this = reinterpret_cast<Scripting::Thunderstorm*> (data);
2159   
2160   try {
2161     _this->thunder();
2162   
2163     return 0;
2164   
2165   } catch(std::exception& e) {
2166     sq_throwerror(vm, e.what());
2167     return SQ_ERROR;
2168   } catch(...) {
2169     sq_throwerror(vm, _SC("Unexpected exception while executing function 'thunder'"));
2170     return SQ_ERROR;
2171   }
2172   
2173 }
2174
2175 static SQInteger Thunderstorm_lightning_wrapper(HSQUIRRELVM vm)
2176 {
2177   SQUserPointer data;
2178   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
2179     sq_throwerror(vm, _SC("'lightning' called without instance"));
2180     return SQ_ERROR;
2181   }
2182   Scripting::Thunderstorm* _this = reinterpret_cast<Scripting::Thunderstorm*> (data);
2183   
2184   try {
2185     _this->lightning();
2186   
2187     return 0;
2188   
2189   } catch(std::exception& e) {
2190     sq_throwerror(vm, e.what());
2191     return SQ_ERROR;
2192   } catch(...) {
2193     sq_throwerror(vm, _SC("Unexpected exception while executing function 'lightning'"));
2194     return SQ_ERROR;
2195   }
2196   
2197 }
2198
2199 static SQInteger Thunderstorm_flash_wrapper(HSQUIRRELVM vm)
2200 {
2201   SQUserPointer data;
2202   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
2203     sq_throwerror(vm, _SC("'flash' called without instance"));
2204     return SQ_ERROR;
2205   }
2206   Scripting::Thunderstorm* _this = reinterpret_cast<Scripting::Thunderstorm*> (data);
2207   
2208   try {
2209     _this->flash();
2210   
2211     return 0;
2212   
2213   } catch(std::exception& e) {
2214     sq_throwerror(vm, e.what());
2215     return SQ_ERROR;
2216   } catch(...) {
2217     sq_throwerror(vm, _SC("Unexpected exception while executing function 'flash'"));
2218     return SQ_ERROR;
2219   }
2220   
2221 }
2222
2223 static SQInteger Thunderstorm_electrify_wrapper(HSQUIRRELVM vm)
2224 {
2225   SQUserPointer data;
2226   if(SQ_FAILED(sq_getinstanceup(vm, 1, &data, 0))) {
2227     sq_throwerror(vm, _SC("'electrify' called without instance"));
2228     return SQ_ERROR;
2229   }
2230   Scripting::Thunderstorm* _this = reinterpret_cast<Scripting::Thunderstorm*> (data);
2231   
2232   try {
2233     _this->electrify();
2234   
2235     return 0;
2236   
2237   } catch(std::exception& e) {
2238     sq_throwerror(vm, e.what());
2239     return SQ_ERROR;
2240   } catch(...) {
2241     sq_throwerror(vm, _SC("Unexpected exception while executing function 'electrify'"));
2242     return SQ_ERROR;
2243   }
2244   
2245 }
2246
2247 static SQInteger display_wrapper(HSQUIRRELVM vm)
2248 {
2249   return Scripting::display(vm);
2250 }
2251
2252 static SQInteger print_stacktrace_wrapper(HSQUIRRELVM vm)
2253 {
2254   HSQUIRRELVM arg0 = vm;
2255   
2256   try {
2257     Scripting::print_stacktrace(arg0);
2258   
2259     return 0;
2260   
2261   } catch(std::exception& e) {
2262     sq_throwerror(vm, e.what());
2263     return SQ_ERROR;
2264   } catch(...) {
2265     sq_throwerror(vm, _SC("Unexpected exception while executing function 'print_stacktrace'"));
2266     return SQ_ERROR;
2267   }
2268   
2269 }
2270
2271 static SQInteger get_current_thread_wrapper(HSQUIRRELVM vm)
2272 {
2273   return Scripting::get_current_thread(vm);
2274 }
2275
2276 static SQInteger display_text_file_wrapper(HSQUIRRELVM vm)
2277 {
2278   const SQChar* arg0;
2279   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2280     sq_throwerror(vm, _SC("Argument 1 not a string"));
2281     return SQ_ERROR;
2282   }
2283   
2284   try {
2285     Scripting::display_text_file(arg0);
2286   
2287     return 0;
2288   
2289   } catch(std::exception& e) {
2290     sq_throwerror(vm, e.what());
2291     return SQ_ERROR;
2292   } catch(...) {
2293     sq_throwerror(vm, _SC("Unexpected exception while executing function 'display_text_file'"));
2294     return SQ_ERROR;
2295   }
2296   
2297 }
2298
2299 static SQInteger load_worldmap_wrapper(HSQUIRRELVM vm)
2300 {
2301   const SQChar* arg0;
2302   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2303     sq_throwerror(vm, _SC("Argument 1 not a string"));
2304     return SQ_ERROR;
2305   }
2306   
2307   try {
2308     Scripting::load_worldmap(arg0);
2309   
2310     return 0;
2311   
2312   } catch(std::exception& e) {
2313     sq_throwerror(vm, e.what());
2314     return SQ_ERROR;
2315   } catch(...) {
2316     sq_throwerror(vm, _SC("Unexpected exception while executing function 'load_worldmap'"));
2317     return SQ_ERROR;
2318   }
2319   
2320 }
2321
2322 static SQInteger load_level_wrapper(HSQUIRRELVM vm)
2323 {
2324   const SQChar* arg0;
2325   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2326     sq_throwerror(vm, _SC("Argument 1 not a string"));
2327     return SQ_ERROR;
2328   }
2329   
2330   try {
2331     Scripting::load_level(arg0);
2332   
2333     return 0;
2334   
2335   } catch(std::exception& e) {
2336     sq_throwerror(vm, e.what());
2337     return SQ_ERROR;
2338   } catch(...) {
2339     sq_throwerror(vm, _SC("Unexpected exception while executing function 'load_level'"));
2340     return SQ_ERROR;
2341   }
2342   
2343 }
2344
2345 static SQInteger wait_wrapper(HSQUIRRELVM vm)
2346 {
2347   HSQUIRRELVM arg0 = vm;
2348   SQFloat arg1;
2349   if(SQ_FAILED(sq_getfloat(vm, 2, &arg1))) {
2350     sq_throwerror(vm, _SC("Argument 1 not a float"));
2351     return SQ_ERROR;
2352   }
2353   
2354   try {
2355     Scripting::wait(arg0, static_cast<float> (arg1));
2356   
2357     return sq_suspendvm(vm);
2358   
2359   } catch(std::exception& e) {
2360     sq_throwerror(vm, e.what());
2361     return SQ_ERROR;
2362   } catch(...) {
2363     sq_throwerror(vm, _SC("Unexpected exception while executing function 'wait'"));
2364     return SQ_ERROR;
2365   }
2366   
2367 }
2368
2369 static SQInteger wait_for_screenswitch_wrapper(HSQUIRRELVM vm)
2370 {
2371   HSQUIRRELVM arg0 = vm;
2372   
2373   try {
2374     Scripting::wait_for_screenswitch(arg0);
2375   
2376     return sq_suspendvm(vm);
2377   
2378   } catch(std::exception& e) {
2379     sq_throwerror(vm, e.what());
2380     return SQ_ERROR;
2381   } catch(...) {
2382     sq_throwerror(vm, _SC("Unexpected exception while executing function 'wait_for_screenswitch'"));
2383     return SQ_ERROR;
2384   }
2385   
2386 }
2387
2388 static SQInteger exit_screen_wrapper(HSQUIRRELVM vm)
2389 {
2390   (void) vm;
2391   
2392   try {
2393     Scripting::exit_screen();
2394   
2395     return 0;
2396   
2397   } catch(std::exception& e) {
2398     sq_throwerror(vm, e.what());
2399     return SQ_ERROR;
2400   } catch(...) {
2401     sq_throwerror(vm, _SC("Unexpected exception while executing function 'exit_screen'"));
2402     return SQ_ERROR;
2403   }
2404   
2405 }
2406
2407 static SQInteger fadeout_screen_wrapper(HSQUIRRELVM vm)
2408 {
2409   SQFloat arg0;
2410   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
2411     sq_throwerror(vm, _SC("Argument 1 not a float"));
2412     return SQ_ERROR;
2413   }
2414   
2415   try {
2416     Scripting::fadeout_screen(static_cast<float> (arg0));
2417   
2418     return 0;
2419   
2420   } catch(std::exception& e) {
2421     sq_throwerror(vm, e.what());
2422     return SQ_ERROR;
2423   } catch(...) {
2424     sq_throwerror(vm, _SC("Unexpected exception while executing function 'fadeout_screen'"));
2425     return SQ_ERROR;
2426   }
2427   
2428 }
2429
2430 static SQInteger shrink_screen_wrapper(HSQUIRRELVM vm)
2431 {
2432   SQFloat arg0;
2433   if(SQ_FAILED(sq_getfloat(vm, 2, &arg0))) {
2434     sq_throwerror(vm, _SC("Argument 1 not a float"));
2435     return SQ_ERROR;
2436   }
2437   SQFloat arg1;
2438   if(SQ_FAILED(sq_getfloat(vm, 3, &arg1))) {
2439     sq_throwerror(vm, _SC("Argument 2 not a float"));
2440     return SQ_ERROR;
2441   }
2442   SQFloat arg2;
2443   if(SQ_FAILED(sq_getfloat(vm, 4, &arg2))) {
2444     sq_throwerror(vm, _SC("Argument 3 not a float"));
2445     return SQ_ERROR;
2446   }
2447   
2448   try {
2449     Scripting::shrink_screen(static_cast<float> (arg0), static_cast<float> (arg1), static_cast<float> (arg2));
2450   
2451     return 0;
2452   
2453   } catch(std::exception& e) {
2454     sq_throwerror(vm, e.what());
2455     return SQ_ERROR;
2456   } catch(...) {
2457     sq_throwerror(vm, _SC("Unexpected exception while executing function 'shrink_screen'"));
2458     return SQ_ERROR;
2459   }
2460   
2461 }
2462
2463 static SQInteger translate_wrapper(HSQUIRRELVM vm)
2464 {
2465   const SQChar* arg0;
2466   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2467     sq_throwerror(vm, _SC("Argument 1 not a string"));
2468     return SQ_ERROR;
2469   }
2470   
2471   try {
2472     std::string return_value = Scripting::translate(arg0);
2473   
2474     sq_pushstring(vm, return_value.c_str(), return_value.size());
2475     return 1;
2476   
2477   } catch(std::exception& e) {
2478     sq_throwerror(vm, e.what());
2479     return SQ_ERROR;
2480   } catch(...) {
2481     sq_throwerror(vm, _SC("Unexpected exception while executing function 'translate'"));
2482     return SQ_ERROR;
2483   }
2484   
2485 }
2486
2487 static SQInteger import_wrapper(HSQUIRRELVM vm)
2488 {
2489   HSQUIRRELVM arg0 = vm;
2490   const SQChar* arg1;
2491   if(SQ_FAILED(sq_getstring(vm, 2, &arg1))) {
2492     sq_throwerror(vm, _SC("Argument 1 not a string"));
2493     return SQ_ERROR;
2494   }
2495   
2496   try {
2497     Scripting::import(arg0, arg1);
2498   
2499     return 0;
2500   
2501   } catch(std::exception& e) {
2502     sq_throwerror(vm, e.what());
2503     return SQ_ERROR;
2504   } catch(...) {
2505     sq_throwerror(vm, _SC("Unexpected exception while executing function 'import'"));
2506     return SQ_ERROR;
2507   }
2508   
2509 }
2510
2511 static SQInteger save_state_wrapper(HSQUIRRELVM vm)
2512 {
2513   (void) vm;
2514   
2515   try {
2516     Scripting::save_state();
2517   
2518     return 0;
2519   
2520   } catch(std::exception& e) {
2521     sq_throwerror(vm, e.what());
2522     return SQ_ERROR;
2523   } catch(...) {
2524     sq_throwerror(vm, _SC("Unexpected exception while executing function 'save_state'"));
2525     return SQ_ERROR;
2526   }
2527   
2528 }
2529
2530 static SQInteger debug_collrects_wrapper(HSQUIRRELVM vm)
2531 {
2532   SQBool arg0;
2533   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
2534     sq_throwerror(vm, _SC("Argument 1 not a bool"));
2535     return SQ_ERROR;
2536   }
2537   
2538   try {
2539     Scripting::debug_collrects(arg0 == SQTrue);
2540   
2541     return 0;
2542   
2543   } catch(std::exception& e) {
2544     sq_throwerror(vm, e.what());
2545     return SQ_ERROR;
2546   } catch(...) {
2547     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_collrects'"));
2548     return SQ_ERROR;
2549   }
2550   
2551 }
2552
2553 static SQInteger debug_show_fps_wrapper(HSQUIRRELVM vm)
2554 {
2555   SQBool arg0;
2556   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
2557     sq_throwerror(vm, _SC("Argument 1 not a bool"));
2558     return SQ_ERROR;
2559   }
2560   
2561   try {
2562     Scripting::debug_show_fps(arg0 == SQTrue);
2563   
2564     return 0;
2565   
2566   } catch(std::exception& e) {
2567     sq_throwerror(vm, e.what());
2568     return SQ_ERROR;
2569   } catch(...) {
2570     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_show_fps'"));
2571     return SQ_ERROR;
2572   }
2573   
2574 }
2575
2576 static SQInteger debug_draw_solids_only_wrapper(HSQUIRRELVM vm)
2577 {
2578   SQBool arg0;
2579   if(SQ_FAILED(sq_getbool(vm, 2, &arg0))) {
2580     sq_throwerror(vm, _SC("Argument 1 not a bool"));
2581     return SQ_ERROR;
2582   }
2583   
2584   try {
2585     Scripting::debug_draw_solids_only(arg0 == SQTrue);
2586   
2587     return 0;
2588   
2589   } catch(std::exception& e) {
2590     sq_throwerror(vm, e.what());
2591     return SQ_ERROR;
2592   } catch(...) {
2593     sq_throwerror(vm, _SC("Unexpected exception while executing function 'debug_draw_solids_only'"));
2594     return SQ_ERROR;
2595   }
2596   
2597 }
2598
2599 static SQInteger play_music_wrapper(HSQUIRRELVM vm)
2600 {
2601   const SQChar* arg0;
2602   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2603     sq_throwerror(vm, _SC("Argument 1 not a string"));
2604     return SQ_ERROR;
2605   }
2606   
2607   try {
2608     Scripting::play_music(arg0);
2609   
2610     return 0;
2611   
2612   } catch(std::exception& e) {
2613     sq_throwerror(vm, e.what());
2614     return SQ_ERROR;
2615   } catch(...) {
2616     sq_throwerror(vm, _SC("Unexpected exception while executing function 'play_music'"));
2617     return SQ_ERROR;
2618   }
2619   
2620 }
2621
2622 static SQInteger play_sound_wrapper(HSQUIRRELVM vm)
2623 {
2624   const SQChar* arg0;
2625   if(SQ_FAILED(sq_getstring(vm, 2, &arg0))) {
2626     sq_throwerror(vm, _SC("Argument 1 not a string"));
2627     return SQ_ERROR;
2628   }
2629   
2630   try {
2631     Scripting::play_sound(arg0);
2632   
2633     return 0;
2634   
2635   } catch(std::exception& e) {
2636     sq_throwerror(vm, e.what());
2637     return SQ_ERROR;
2638   } catch(...) {
2639     sq_throwerror(vm, _SC("Unexpected exception while executing function 'play_sound'"));
2640     return SQ_ERROR;
2641   }
2642   
2643 }
2644
2645 static SQInteger grease_wrapper(HSQUIRRELVM vm)
2646 {
2647   (void) vm;
2648   
2649   try {
2650     Scripting::grease();
2651   
2652     return 0;
2653   
2654   } catch(std::exception& e) {
2655     sq_throwerror(vm, e.what());
2656     return SQ_ERROR;
2657   } catch(...) {
2658     sq_throwerror(vm, _SC("Unexpected exception while executing function 'grease'"));
2659     return SQ_ERROR;
2660   }
2661   
2662 }
2663
2664 static SQInteger invincible_wrapper(HSQUIRRELVM vm)
2665 {
2666   (void) vm;
2667   
2668   try {
2669     Scripting::invincible();
2670   
2671     return 0;
2672   
2673   } catch(std::exception& e) {
2674     sq_throwerror(vm, e.what());
2675     return SQ_ERROR;
2676   } catch(...) {
2677     sq_throwerror(vm, _SC("Unexpected exception while executing function 'invincible'"));
2678     return SQ_ERROR;
2679   }
2680   
2681 }
2682
2683 static SQInteger ghost_wrapper(HSQUIRRELVM vm)
2684 {
2685   (void) vm;
2686   
2687   try {
2688     Scripting::ghost();
2689   
2690     return 0;
2691   
2692   } catch(std::exception& e) {
2693     sq_throwerror(vm, e.what());
2694     return SQ_ERROR;
2695   } catch(...) {
2696     sq_throwerror(vm, _SC("Unexpected exception while executing function 'ghost'"));
2697     return SQ_ERROR;
2698   }
2699   
2700 }
2701
2702 static SQInteger mortal_wrapper(HSQUIRRELVM vm)
2703 {
2704   (void) vm;
2705   
2706   try {
2707     Scripting::mortal();
2708   
2709     return 0;
2710   
2711   } catch(std::exception& e) {
2712     sq_throwerror(vm, e.what());
2713     return SQ_ERROR;
2714   } catch(...) {
2715     sq_throwerror(vm, _SC("Unexpected exception while executing function 'mortal'"));
2716     return SQ_ERROR;
2717   }
2718   
2719 }
2720
2721 static SQInteger restart_wrapper(HSQUIRRELVM vm)
2722 {
2723   (void) vm;
2724   
2725   try {
2726     Scripting::restart();
2727   
2728     return 0;
2729   
2730   } catch(std::exception& e) {
2731     sq_throwerror(vm, e.what());
2732     return SQ_ERROR;
2733   } catch(...) {
2734     sq_throwerror(vm, _SC("Unexpected exception while executing function 'restart'"));
2735     return SQ_ERROR;
2736   }
2737   
2738 }
2739
2740 static SQInteger whereami_wrapper(HSQUIRRELVM vm)
2741 {
2742   (void) vm;
2743   
2744   try {
2745     Scripting::whereami();
2746   
2747     return 0;
2748   
2749   } catch(std::exception& e) {
2750     sq_throwerror(vm, e.what());
2751     return SQ_ERROR;
2752   } catch(...) {
2753     sq_throwerror(vm, _SC("Unexpected exception while executing function 'whereami'"));
2754     return SQ_ERROR;
2755   }
2756   
2757 }
2758
2759 static SQInteger gotoend_wrapper(HSQUIRRELVM vm)
2760 {
2761   (void) vm;
2762   
2763   try {
2764     Scripting::gotoend();
2765   
2766     return 0;
2767   
2768   } catch(std::exception& e) {
2769     sq_throwerror(vm, e.what());
2770     return SQ_ERROR;
2771   } catch(...) {
2772     sq_throwerror(vm, _SC("Unexpected exception while executing function 'gotoend'"));
2773     return SQ_ERROR;
2774   }
2775   
2776 }
2777
2778 static SQInteger camera_wrapper(HSQUIRRELVM vm)
2779 {
2780   (void) vm;
2781   
2782   try {
2783     Scripting::camera();
2784   
2785     return 0;
2786   
2787   } catch(std::exception& e) {
2788     sq_throwerror(vm, e.what());
2789     return SQ_ERROR;
2790   } catch(...) {
2791     sq_throwerror(vm, _SC("Unexpected exception while executing function 'camera'"));
2792     return SQ_ERROR;
2793   }
2794   
2795 }
2796
2797 static SQInteger quit_wrapper(HSQUIRRELVM vm)
2798 {
2799   (void) vm;
2800   
2801   try {
2802     Scripting::quit();
2803   
2804     return 0;
2805   
2806   } catch(std::exception& e) {
2807     sq_throwerror(vm, e.what());
2808     return SQ_ERROR;
2809   } catch(...) {
2810     sq_throwerror(vm, _SC("Unexpected exception while executing function 'quit'"));
2811     return SQ_ERROR;
2812   }
2813   
2814 }
2815
2816 static SQInteger rand_wrapper(HSQUIRRELVM vm)
2817 {
2818   
2819   try {
2820     int return_value = Scripting::rand();
2821   
2822     sq_pushinteger(vm, return_value);
2823     return 1;
2824   
2825   } catch(std::exception& e) {
2826     sq_throwerror(vm, e.what());
2827     return SQ_ERROR;
2828   } catch(...) {
2829     sq_throwerror(vm, _SC("Unexpected exception while executing function 'rand'"));
2830     return SQ_ERROR;
2831   }
2832   
2833 }
2834
2835 } // end of namespace Wrapper
2836
2837 void create_squirrel_instance(HSQUIRRELVM v, Scripting::DisplayEffect* object, bool setup_releasehook)
2838 {
2839   using namespace Wrapper;
2840
2841   sq_pushroottable(v);
2842   sq_pushstring(v, "DisplayEffect", -1);
2843   if(SQ_FAILED(sq_get(v, -2))) {
2844     std::ostringstream msg;
2845     msg << "Couldn't resolved squirrel type 'DisplayEffect'";
2846     throw SquirrelError(v, msg.str());
2847   }
2848
2849   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2850     std::ostringstream msg;
2851     msg << "Couldn't setup squirrel instance for object of type 'DisplayEffect'";
2852     throw SquirrelError(v, msg.str());
2853   }
2854   sq_remove(v, -2); // remove object name
2855
2856   if(setup_releasehook) {
2857     sq_setreleasehook(v, -1, DisplayEffect_release_hook);
2858   }
2859
2860   sq_remove(v, -2); // remove root table
2861 }
2862
2863 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Camera* object, bool setup_releasehook)
2864 {
2865   using namespace Wrapper;
2866
2867   sq_pushroottable(v);
2868   sq_pushstring(v, "Camera", -1);
2869   if(SQ_FAILED(sq_get(v, -2))) {
2870     std::ostringstream msg;
2871     msg << "Couldn't resolved squirrel type 'Camera'";
2872     throw SquirrelError(v, msg.str());
2873   }
2874
2875   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2876     std::ostringstream msg;
2877     msg << "Couldn't setup squirrel instance for object of type 'Camera'";
2878     throw SquirrelError(v, msg.str());
2879   }
2880   sq_remove(v, -2); // remove object name
2881
2882   if(setup_releasehook) {
2883     sq_setreleasehook(v, -1, Camera_release_hook);
2884   }
2885
2886   sq_remove(v, -2); // remove root table
2887 }
2888
2889 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Level* object, bool setup_releasehook)
2890 {
2891   using namespace Wrapper;
2892
2893   sq_pushroottable(v);
2894   sq_pushstring(v, "Level", -1);
2895   if(SQ_FAILED(sq_get(v, -2))) {
2896     std::ostringstream msg;
2897     msg << "Couldn't resolved squirrel type 'Level'";
2898     throw SquirrelError(v, msg.str());
2899   }
2900
2901   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2902     std::ostringstream msg;
2903     msg << "Couldn't setup squirrel instance for object of type 'Level'";
2904     throw SquirrelError(v, msg.str());
2905   }
2906   sq_remove(v, -2); // remove object name
2907
2908   if(setup_releasehook) {
2909     sq_setreleasehook(v, -1, Level_release_hook);
2910   }
2911
2912   sq_remove(v, -2); // remove root table
2913 }
2914
2915 void create_squirrel_instance(HSQUIRRELVM v, Scripting::ScriptedObject* object, bool setup_releasehook)
2916 {
2917   using namespace Wrapper;
2918
2919   sq_pushroottable(v);
2920   sq_pushstring(v, "ScriptedObject", -1);
2921   if(SQ_FAILED(sq_get(v, -2))) {
2922     std::ostringstream msg;
2923     msg << "Couldn't resolved squirrel type 'ScriptedObject'";
2924     throw SquirrelError(v, msg.str());
2925   }
2926
2927   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2928     std::ostringstream msg;
2929     msg << "Couldn't setup squirrel instance for object of type 'ScriptedObject'";
2930     throw SquirrelError(v, msg.str());
2931   }
2932   sq_remove(v, -2); // remove object name
2933
2934   if(setup_releasehook) {
2935     sq_setreleasehook(v, -1, ScriptedObject_release_hook);
2936   }
2937
2938   sq_remove(v, -2); // remove root table
2939 }
2940
2941 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Text* object, bool setup_releasehook)
2942 {
2943   using namespace Wrapper;
2944
2945   sq_pushroottable(v);
2946   sq_pushstring(v, "Text", -1);
2947   if(SQ_FAILED(sq_get(v, -2))) {
2948     std::ostringstream msg;
2949     msg << "Couldn't resolved squirrel type 'Text'";
2950     throw SquirrelError(v, msg.str());
2951   }
2952
2953   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2954     std::ostringstream msg;
2955     msg << "Couldn't setup squirrel instance for object of type 'Text'";
2956     throw SquirrelError(v, msg.str());
2957   }
2958   sq_remove(v, -2); // remove object name
2959
2960   if(setup_releasehook) {
2961     sq_setreleasehook(v, -1, Text_release_hook);
2962   }
2963
2964   sq_remove(v, -2); // remove root table
2965 }
2966
2967 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Player* object, bool setup_releasehook)
2968 {
2969   using namespace Wrapper;
2970
2971   sq_pushroottable(v);
2972   sq_pushstring(v, "Player", -1);
2973   if(SQ_FAILED(sq_get(v, -2))) {
2974     std::ostringstream msg;
2975     msg << "Couldn't resolved squirrel type 'Player'";
2976     throw SquirrelError(v, msg.str());
2977   }
2978
2979   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
2980     std::ostringstream msg;
2981     msg << "Couldn't setup squirrel instance for object of type 'Player'";
2982     throw SquirrelError(v, msg.str());
2983   }
2984   sq_remove(v, -2); // remove object name
2985
2986   if(setup_releasehook) {
2987     sq_setreleasehook(v, -1, Player_release_hook);
2988   }
2989
2990   sq_remove(v, -2); // remove root table
2991 }
2992
2993 void create_squirrel_instance(HSQUIRRELVM v, Scripting::FloatingImage* object, bool setup_releasehook)
2994 {
2995   using namespace Wrapper;
2996
2997   sq_pushroottable(v);
2998   sq_pushstring(v, "FloatingImage", -1);
2999   if(SQ_FAILED(sq_get(v, -2))) {
3000     std::ostringstream msg;
3001     msg << "Couldn't resolved squirrel type 'FloatingImage'";
3002     throw SquirrelError(v, msg.str());
3003   }
3004
3005   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3006     std::ostringstream msg;
3007     msg << "Couldn't setup squirrel instance for object of type 'FloatingImage'";
3008     throw SquirrelError(v, msg.str());
3009   }
3010   sq_remove(v, -2); // remove object name
3011
3012   if(setup_releasehook) {
3013     sq_setreleasehook(v, -1, FloatingImage_release_hook);
3014   }
3015
3016   sq_remove(v, -2); // remove root table
3017 }
3018
3019 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Platform* object, bool setup_releasehook)
3020 {
3021   using namespace Wrapper;
3022
3023   sq_pushroottable(v);
3024   sq_pushstring(v, "Platform", -1);
3025   if(SQ_FAILED(sq_get(v, -2))) {
3026     std::ostringstream msg;
3027     msg << "Couldn't resolved squirrel type 'Platform'";
3028     throw SquirrelError(v, msg.str());
3029   }
3030
3031   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3032     std::ostringstream msg;
3033     msg << "Couldn't setup squirrel instance for object of type 'Platform'";
3034     throw SquirrelError(v, msg.str());
3035   }
3036   sq_remove(v, -2); // remove object name
3037
3038   if(setup_releasehook) {
3039     sq_setreleasehook(v, -1, Platform_release_hook);
3040   }
3041
3042   sq_remove(v, -2); // remove root table
3043 }
3044
3045 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Candle* object, bool setup_releasehook)
3046 {
3047   using namespace Wrapper;
3048
3049   sq_pushroottable(v);
3050   sq_pushstring(v, "Candle", -1);
3051   if(SQ_FAILED(sq_get(v, -2))) {
3052     std::ostringstream msg;
3053     msg << "Couldn't resolved squirrel type 'Candle'";
3054     throw SquirrelError(v, msg.str());
3055   }
3056
3057   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3058     std::ostringstream msg;
3059     msg << "Couldn't setup squirrel instance for object of type 'Candle'";
3060     throw SquirrelError(v, msg.str());
3061   }
3062   sq_remove(v, -2); // remove object name
3063
3064   if(setup_releasehook) {
3065     sq_setreleasehook(v, -1, Candle_release_hook);
3066   }
3067
3068   sq_remove(v, -2); // remove root table
3069 }
3070
3071 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Wind* object, bool setup_releasehook)
3072 {
3073   using namespace Wrapper;
3074
3075   sq_pushroottable(v);
3076   sq_pushstring(v, "Wind", -1);
3077   if(SQ_FAILED(sq_get(v, -2))) {
3078     std::ostringstream msg;
3079     msg << "Couldn't resolved squirrel type 'Wind'";
3080     throw SquirrelError(v, msg.str());
3081   }
3082
3083   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3084     std::ostringstream msg;
3085     msg << "Couldn't setup squirrel instance for object of type 'Wind'";
3086     throw SquirrelError(v, msg.str());
3087   }
3088   sq_remove(v, -2); // remove object name
3089
3090   if(setup_releasehook) {
3091     sq_setreleasehook(v, -1, Wind_release_hook);
3092   }
3093
3094   sq_remove(v, -2); // remove root table
3095 }
3096
3097 void create_squirrel_instance(HSQUIRRELVM v, Scripting::AmbientSound* object, bool setup_releasehook)
3098 {
3099   using namespace Wrapper;
3100
3101   sq_pushroottable(v);
3102   sq_pushstring(v, "AmbientSound", -1);
3103   if(SQ_FAILED(sq_get(v, -2))) {
3104     std::ostringstream msg;
3105     msg << "Couldn't resolved squirrel type 'AmbientSound'";
3106     throw SquirrelError(v, msg.str());
3107   }
3108
3109   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3110     std::ostringstream msg;
3111     msg << "Couldn't setup squirrel instance for object of type 'AmbientSound'";
3112     throw SquirrelError(v, msg.str());
3113   }
3114   sq_remove(v, -2); // remove object name
3115
3116   if(setup_releasehook) {
3117     sq_setreleasehook(v, -1, AmbientSound_release_hook);
3118   }
3119
3120   sq_remove(v, -2); // remove root table
3121 }
3122
3123 void create_squirrel_instance(HSQUIRRELVM v, Scripting::Thunderstorm* object, bool setup_releasehook)
3124 {
3125   using namespace Wrapper;
3126
3127   sq_pushroottable(v);
3128   sq_pushstring(v, "Thunderstorm", -1);
3129   if(SQ_FAILED(sq_get(v, -2))) {
3130     std::ostringstream msg;
3131     msg << "Couldn't resolved squirrel type 'Thunderstorm'";
3132     throw SquirrelError(v, msg.str());
3133   }
3134
3135   if(SQ_FAILED(sq_createinstance(v, -1)) || SQ_FAILED(sq_setinstanceup(v, -1, object))) {
3136     std::ostringstream msg;
3137     msg << "Couldn't setup squirrel instance for object of type 'Thunderstorm'";
3138     throw SquirrelError(v, msg.str());
3139   }
3140   sq_remove(v, -2); // remove object name
3141
3142   if(setup_releasehook) {
3143     sq_setreleasehook(v, -1, Thunderstorm_release_hook);
3144   }
3145
3146   sq_remove(v, -2); // remove root table
3147 }
3148
3149 void register_supertux_wrapper(HSQUIRRELVM v)
3150 {
3151   using namespace Wrapper;
3152
3153   sq_pushstring(v, "ANCHOR_TOP", -1);
3154   sq_pushinteger(v, 16);
3155   if(SQ_FAILED(sq_createslot(v, -3))) {
3156     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP'");
3157   }
3158
3159   sq_pushstring(v, "ANCHOR_BOTTOM", -1);
3160   sq_pushinteger(v, 32);
3161   if(SQ_FAILED(sq_createslot(v, -3))) {
3162     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM'");
3163   }
3164
3165   sq_pushstring(v, "ANCHOR_LEFT", -1);
3166   sq_pushinteger(v, 1);
3167   if(SQ_FAILED(sq_createslot(v, -3))) {
3168     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_LEFT'");
3169   }
3170
3171   sq_pushstring(v, "ANCHOR_RIGHT", -1);
3172   sq_pushinteger(v, 2);
3173   if(SQ_FAILED(sq_createslot(v, -3))) {
3174     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_RIGHT'");
3175   }
3176
3177   sq_pushstring(v, "ANCHOR_MIDDLE", -1);
3178   sq_pushinteger(v, 0);
3179   if(SQ_FAILED(sq_createslot(v, -3))) {
3180     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_MIDDLE'");
3181   }
3182
3183   sq_pushstring(v, "ANCHOR_TOP_LEFT", -1);
3184   sq_pushinteger(v, 17);
3185   if(SQ_FAILED(sq_createslot(v, -3))) {
3186     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP_LEFT'");
3187   }
3188
3189   sq_pushstring(v, "ANCHOR_TOP_RIGHT", -1);
3190   sq_pushinteger(v, 18);
3191   if(SQ_FAILED(sq_createslot(v, -3))) {
3192     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_TOP_RIGHT'");
3193   }
3194
3195   sq_pushstring(v, "ANCHOR_BOTTOM_LEFT", -1);
3196   sq_pushinteger(v, 33);
3197   if(SQ_FAILED(sq_createslot(v, -3))) {
3198     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM_LEFT'");
3199   }
3200
3201   sq_pushstring(v, "ANCHOR_BOTTOM_RIGHT", -1);
3202   sq_pushinteger(v, 34);
3203   if(SQ_FAILED(sq_createslot(v, -3))) {
3204     throw SquirrelError(v, "Couldn't register constant 'ANCHOR_BOTTOM_RIGHT'");
3205   }
3206
3207   sq_pushstring(v, "display", -1);
3208   sq_newclosure(v, &display_wrapper, 0);
3209   if(SQ_FAILED(sq_createslot(v, -3))) {
3210     throw SquirrelError(v, "Couldn't register function 'display'");
3211   }
3212
3213   sq_pushstring(v, "print_stacktrace", -1);
3214   sq_newclosure(v, &print_stacktrace_wrapper, 0);
3215   if(SQ_FAILED(sq_createslot(v, -3))) {
3216     throw SquirrelError(v, "Couldn't register function 'print_stacktrace'");
3217   }
3218
3219   sq_pushstring(v, "get_current_thread", -1);
3220   sq_newclosure(v, &get_current_thread_wrapper, 0);
3221   if(SQ_FAILED(sq_createslot(v, -3))) {
3222     throw SquirrelError(v, "Couldn't register function 'get_current_thread'");
3223   }
3224
3225   sq_pushstring(v, "display_text_file", -1);
3226   sq_newclosure(v, &display_text_file_wrapper, 0);
3227   if(SQ_FAILED(sq_createslot(v, -3))) {
3228     throw SquirrelError(v, "Couldn't register function 'display_text_file'");
3229   }
3230
3231   sq_pushstring(v, "load_worldmap", -1);
3232   sq_newclosure(v, &load_worldmap_wrapper, 0);
3233   if(SQ_FAILED(sq_createslot(v, -3))) {
3234     throw SquirrelError(v, "Couldn't register function 'load_worldmap'");
3235   }
3236
3237   sq_pushstring(v, "load_level", -1);
3238   sq_newclosure(v, &load_level_wrapper, 0);
3239   if(SQ_FAILED(sq_createslot(v, -3))) {
3240     throw SquirrelError(v, "Couldn't register function 'load_level'");
3241   }
3242
3243   sq_pushstring(v, "wait", -1);
3244   sq_newclosure(v, &wait_wrapper, 0);
3245   if(SQ_FAILED(sq_createslot(v, -3))) {
3246     throw SquirrelError(v, "Couldn't register function 'wait'");
3247   }
3248
3249   sq_pushstring(v, "wait_for_screenswitch", -1);
3250   sq_newclosure(v, &wait_for_screenswitch_wrapper, 0);
3251   if(SQ_FAILED(sq_createslot(v, -3))) {
3252     throw SquirrelError(v, "Couldn't register function 'wait_for_screenswitch'");
3253   }
3254
3255   sq_pushstring(v, "exit_screen", -1);
3256   sq_newclosure(v, &exit_screen_wrapper, 0);
3257   if(SQ_FAILED(sq_createslot(v, -3))) {
3258     throw SquirrelError(v, "Couldn't register function 'exit_screen'");
3259   }
3260
3261   sq_pushstring(v, "fadeout_screen", -1);
3262   sq_newclosure(v, &fadeout_screen_wrapper, 0);
3263   if(SQ_FAILED(sq_createslot(v, -3))) {
3264     throw SquirrelError(v, "Couldn't register function 'fadeout_screen'");
3265   }
3266
3267   sq_pushstring(v, "shrink_screen", -1);
3268   sq_newclosure(v, &shrink_screen_wrapper, 0);
3269   if(SQ_FAILED(sq_createslot(v, -3))) {
3270     throw SquirrelError(v, "Couldn't register function 'shrink_screen'");
3271   }
3272
3273   sq_pushstring(v, "translate", -1);
3274   sq_newclosure(v, &translate_wrapper, 0);
3275   if(SQ_FAILED(sq_createslot(v, -3))) {
3276     throw SquirrelError(v, "Couldn't register function 'translate'");
3277   }
3278
3279   sq_pushstring(v, "import", -1);
3280   sq_newclosure(v, &import_wrapper, 0);
3281   if(SQ_FAILED(sq_createslot(v, -3))) {
3282     throw SquirrelError(v, "Couldn't register function 'import'");
3283   }
3284
3285   sq_pushstring(v, "save_state", -1);
3286   sq_newclosure(v, &save_state_wrapper, 0);
3287   if(SQ_FAILED(sq_createslot(v, -3))) {
3288     throw SquirrelError(v, "Couldn't register function 'save_state'");
3289   }
3290
3291   sq_pushstring(v, "debug_collrects", -1);
3292   sq_newclosure(v, &debug_collrects_wrapper, 0);
3293   if(SQ_FAILED(sq_createslot(v, -3))) {
3294     throw SquirrelError(v, "Couldn't register function 'debug_collrects'");
3295   }
3296
3297   sq_pushstring(v, "debug_show_fps", -1);
3298   sq_newclosure(v, &debug_show_fps_wrapper, 0);
3299   if(SQ_FAILED(sq_createslot(v, -3))) {
3300     throw SquirrelError(v, "Couldn't register function 'debug_show_fps'");
3301   }
3302
3303   sq_pushstring(v, "debug_draw_solids_only", -1);
3304   sq_newclosure(v, &debug_draw_solids_only_wrapper, 0);
3305   if(SQ_FAILED(sq_createslot(v, -3))) {
3306     throw SquirrelError(v, "Couldn't register function 'debug_draw_solids_only'");
3307   }
3308
3309   sq_pushstring(v, "play_music", -1);
3310   sq_newclosure(v, &play_music_wrapper, 0);
3311   if(SQ_FAILED(sq_createslot(v, -3))) {
3312     throw SquirrelError(v, "Couldn't register function 'play_music'");
3313   }
3314
3315   sq_pushstring(v, "play_sound", -1);
3316   sq_newclosure(v, &play_sound_wrapper, 0);
3317   if(SQ_FAILED(sq_createslot(v, -3))) {
3318     throw SquirrelError(v, "Couldn't register function 'play_sound'");
3319   }
3320
3321   sq_pushstring(v, "grease", -1);
3322   sq_newclosure(v, &grease_wrapper, 0);
3323   if(SQ_FAILED(sq_createslot(v, -3))) {
3324     throw SquirrelError(v, "Couldn't register function 'grease'");
3325   }
3326
3327   sq_pushstring(v, "invincible", -1);
3328   sq_newclosure(v, &invincible_wrapper, 0);
3329   if(SQ_FAILED(sq_createslot(v, -3))) {
3330     throw SquirrelError(v, "Couldn't register function 'invincible'");
3331   }
3332
3333   sq_pushstring(v, "ghost", -1);
3334   sq_newclosure(v, &ghost_wrapper, 0);
3335   if(SQ_FAILED(sq_createslot(v, -3))) {
3336     throw SquirrelError(v, "Couldn't register function 'ghost'");
3337   }
3338
3339   sq_pushstring(v, "mortal", -1);
3340   sq_newclosure(v, &mortal_wrapper, 0);
3341   if(SQ_FAILED(sq_createslot(v, -3))) {
3342     throw SquirrelError(v, "Couldn't register function 'mortal'");
3343   }
3344
3345   sq_pushstring(v, "restart", -1);
3346   sq_newclosure(v, &restart_wrapper, 0);
3347   if(SQ_FAILED(sq_createslot(v, -3))) {
3348     throw SquirrelError(v, "Couldn't register function 'restart'");
3349   }
3350
3351   sq_pushstring(v, "whereami", -1);
3352   sq_newclosure(v, &whereami_wrapper, 0);
3353   if(SQ_FAILED(sq_createslot(v, -3))) {
3354     throw SquirrelError(v, "Couldn't register function 'whereami'");
3355   }
3356
3357   sq_pushstring(v, "gotoend", -1);
3358   sq_newclosure(v, &gotoend_wrapper, 0);
3359   if(SQ_FAILED(sq_createslot(v, -3))) {
3360     throw SquirrelError(v, "Couldn't register function 'gotoend'");
3361   }
3362
3363   sq_pushstring(v, "camera", -1);
3364   sq_newclosure(v, &camera_wrapper, 0);
3365   if(SQ_FAILED(sq_createslot(v, -3))) {
3366     throw SquirrelError(v, "Couldn't register function 'camera'");
3367   }
3368
3369   sq_pushstring(v, "quit", -1);
3370   sq_newclosure(v, &quit_wrapper, 0);
3371   if(SQ_FAILED(sq_createslot(v, -3))) {
3372     throw SquirrelError(v, "Couldn't register function 'quit'");
3373   }
3374
3375   sq_pushstring(v, "rand", -1);
3376   sq_newclosure(v, &rand_wrapper, 0);
3377   if(SQ_FAILED(sq_createslot(v, -3))) {
3378     throw SquirrelError(v, "Couldn't register function 'rand'");
3379   }
3380
3381   // Register class DisplayEffect
3382   sq_pushstring(v, "DisplayEffect", -1);
3383   if(sq_newclass(v, SQFalse) < 0) {
3384     std::ostringstream msg;
3385     msg << "Couldn't create new class 'DisplayEffect'";
3386     throw SquirrelError(v, msg.str());
3387   }
3388   sq_pushstring(v, "fade_out", -1);
3389   sq_newclosure(v, &DisplayEffect_fade_out_wrapper, 0);
3390   if(SQ_FAILED(sq_createslot(v, -3))) {
3391     throw SquirrelError(v, "Couldn't register function 'fade_out'");
3392   }
3393
3394   sq_pushstring(v, "fade_in", -1);
3395   sq_newclosure(v, &DisplayEffect_fade_in_wrapper, 0);
3396   if(SQ_FAILED(sq_createslot(v, -3))) {
3397     throw SquirrelError(v, "Couldn't register function 'fade_in'");
3398   }
3399
3400   sq_pushstring(v, "set_black", -1);
3401   sq_newclosure(v, &DisplayEffect_set_black_wrapper, 0);
3402   if(SQ_FAILED(sq_createslot(v, -3))) {
3403     throw SquirrelError(v, "Couldn't register function 'set_black'");
3404   }
3405
3406   sq_pushstring(v, "is_black", -1);
3407   sq_newclosure(v, &DisplayEffect_is_black_wrapper, 0);
3408   if(SQ_FAILED(sq_createslot(v, -3))) {
3409     throw SquirrelError(v, "Couldn't register function 'is_black'");
3410   }
3411
3412   sq_pushstring(v, "sixteen_to_nine", -1);
3413   sq_newclosure(v, &DisplayEffect_sixteen_to_nine_wrapper, 0);
3414   if(SQ_FAILED(sq_createslot(v, -3))) {
3415     throw SquirrelError(v, "Couldn't register function 'sixteen_to_nine'");
3416   }
3417
3418   sq_pushstring(v, "four_to_three", -1);
3419   sq_newclosure(v, &DisplayEffect_four_to_three_wrapper, 0);
3420   if(SQ_FAILED(sq_createslot(v, -3))) {
3421     throw SquirrelError(v, "Couldn't register function 'four_to_three'");
3422   }
3423
3424   if(SQ_FAILED(sq_createslot(v, -3))) {
3425     throw SquirrelError(v, "Couldn't register class 'DisplayEffect'");
3426   }
3427
3428   // Register class Camera
3429   sq_pushstring(v, "Camera", -1);
3430   if(sq_newclass(v, SQFalse) < 0) {
3431     std::ostringstream msg;
3432     msg << "Couldn't create new class 'Camera'";
3433     throw SquirrelError(v, msg.str());
3434   }
3435   sq_pushstring(v, "shake", -1);
3436   sq_newclosure(v, &Camera_shake_wrapper, 0);
3437   if(SQ_FAILED(sq_createslot(v, -3))) {
3438     throw SquirrelError(v, "Couldn't register function 'shake'");
3439   }
3440
3441   sq_pushstring(v, "set_pos", -1);
3442   sq_newclosure(v, &Camera_set_pos_wrapper, 0);
3443   if(SQ_FAILED(sq_createslot(v, -3))) {
3444     throw SquirrelError(v, "Couldn't register function 'set_pos'");
3445   }
3446
3447   sq_pushstring(v, "set_mode", -1);
3448   sq_newclosure(v, &Camera_set_mode_wrapper, 0);
3449   if(SQ_FAILED(sq_createslot(v, -3))) {
3450     throw SquirrelError(v, "Couldn't register function 'set_mode'");
3451   }
3452
3453   sq_pushstring(v, "scroll_to", -1);
3454   sq_newclosure(v, &Camera_scroll_to_wrapper, 0);
3455   if(SQ_FAILED(sq_createslot(v, -3))) {
3456     throw SquirrelError(v, "Couldn't register function 'scroll_to'");
3457   }
3458
3459   if(SQ_FAILED(sq_createslot(v, -3))) {
3460     throw SquirrelError(v, "Couldn't register class 'Camera'");
3461   }
3462
3463   // Register class Level
3464   sq_pushstring(v, "Level", -1);
3465   if(sq_newclass(v, SQFalse) < 0) {
3466     std::ostringstream msg;
3467     msg << "Couldn't create new class 'Level'";
3468     throw SquirrelError(v, msg.str());
3469   }
3470   sq_pushstring(v, "finish", -1);
3471   sq_newclosure(v, &Level_finish_wrapper, 0);
3472   if(SQ_FAILED(sq_createslot(v, -3))) {
3473     throw SquirrelError(v, "Couldn't register function 'finish'");
3474   }
3475
3476   sq_pushstring(v, "spawn", -1);
3477   sq_newclosure(v, &Level_spawn_wrapper, 0);
3478   if(SQ_FAILED(sq_createslot(v, -3))) {
3479     throw SquirrelError(v, "Couldn't register function 'spawn'");
3480   }
3481
3482   sq_pushstring(v, "flip_vertically", -1);
3483   sq_newclosure(v, &Level_flip_vertically_wrapper, 0);
3484   if(SQ_FAILED(sq_createslot(v, -3))) {
3485     throw SquirrelError(v, "Couldn't register function 'flip_vertically'");
3486   }
3487
3488   sq_pushstring(v, "toggle_pause", -1);
3489   sq_newclosure(v, &Level_toggle_pause_wrapper, 0);
3490   if(SQ_FAILED(sq_createslot(v, -3))) {
3491     throw SquirrelError(v, "Couldn't register function 'toggle_pause'");
3492   }
3493
3494   if(SQ_FAILED(sq_createslot(v, -3))) {
3495     throw SquirrelError(v, "Couldn't register class 'Level'");
3496   }
3497
3498   // Register class ScriptedObject
3499   sq_pushstring(v, "ScriptedObject", -1);
3500   if(sq_newclass(v, SQFalse) < 0) {
3501     std::ostringstream msg;
3502     msg << "Couldn't create new class 'ScriptedObject'";
3503     throw SquirrelError(v, msg.str());
3504   }
3505   sq_pushstring(v, "set_action", -1);
3506   sq_newclosure(v, &ScriptedObject_set_action_wrapper, 0);
3507   if(SQ_FAILED(sq_createslot(v, -3))) {
3508     throw SquirrelError(v, "Couldn't register function 'set_action'");
3509   }
3510
3511   sq_pushstring(v, "get_action", -1);
3512   sq_newclosure(v, &ScriptedObject_get_action_wrapper, 0);
3513   if(SQ_FAILED(sq_createslot(v, -3))) {
3514     throw SquirrelError(v, "Couldn't register function 'get_action'");
3515   }
3516
3517   sq_pushstring(v, "move", -1);
3518   sq_newclosure(v, &ScriptedObject_move_wrapper, 0);
3519   if(SQ_FAILED(sq_createslot(v, -3))) {
3520     throw SquirrelError(v, "Couldn't register function 'move'");
3521   }
3522
3523   sq_pushstring(v, "set_pos", -1);
3524   sq_newclosure(v, &ScriptedObject_set_pos_wrapper, 0);
3525   if(SQ_FAILED(sq_createslot(v, -3))) {
3526     throw SquirrelError(v, "Couldn't register function 'set_pos'");
3527   }
3528
3529   sq_pushstring(v, "get_pos_x", -1);
3530   sq_newclosure(v, &ScriptedObject_get_pos_x_wrapper, 0);
3531   if(SQ_FAILED(sq_createslot(v, -3))) {
3532     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
3533   }
3534
3535   sq_pushstring(v, "get_pos_y", -1);
3536   sq_newclosure(v, &ScriptedObject_get_pos_y_wrapper, 0);
3537   if(SQ_FAILED(sq_createslot(v, -3))) {
3538     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
3539   }
3540
3541   sq_pushstring(v, "set_velocity", -1);
3542   sq_newclosure(v, &ScriptedObject_set_velocity_wrapper, 0);
3543   if(SQ_FAILED(sq_createslot(v, -3))) {
3544     throw SquirrelError(v, "Couldn't register function 'set_velocity'");
3545   }
3546
3547   sq_pushstring(v, "get_velocity_x", -1);
3548   sq_newclosure(v, &ScriptedObject_get_velocity_x_wrapper, 0);
3549   if(SQ_FAILED(sq_createslot(v, -3))) {
3550     throw SquirrelError(v, "Couldn't register function 'get_velocity_x'");
3551   }
3552
3553   sq_pushstring(v, "get_velocity_y", -1);
3554   sq_newclosure(v, &ScriptedObject_get_velocity_y_wrapper, 0);
3555   if(SQ_FAILED(sq_createslot(v, -3))) {
3556     throw SquirrelError(v, "Couldn't register function 'get_velocity_y'");
3557   }
3558
3559   sq_pushstring(v, "set_visible", -1);
3560   sq_newclosure(v, &ScriptedObject_set_visible_wrapper, 0);
3561   if(SQ_FAILED(sq_createslot(v, -3))) {
3562     throw SquirrelError(v, "Couldn't register function 'set_visible'");
3563   }
3564
3565   sq_pushstring(v, "is_visible", -1);
3566   sq_newclosure(v, &ScriptedObject_is_visible_wrapper, 0);
3567   if(SQ_FAILED(sq_createslot(v, -3))) {
3568     throw SquirrelError(v, "Couldn't register function 'is_visible'");
3569   }
3570
3571   sq_pushstring(v, "set_solid", -1);
3572   sq_newclosure(v, &ScriptedObject_set_solid_wrapper, 0);
3573   if(SQ_FAILED(sq_createslot(v, -3))) {
3574     throw SquirrelError(v, "Couldn't register function 'set_solid'");
3575   }
3576
3577   sq_pushstring(v, "is_solid", -1);
3578   sq_newclosure(v, &ScriptedObject_is_solid_wrapper, 0);
3579   if(SQ_FAILED(sq_createslot(v, -3))) {
3580     throw SquirrelError(v, "Couldn't register function 'is_solid'");
3581   }
3582
3583   sq_pushstring(v, "get_name", -1);
3584   sq_newclosure(v, &ScriptedObject_get_name_wrapper, 0);
3585   if(SQ_FAILED(sq_createslot(v, -3))) {
3586     throw SquirrelError(v, "Couldn't register function 'get_name'");
3587   }
3588
3589   if(SQ_FAILED(sq_createslot(v, -3))) {
3590     throw SquirrelError(v, "Couldn't register class 'ScriptedObject'");
3591   }
3592
3593   // Register class Text
3594   sq_pushstring(v, "Text", -1);
3595   if(sq_newclass(v, SQFalse) < 0) {
3596     std::ostringstream msg;
3597     msg << "Couldn't create new class 'Text'";
3598     throw SquirrelError(v, msg.str());
3599   }
3600   sq_pushstring(v, "set_text", -1);
3601   sq_newclosure(v, &Text_set_text_wrapper, 0);
3602   if(SQ_FAILED(sq_createslot(v, -3))) {
3603     throw SquirrelError(v, "Couldn't register function 'set_text'");
3604   }
3605
3606   sq_pushstring(v, "set_font", -1);
3607   sq_newclosure(v, &Text_set_font_wrapper, 0);
3608   if(SQ_FAILED(sq_createslot(v, -3))) {
3609     throw SquirrelError(v, "Couldn't register function 'set_font'");
3610   }
3611
3612   sq_pushstring(v, "fade_in", -1);
3613   sq_newclosure(v, &Text_fade_in_wrapper, 0);
3614   if(SQ_FAILED(sq_createslot(v, -3))) {
3615     throw SquirrelError(v, "Couldn't register function 'fade_in'");
3616   }
3617
3618   sq_pushstring(v, "fade_out", -1);
3619   sq_newclosure(v, &Text_fade_out_wrapper, 0);
3620   if(SQ_FAILED(sq_createslot(v, -3))) {
3621     throw SquirrelError(v, "Couldn't register function 'fade_out'");
3622   }
3623
3624   sq_pushstring(v, "set_visible", -1);
3625   sq_newclosure(v, &Text_set_visible_wrapper, 0);
3626   if(SQ_FAILED(sq_createslot(v, -3))) {
3627     throw SquirrelError(v, "Couldn't register function 'set_visible'");
3628   }
3629
3630   sq_pushstring(v, "set_centered", -1);
3631   sq_newclosure(v, &Text_set_centered_wrapper, 0);
3632   if(SQ_FAILED(sq_createslot(v, -3))) {
3633     throw SquirrelError(v, "Couldn't register function 'set_centered'");
3634   }
3635
3636   if(SQ_FAILED(sq_createslot(v, -3))) {
3637     throw SquirrelError(v, "Couldn't register class 'Text'");
3638   }
3639
3640   // Register class Player
3641   sq_pushstring(v, "Player", -1);
3642   if(sq_newclass(v, SQFalse) < 0) {
3643     std::ostringstream msg;
3644     msg << "Couldn't create new class 'Player'";
3645     throw SquirrelError(v, msg.str());
3646   }
3647   sq_pushstring(v, "add_bonus", -1);
3648   sq_newclosure(v, &Player_add_bonus_wrapper, 0);
3649   if(SQ_FAILED(sq_createslot(v, -3))) {
3650     throw SquirrelError(v, "Couldn't register function 'add_bonus'");
3651   }
3652
3653   sq_pushstring(v, "add_coins", -1);
3654   sq_newclosure(v, &Player_add_coins_wrapper, 0);
3655   if(SQ_FAILED(sq_createslot(v, -3))) {
3656     throw SquirrelError(v, "Couldn't register function 'add_coins'");
3657   }
3658
3659   sq_pushstring(v, "make_invincible", -1);
3660   sq_newclosure(v, &Player_make_invincible_wrapper, 0);
3661   if(SQ_FAILED(sq_createslot(v, -3))) {
3662     throw SquirrelError(v, "Couldn't register function 'make_invincible'");
3663   }
3664
3665   sq_pushstring(v, "deactivate", -1);
3666   sq_newclosure(v, &Player_deactivate_wrapper, 0);
3667   if(SQ_FAILED(sq_createslot(v, -3))) {
3668     throw SquirrelError(v, "Couldn't register function 'deactivate'");
3669   }
3670
3671   sq_pushstring(v, "activate", -1);
3672   sq_newclosure(v, &Player_activate_wrapper, 0);
3673   if(SQ_FAILED(sq_createslot(v, -3))) {
3674     throw SquirrelError(v, "Couldn't register function 'activate'");
3675   }
3676
3677   sq_pushstring(v, "walk", -1);
3678   sq_newclosure(v, &Player_walk_wrapper, 0);
3679   if(SQ_FAILED(sq_createslot(v, -3))) {
3680     throw SquirrelError(v, "Couldn't register function 'walk'");
3681   }
3682
3683   sq_pushstring(v, "set_visible", -1);
3684   sq_newclosure(v, &Player_set_visible_wrapper, 0);
3685   if(SQ_FAILED(sq_createslot(v, -3))) {
3686     throw SquirrelError(v, "Couldn't register function 'set_visible'");
3687   }
3688
3689   sq_pushstring(v, "get_visible", -1);
3690   sq_newclosure(v, &Player_get_visible_wrapper, 0);
3691   if(SQ_FAILED(sq_createslot(v, -3))) {
3692     throw SquirrelError(v, "Couldn't register function 'get_visible'");
3693   }
3694
3695   sq_pushstring(v, "kill", -1);
3696   sq_newclosure(v, &Player_kill_wrapper, 0);
3697   if(SQ_FAILED(sq_createslot(v, -3))) {
3698     throw SquirrelError(v, "Couldn't register function 'kill'");
3699   }
3700
3701   sq_pushstring(v, "set_ghost_mode", -1);
3702   sq_newclosure(v, &Player_set_ghost_mode_wrapper, 0);
3703   if(SQ_FAILED(sq_createslot(v, -3))) {
3704     throw SquirrelError(v, "Couldn't register function 'set_ghost_mode'");
3705   }
3706
3707   sq_pushstring(v, "get_ghost_mode", -1);
3708   sq_newclosure(v, &Player_get_ghost_mode_wrapper, 0);
3709   if(SQ_FAILED(sq_createslot(v, -3))) {
3710     throw SquirrelError(v, "Couldn't register function 'get_ghost_mode'");
3711   }
3712
3713   sq_pushstring(v, "do_cheer", -1);
3714   sq_newclosure(v, &Player_do_cheer_wrapper, 0);
3715   if(SQ_FAILED(sq_createslot(v, -3))) {
3716     throw SquirrelError(v, "Couldn't register function 'do_cheer'");
3717   }
3718
3719   sq_pushstring(v, "do_duck", -1);
3720   sq_newclosure(v, &Player_do_duck_wrapper, 0);
3721   if(SQ_FAILED(sq_createslot(v, -3))) {
3722     throw SquirrelError(v, "Couldn't register function 'do_duck'");
3723   }
3724
3725   sq_pushstring(v, "do_standup", -1);
3726   sq_newclosure(v, &Player_do_standup_wrapper, 0);
3727   if(SQ_FAILED(sq_createslot(v, -3))) {
3728     throw SquirrelError(v, "Couldn't register function 'do_standup'");
3729   }
3730
3731   sq_pushstring(v, "do_backflip", -1);
3732   sq_newclosure(v, &Player_do_backflip_wrapper, 0);
3733   if(SQ_FAILED(sq_createslot(v, -3))) {
3734     throw SquirrelError(v, "Couldn't register function 'do_backflip'");
3735   }
3736
3737   sq_pushstring(v, "do_jump", -1);
3738   sq_newclosure(v, &Player_do_jump_wrapper, 0);
3739   if(SQ_FAILED(sq_createslot(v, -3))) {
3740     throw SquirrelError(v, "Couldn't register function 'do_jump'");
3741   }
3742
3743   if(SQ_FAILED(sq_createslot(v, -3))) {
3744     throw SquirrelError(v, "Couldn't register class 'Player'");
3745   }
3746
3747   // Register class FloatingImage
3748   sq_pushstring(v, "FloatingImage", -1);
3749   if(sq_newclass(v, SQFalse) < 0) {
3750     std::ostringstream msg;
3751     msg << "Couldn't create new class 'FloatingImage'";
3752     throw SquirrelError(v, msg.str());
3753   }
3754   sq_pushstring(v, "constructor", -1);
3755   sq_newclosure(v, &FloatingImage_constructor_wrapper, 0);
3756   if(SQ_FAILED(sq_createslot(v, -3))) {
3757     throw SquirrelError(v, "Couldn't register function 'constructor'");
3758   }
3759
3760   sq_pushstring(v, "set_layer", -1);
3761   sq_newclosure(v, &FloatingImage_set_layer_wrapper, 0);
3762   if(SQ_FAILED(sq_createslot(v, -3))) {
3763     throw SquirrelError(v, "Couldn't register function 'set_layer'");
3764   }
3765
3766   sq_pushstring(v, "get_layer", -1);
3767   sq_newclosure(v, &FloatingImage_get_layer_wrapper, 0);
3768   if(SQ_FAILED(sq_createslot(v, -3))) {
3769     throw SquirrelError(v, "Couldn't register function 'get_layer'");
3770   }
3771
3772   sq_pushstring(v, "set_pos", -1);
3773   sq_newclosure(v, &FloatingImage_set_pos_wrapper, 0);
3774   if(SQ_FAILED(sq_createslot(v, -3))) {
3775     throw SquirrelError(v, "Couldn't register function 'set_pos'");
3776   }
3777
3778   sq_pushstring(v, "get_pos_x", -1);
3779   sq_newclosure(v, &FloatingImage_get_pos_x_wrapper, 0);
3780   if(SQ_FAILED(sq_createslot(v, -3))) {
3781     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
3782   }
3783
3784   sq_pushstring(v, "get_pos_y", -1);
3785   sq_newclosure(v, &FloatingImage_get_pos_y_wrapper, 0);
3786   if(SQ_FAILED(sq_createslot(v, -3))) {
3787     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
3788   }
3789
3790   sq_pushstring(v, "set_anchor_point", -1);
3791   sq_newclosure(v, &FloatingImage_set_anchor_point_wrapper, 0);
3792   if(SQ_FAILED(sq_createslot(v, -3))) {
3793     throw SquirrelError(v, "Couldn't register function 'set_anchor_point'");
3794   }
3795
3796   sq_pushstring(v, "get_anchor_point", -1);
3797   sq_newclosure(v, &FloatingImage_get_anchor_point_wrapper, 0);
3798   if(SQ_FAILED(sq_createslot(v, -3))) {
3799     throw SquirrelError(v, "Couldn't register function 'get_anchor_point'");
3800   }
3801
3802   sq_pushstring(v, "set_visible", -1);
3803   sq_newclosure(v, &FloatingImage_set_visible_wrapper, 0);
3804   if(SQ_FAILED(sq_createslot(v, -3))) {
3805     throw SquirrelError(v, "Couldn't register function 'set_visible'");
3806   }
3807
3808   sq_pushstring(v, "get_visible", -1);
3809   sq_newclosure(v, &FloatingImage_get_visible_wrapper, 0);
3810   if(SQ_FAILED(sq_createslot(v, -3))) {
3811     throw SquirrelError(v, "Couldn't register function 'get_visible'");
3812   }
3813
3814   sq_pushstring(v, "set_action", -1);
3815   sq_newclosure(v, &FloatingImage_set_action_wrapper, 0);
3816   if(SQ_FAILED(sq_createslot(v, -3))) {
3817     throw SquirrelError(v, "Couldn't register function 'set_action'");
3818   }
3819
3820   sq_pushstring(v, "get_action", -1);
3821   sq_newclosure(v, &FloatingImage_get_action_wrapper, 0);
3822   if(SQ_FAILED(sq_createslot(v, -3))) {
3823     throw SquirrelError(v, "Couldn't register function 'get_action'");
3824   }
3825
3826   if(SQ_FAILED(sq_createslot(v, -3))) {
3827     throw SquirrelError(v, "Couldn't register class 'FloatingImage'");
3828   }
3829
3830   // Register class Platform
3831   sq_pushstring(v, "Platform", -1);
3832   if(sq_newclass(v, SQFalse) < 0) {
3833     std::ostringstream msg;
3834     msg << "Couldn't create new class 'Platform'";
3835     throw SquirrelError(v, msg.str());
3836   }
3837   sq_pushstring(v, "goto_node", -1);
3838   sq_newclosure(v, &Platform_goto_node_wrapper, 0);
3839   if(SQ_FAILED(sq_createslot(v, -3))) {
3840     throw SquirrelError(v, "Couldn't register function 'goto_node'");
3841   }
3842
3843   sq_pushstring(v, "start_moving", -1);
3844   sq_newclosure(v, &Platform_start_moving_wrapper, 0);
3845   if(SQ_FAILED(sq_createslot(v, -3))) {
3846     throw SquirrelError(v, "Couldn't register function 'start_moving'");
3847   }
3848
3849   sq_pushstring(v, "stop_moving", -1);
3850   sq_newclosure(v, &Platform_stop_moving_wrapper, 0);
3851   if(SQ_FAILED(sq_createslot(v, -3))) {
3852     throw SquirrelError(v, "Couldn't register function 'stop_moving'");
3853   }
3854
3855   if(SQ_FAILED(sq_createslot(v, -3))) {
3856     throw SquirrelError(v, "Couldn't register class 'Platform'");
3857   }
3858
3859   // Register class Candle
3860   sq_pushstring(v, "Candle", -1);
3861   if(sq_newclass(v, SQFalse) < 0) {
3862     std::ostringstream msg;
3863     msg << "Couldn't create new class 'Candle'";
3864     throw SquirrelError(v, msg.str());
3865   }
3866   sq_pushstring(v, "get_burning", -1);
3867   sq_newclosure(v, &Candle_get_burning_wrapper, 0);
3868   if(SQ_FAILED(sq_createslot(v, -3))) {
3869     throw SquirrelError(v, "Couldn't register function 'get_burning'");
3870   }
3871
3872   sq_pushstring(v, "set_burning", -1);
3873   sq_newclosure(v, &Candle_set_burning_wrapper, 0);
3874   if(SQ_FAILED(sq_createslot(v, -3))) {
3875     throw SquirrelError(v, "Couldn't register function 'set_burning'");
3876   }
3877
3878   if(SQ_FAILED(sq_createslot(v, -3))) {
3879     throw SquirrelError(v, "Couldn't register class 'Candle'");
3880   }
3881
3882   // Register class Wind
3883   sq_pushstring(v, "Wind", -1);
3884   if(sq_newclass(v, SQFalse) < 0) {
3885     std::ostringstream msg;
3886     msg << "Couldn't create new class 'Wind'";
3887     throw SquirrelError(v, msg.str());
3888   }
3889   sq_pushstring(v, "start", -1);
3890   sq_newclosure(v, &Wind_start_wrapper, 0);
3891   if(SQ_FAILED(sq_createslot(v, -3))) {
3892     throw SquirrelError(v, "Couldn't register function 'start'");
3893   }
3894
3895   sq_pushstring(v, "stop", -1);
3896   sq_newclosure(v, &Wind_stop_wrapper, 0);
3897   if(SQ_FAILED(sq_createslot(v, -3))) {
3898     throw SquirrelError(v, "Couldn't register function 'stop'");
3899   }
3900
3901   if(SQ_FAILED(sq_createslot(v, -3))) {
3902     throw SquirrelError(v, "Couldn't register class 'Wind'");
3903   }
3904
3905   // Register class AmbientSound
3906   sq_pushstring(v, "AmbientSound", -1);
3907   if(sq_newclass(v, SQFalse) < 0) {
3908     std::ostringstream msg;
3909     msg << "Couldn't create new class 'AmbientSound'";
3910     throw SquirrelError(v, msg.str());
3911   }
3912   sq_pushstring(v, "set_pos", -1);
3913   sq_newclosure(v, &AmbientSound_set_pos_wrapper, 0);
3914   if(SQ_FAILED(sq_createslot(v, -3))) {
3915     throw SquirrelError(v, "Couldn't register function 'set_pos'");
3916   }
3917
3918   sq_pushstring(v, "get_pos_x", -1);
3919   sq_newclosure(v, &AmbientSound_get_pos_x_wrapper, 0);
3920   if(SQ_FAILED(sq_createslot(v, -3))) {
3921     throw SquirrelError(v, "Couldn't register function 'get_pos_x'");
3922   }
3923
3924   sq_pushstring(v, "get_pos_y", -1);
3925   sq_newclosure(v, &AmbientSound_get_pos_y_wrapper, 0);
3926   if(SQ_FAILED(sq_createslot(v, -3))) {
3927     throw SquirrelError(v, "Couldn't register function 'get_pos_y'");
3928   }
3929
3930   if(SQ_FAILED(sq_createslot(v, -3))) {
3931     throw SquirrelError(v, "Couldn't register class 'AmbientSound'");
3932   }
3933
3934   // Register class Thunderstorm
3935   sq_pushstring(v, "Thunderstorm", -1);
3936   if(sq_newclass(v, SQFalse) < 0) {
3937     std::ostringstream msg;
3938     msg << "Couldn't create new class 'Thunderstorm'";
3939     throw SquirrelError(v, msg.str());
3940   }
3941   sq_pushstring(v, "start", -1);
3942   sq_newclosure(v, &Thunderstorm_start_wrapper, 0);
3943   if(SQ_FAILED(sq_createslot(v, -3))) {
3944     throw SquirrelError(v, "Couldn't register function 'start'");
3945   }
3946
3947   sq_pushstring(v, "stop", -1);
3948   sq_newclosure(v, &Thunderstorm_stop_wrapper, 0);
3949   if(SQ_FAILED(sq_createslot(v, -3))) {
3950     throw SquirrelError(v, "Couldn't register function 'stop'");
3951   }
3952
3953   sq_pushstring(v, "thunder", -1);
3954   sq_newclosure(v, &Thunderstorm_thunder_wrapper, 0);
3955   if(SQ_FAILED(sq_createslot(v, -3))) {
3956     throw SquirrelError(v, "Couldn't register function 'thunder'");
3957   }
3958
3959   sq_pushstring(v, "lightning", -1);
3960   sq_newclosure(v, &Thunderstorm_lightning_wrapper, 0);
3961   if(SQ_FAILED(sq_createslot(v, -3))) {
3962     throw SquirrelError(v, "Couldn't register function 'lightning'");
3963   }
3964
3965   sq_pushstring(v, "flash", -1);
3966   sq_newclosure(v, &Thunderstorm_flash_wrapper, 0);
3967   if(SQ_FAILED(sq_createslot(v, -3))) {
3968     throw SquirrelError(v, "Couldn't register function 'flash'");
3969   }
3970
3971   sq_pushstring(v, "electrify", -1);
3972   sq_newclosure(v, &Thunderstorm_electrify_wrapper, 0);
3973   if(SQ_FAILED(sq_createslot(v, -3))) {
3974     throw SquirrelError(v, "Couldn't register function 'electrify'");
3975   }
3976
3977   if(SQ_FAILED(sq_createslot(v, -3))) {
3978     throw SquirrelError(v, "Couldn't register class 'Thunderstorm'");
3979   }
3980
3981 }
3982
3983 } // end of namespace Scripting
3984