src/swig/ext/armagetronad_wrap.cxx

Go to the documentation of this file.
00001 /* ----------------------------------------------------------------------------
00002  * This file was automatically generated by SWIG (http://www.swig.org).
00003  * Version 1.3.31
00004  * 
00005  * This file is not intended to be easily readable and contains a number of 
00006  * coding conventions designed to improve portability and efficiency. Do not make
00007  * changes to this file unless you know what you are doing--modify the SWIG 
00008  * interface file instead. 
00009  * ----------------------------------------------------------------------------- */
00010 
00011 #define SWIGRUBY
00012 #define SWIG_DIRECTORS
00013 
00014 #ifdef __cplusplus
00015 template<class T> class SwigValueWrapper {
00016     T *tt;
00017 public:
00018     SwigValueWrapper() : tt(0) { }
00019     SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
00020     SwigValueWrapper(const T& t) : tt(new T(t)) { }
00021     ~SwigValueWrapper() { delete tt; } 
00022     SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
00023     operator T&() const { return *tt; }
00024     T *operator&() { return tt; }
00025 private:
00026     SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
00027 };
00028 #endif
00029 
00030 /* -----------------------------------------------------------------------------
00031  *  This section contains generic SWIG labels for method/variable
00032  *  declarations/attributes, and other compiler dependent labels.
00033  * ----------------------------------------------------------------------------- */
00034 
00035 /* template workaround for compilers that cannot correctly implement the C++ standard */
00036 #ifndef SWIGTEMPLATEDISAMBIGUATOR
00037 # if defined(__SUNPRO_CC)
00038 #   if (__SUNPRO_CC <= 0x560)
00039 #     define SWIGTEMPLATEDISAMBIGUATOR template
00040 #   else
00041 #     define SWIGTEMPLATEDISAMBIGUATOR 
00042 #   endif
00043 # else
00044 #   define SWIGTEMPLATEDISAMBIGUATOR 
00045 # endif
00046 #endif
00047 
00048 /* inline attribute */
00049 #ifndef SWIGINLINE
00050 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
00051 #   define SWIGINLINE inline
00052 # else
00053 #   define SWIGINLINE
00054 # endif
00055 #endif
00056 
00057 /* attribute recognised by some compilers to avoid 'unused' warnings */
00058 #ifndef SWIGUNUSED
00059 # if defined(__GNUC__)
00060 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
00061 #     define SWIGUNUSED __attribute__ ((__unused__)) 
00062 #   else
00063 #     define SWIGUNUSED
00064 #   endif
00065 # elif defined(__ICC)
00066 #   define SWIGUNUSED __attribute__ ((__unused__)) 
00067 # else
00068 #   define SWIGUNUSED 
00069 # endif
00070 #endif
00071 
00072 #ifndef SWIGUNUSEDPARM
00073 # ifdef __cplusplus
00074 #   define SWIGUNUSEDPARM(p)
00075 # else
00076 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
00077 # endif
00078 #endif
00079 
00080 /* internal SWIG method */
00081 #ifndef SWIGINTERN
00082 # define SWIGINTERN static SWIGUNUSED
00083 #endif
00084 
00085 /* internal inline SWIG method */
00086 #ifndef SWIGINTERNINLINE
00087 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
00088 #endif
00089 
00090 /* exporting methods */
00091 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
00092 #  ifndef GCC_HASCLASSVISIBILITY
00093 #    define GCC_HASCLASSVISIBILITY
00094 #  endif
00095 #endif
00096 
00097 #ifndef SWIGEXPORT
00098 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00099 #   if defined(STATIC_LINKED)
00100 #     define SWIGEXPORT
00101 #   else
00102 #     define SWIGEXPORT __declspec(dllexport)
00103 #   endif
00104 # else
00105 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
00106 #     define SWIGEXPORT __attribute__ ((visibility("default")))
00107 #   else
00108 #     define SWIGEXPORT
00109 #   endif
00110 # endif
00111 #endif
00112 
00113 /* calling conventions for Windows */
00114 #ifndef SWIGSTDCALL
00115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00116 #   define SWIGSTDCALL __stdcall
00117 # else
00118 #   define SWIGSTDCALL
00119 # endif 
00120 #endif
00121 
00122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
00123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
00124 # define _CRT_SECURE_NO_DEPRECATE
00125 #endif
00126 
00127 /* -----------------------------------------------------------------------------
00128  *  This section contains generic SWIG labels for method/variable
00129  *  declarations/attributes, and other compiler dependent labels.
00130  * ----------------------------------------------------------------------------- */
00131 
00132 /* template workaround for compilers that cannot correctly implement the C++ standard */
00133 #ifndef SWIGTEMPLATEDISAMBIGUATOR
00134 # if defined(__SUNPRO_CC)
00135 #   if (__SUNPRO_CC <= 0x560)
00136 #     define SWIGTEMPLATEDISAMBIGUATOR template
00137 #   else
00138 #     define SWIGTEMPLATEDISAMBIGUATOR 
00139 #   endif
00140 # else
00141 #   define SWIGTEMPLATEDISAMBIGUATOR 
00142 # endif
00143 #endif
00144 
00145 /* inline attribute */
00146 #ifndef SWIGINLINE
00147 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
00148 #   define SWIGINLINE inline
00149 # else
00150 #   define SWIGINLINE
00151 # endif
00152 #endif
00153 
00154 /* attribute recognised by some compilers to avoid 'unused' warnings */
00155 #ifndef SWIGUNUSED
00156 # if defined(__GNUC__)
00157 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
00158 #     define SWIGUNUSED __attribute__ ((__unused__)) 
00159 #   else
00160 #     define SWIGUNUSED
00161 #   endif
00162 # elif defined(__ICC)
00163 #   define SWIGUNUSED __attribute__ ((__unused__)) 
00164 # else
00165 #   define SWIGUNUSED 
00166 # endif
00167 #endif
00168 
00169 #ifndef SWIGUNUSEDPARM
00170 # ifdef __cplusplus
00171 #   define SWIGUNUSEDPARM(p)
00172 # else
00173 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
00174 # endif
00175 #endif
00176 
00177 /* internal SWIG method */
00178 #ifndef SWIGINTERN
00179 # define SWIGINTERN static SWIGUNUSED
00180 #endif
00181 
00182 /* internal inline SWIG method */
00183 #ifndef SWIGINTERNINLINE
00184 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
00185 #endif
00186 
00187 /* exporting methods */
00188 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
00189 #  ifndef GCC_HASCLASSVISIBILITY
00190 #    define GCC_HASCLASSVISIBILITY
00191 #  endif
00192 #endif
00193 
00194 #ifndef SWIGEXPORT
00195 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00196 #   if defined(STATIC_LINKED)
00197 #     define SWIGEXPORT
00198 #   else
00199 #     define SWIGEXPORT __declspec(dllexport)
00200 #   endif
00201 # else
00202 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
00203 #     define SWIGEXPORT __attribute__ ((visibility("default")))
00204 #   else
00205 #     define SWIGEXPORT
00206 #   endif
00207 # endif
00208 #endif
00209 
00210 /* calling conventions for Windows */
00211 #ifndef SWIGSTDCALL
00212 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00213 #   define SWIGSTDCALL __stdcall
00214 # else
00215 #   define SWIGSTDCALL
00216 # endif 
00217 #endif
00218 
00219 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
00220 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
00221 # define _CRT_SECURE_NO_DEPRECATE
00222 #endif
00223 
00224 /* -----------------------------------------------------------------------------
00225  * swigrun.swg
00226  *
00227  * This file contains generic CAPI SWIG runtime support for pointer
00228  * type checking.
00229  * ----------------------------------------------------------------------------- */
00230 
00231 /* This should only be incremented when either the layout of swig_type_info changes,
00232    or for whatever reason, the runtime changes incompatibly */
00233 #define SWIG_RUNTIME_VERSION "3"
00234 
00235 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
00236 #ifdef SWIG_TYPE_TABLE
00237 # define SWIG_QUOTE_STRING(x) #x
00238 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
00239 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
00240 #else
00241 # define SWIG_TYPE_TABLE_NAME
00242 #endif
00243 
00244 /*
00245   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
00246   creating a static or dynamic library from the swig runtime code.
00247   In 99.9% of the cases, swig just needs to declare them as 'static'.
00248   
00249   But only do this if is strictly necessary, ie, if you have problems
00250   with your compiler or so.
00251 */
00252 
00253 #ifndef SWIGRUNTIME
00254 # define SWIGRUNTIME SWIGINTERN
00255 #endif
00256 
00257 #ifndef SWIGRUNTIMEINLINE
00258 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
00259 #endif
00260 
00261 /*  Generic buffer size */
00262 #ifndef SWIG_BUFFER_SIZE
00263 # define SWIG_BUFFER_SIZE 1024
00264 #endif
00265 
00266 /* Flags for pointer conversions */
00267 #define SWIG_POINTER_DISOWN        0x1
00268 
00269 /* Flags for new pointer objects */
00270 #define SWIG_POINTER_OWN           0x1
00271 
00272 
00273 /* 
00274    Flags/methods for returning states.
00275    
00276    The swig conversion methods, as ConvertPtr, return and integer 
00277    that tells if the conversion was successful or not. And if not,
00278    an error code can be returned (see swigerrors.swg for the codes).
00279    
00280    Use the following macros/flags to set or process the returning
00281    states.
00282    
00283    In old swig versions, you usually write code as:
00284 
00285      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
00286        // success code
00287      } else {
00288        //fail code
00289      }
00290 
00291    Now you can be more explicit as:
00292 
00293     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
00294     if (SWIG_IsOK(res)) {
00295       // success code
00296     } else {
00297       // fail code
00298     }
00299 
00300    that seems to be the same, but now you can also do
00301 
00302     Type *ptr;
00303     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
00304     if (SWIG_IsOK(res)) {
00305       // success code
00306       if (SWIG_IsNewObj(res) {
00307         ...
00308         delete *ptr;
00309       } else {
00310         ...
00311       }
00312     } else {
00313       // fail code
00314     }
00315     
00316    I.e., now SWIG_ConvertPtr can return new objects and you can
00317    identify the case and take care of the deallocation. Of course that
00318    requires also to SWIG_ConvertPtr to return new result values, as
00319 
00320       int SWIG_ConvertPtr(obj, ptr,...) {         
00321         if (<obj is ok>) {                             
00322           if (<need new object>) {                     
00323             *ptr = <ptr to new allocated object>; 
00324             return SWIG_NEWOBJ;                
00325           } else {                                     
00326             *ptr = <ptr to old object>;        
00327             return SWIG_OLDOBJ;                
00328           }                                    
00329         } else {                                       
00330           return SWIG_BADOBJ;                  
00331         }                                              
00332       }
00333 
00334    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
00335    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
00336    swig errors code.
00337 
00338    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
00339    allows to return the 'cast rank', for example, if you have this
00340 
00341        int food(double)
00342        int fooi(int);
00343 
00344    and you call
00345  
00346       food(1)   // cast rank '1'  (1 -> 1.0)
00347       fooi(1)   // cast rank '0'
00348 
00349    just use the SWIG_AddCast()/SWIG_CheckState()
00350 
00351 
00352  */
00353 #define SWIG_OK                    (0) 
00354 #define SWIG_ERROR                 (-1)
00355 #define SWIG_IsOK(r)               (r >= 0)
00356 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
00357 
00358 /* The CastRankLimit says how many bits are used for the cast rank */
00359 #define SWIG_CASTRANKLIMIT         (1 << 8)
00360 /* The NewMask denotes the object was created (using new/malloc) */
00361 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
00362 /* The TmpMask is for in/out typemaps that use temporal objects */
00363 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
00364 /* Simple returning values */
00365 #define SWIG_BADOBJ                (SWIG_ERROR)
00366 #define SWIG_OLDOBJ                (SWIG_OK)
00367 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
00368 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
00369 /* Check, add and del mask methods */
00370 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
00371 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
00372 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
00373 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
00374 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
00375 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
00376 
00377 
00378 /* Cast-Rank Mode */
00379 #if defined(SWIG_CASTRANK_MODE)
00380 #  ifndef SWIG_TypeRank
00381 #    define SWIG_TypeRank             unsigned long
00382 #  endif
00383 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
00384 #    define SWIG_MAXCASTRANK          (2)
00385 #  endif
00386 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
00387 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
00388 SWIGINTERNINLINE int SWIG_AddCast(int r) { 
00389   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
00390 }
00391 SWIGINTERNINLINE int SWIG_CheckState(int r) { 
00392   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
00393 }
00394 #else /* no cast-rank mode */
00395 #  define SWIG_AddCast
00396 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
00397 #endif
00398 
00399 
00400 
00401 
00402 #include <string.h>
00403 
00404 #ifdef __cplusplus
00405 extern "C" {
00406 #endif
00407 
00408 typedef void *(*swig_converter_func)(void *);
00409 typedef struct swig_type_info *(*swig_dycast_func)(void **);
00410 
00411 /* Structure to store inforomation on one type */
00412 typedef struct swig_type_info {
00413   const char             *name;                 /* mangled name of this type */
00414   const char             *str;                  /* human readable name of this type */
00415   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
00416   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
00417   void                   *clientdata;           /* language specific type data */
00418   int                    owndata;               /* flag if the structure owns the clientdata */
00419 } swig_type_info;
00420 
00421 /* Structure to store a type and conversion function used for casting */
00422 typedef struct swig_cast_info {
00423   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
00424   swig_converter_func     converter;            /* function to cast the void pointers */
00425   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
00426   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
00427 } swig_cast_info;
00428 
00429 /* Structure used to store module information
00430  * Each module generates one structure like this, and the runtime collects
00431  * all of these structures and stores them in a circularly linked list.*/
00432 typedef struct swig_module_info {
00433   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
00434   size_t                 size;                  /* Number of types in this module */
00435   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
00436   swig_type_info         **type_initial;        /* Array of initially generated type structures */
00437   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
00438   void                    *clientdata;          /* Language specific module data */
00439 } swig_module_info;
00440 
00441 /* 
00442   Compare two type names skipping the space characters, therefore
00443   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
00444 
00445   Return 0 when the two name types are equivalent, as in
00446   strncmp, but skipping ' '.
00447 */
00448 SWIGRUNTIME int
00449 SWIG_TypeNameComp(const char *f1, const char *l1,
00450                   const char *f2, const char *l2) {
00451   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
00452     while ((*f1 == ' ') && (f1 != l1)) ++f1;
00453     while ((*f2 == ' ') && (f2 != l2)) ++f2;
00454     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
00455   }
00456   return (l1 - f1) - (l2 - f2);
00457 }
00458 
00459 /*
00460   Check type equivalence in a name list like <name1>|<name2>|...
00461   Return 0 if not equal, 1 if equal
00462 */
00463 SWIGRUNTIME int
00464 SWIG_TypeEquiv(const char *nb, const char *tb) {
00465   int equiv = 0;
00466   const char* te = tb + strlen(tb);
00467   const char* ne = nb;
00468   while (!equiv && *ne) {
00469     for (nb = ne; *ne; ++ne) {
00470       if (*ne == '|') break;
00471     }
00472     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
00473     if (*ne) ++ne;
00474   }
00475   return equiv;
00476 }
00477 
00478 /*
00479   Check type equivalence in a name list like <name1>|<name2>|...
00480   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
00481 */
00482 SWIGRUNTIME int
00483 SWIG_TypeCompare(const char *nb, const char *tb) {
00484   int equiv = 0;
00485   const char* te = tb + strlen(tb);
00486   const char* ne = nb;
00487   while (!equiv && *ne) {
00488     for (nb = ne; *ne; ++ne) {
00489       if (*ne == '|') break;
00490     }
00491     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
00492     if (*ne) ++ne;
00493   }
00494   return equiv;
00495 }
00496 
00497 
00498 /* think of this as a c++ template<> or a scheme macro */
00499 #define SWIG_TypeCheck_Template(comparison, ty)         \
00500   if (ty) {                                             \
00501     swig_cast_info *iter = ty->cast;                    \
00502     while (iter) {                                      \
00503       if (comparison) {                                 \
00504         if (iter == ty->cast) return iter;              \
00505         /* Move iter to the top of the linked list */   \
00506         iter->prev->next = iter->next;                  \
00507         if (iter->next)                                 \
00508           iter->next->prev = iter->prev;                \
00509         iter->next = ty->cast;                          \
00510         iter->prev = 0;                                 \
00511         if (ty->cast) ty->cast->prev = iter;            \
00512         ty->cast = iter;                                \
00513         return iter;                                    \
00514       }                                                 \
00515       iter = iter->next;                                \
00516     }                                                   \
00517   }                                                     \
00518   return 0
00519 
00520 /*
00521   Check the typename
00522 */
00523 SWIGRUNTIME swig_cast_info *
00524 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
00525   SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
00526 }
00527 
00528 /* Same as previous function, except strcmp is replaced with a pointer comparison */
00529 SWIGRUNTIME swig_cast_info *
00530 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
00531   SWIG_TypeCheck_Template(iter->type == from, into);
00532 }
00533 
00534 /*
00535   Cast a pointer up an inheritance hierarchy
00536 */
00537 SWIGRUNTIMEINLINE void *
00538 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
00539   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
00540 }
00541 
00542 /* 
00543    Dynamic pointer casting. Down an inheritance hierarchy
00544 */
00545 SWIGRUNTIME swig_type_info *
00546 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
00547   swig_type_info *lastty = ty;
00548   if (!ty || !ty->dcast) return ty;
00549   while (ty && (ty->dcast)) {
00550     ty = (*ty->dcast)(ptr);
00551     if (ty) lastty = ty;
00552   }
00553   return lastty;
00554 }
00555 
00556 /*
00557   Return the name associated with this type
00558 */
00559 SWIGRUNTIMEINLINE const char *
00560 SWIG_TypeName(const swig_type_info *ty) {
00561   return ty->name;
00562 }
00563 
00564 /*
00565   Return the pretty name associated with this type,
00566   that is an unmangled type name in a form presentable to the user.
00567 */
00568 SWIGRUNTIME const char *
00569 SWIG_TypePrettyName(const swig_type_info *type) {
00570   /* The "str" field contains the equivalent pretty names of the
00571      type, separated by vertical-bar characters.  We choose
00572      to print the last name, as it is often (?) the most
00573      specific. */
00574   if (!type) return NULL;
00575   if (type->str != NULL) {
00576     const char *last_name = type->str;
00577     const char *s;
00578     for (s = type->str; *s; s++)
00579       if (*s == '|') last_name = s+1;
00580     return last_name;
00581   }
00582   else
00583     return type->name;
00584 }
00585 
00586 /* 
00587    Set the clientdata field for a type
00588 */
00589 SWIGRUNTIME void
00590 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
00591   swig_cast_info *cast = ti->cast;
00592   /* if (ti->clientdata == clientdata) return; */
00593   ti->clientdata = clientdata;
00594   
00595   while (cast) {
00596     if (!cast->converter) {
00597       swig_type_info *tc = cast->type;
00598       if (!tc->clientdata) {
00599         SWIG_TypeClientData(tc, clientdata);
00600       }
00601     }    
00602     cast = cast->next;
00603   }
00604 }
00605 SWIGRUNTIME void
00606 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
00607   SWIG_TypeClientData(ti, clientdata);
00608   ti->owndata = 1;
00609 }
00610   
00611 /*
00612   Search for a swig_type_info structure only by mangled name
00613   Search is a O(log #types)
00614   
00615   We start searching at module start, and finish searching when start == end.  
00616   Note: if start == end at the beginning of the function, we go all the way around
00617   the circular list.
00618 */
00619 SWIGRUNTIME swig_type_info *
00620 SWIG_MangledTypeQueryModule(swig_module_info *start, 
00621                             swig_module_info *end, 
00622                             const char *name) {
00623   swig_module_info *iter = start;
00624   do {
00625     if (iter->size) {
00626       register size_t l = 0;
00627       register size_t r = iter->size - 1;
00628       do {
00629         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
00630         register size_t i = (l + r) >> 1; 
00631         const char *iname = iter->types[i]->name;
00632         if (iname) {
00633           register int compare = strcmp(name, iname);
00634           if (compare == 0) {       
00635             return iter->types[i];
00636           } else if (compare < 0) {
00637             if (i) {
00638               r = i - 1;
00639             } else {
00640               break;
00641             }
00642           } else if (compare > 0) {
00643             l = i + 1;
00644           }
00645         } else {
00646           break; /* should never happen */
00647         }
00648       } while (l <= r);
00649     }
00650     iter = iter->next;
00651   } while (iter != end);
00652   return 0;
00653 }
00654 
00655 /*
00656   Search for a swig_type_info structure for either a mangled name or a human readable name.
00657   It first searches the mangled names of the types, which is a O(log #types)
00658   If a type is not found it then searches the human readable names, which is O(#types).
00659   
00660   We start searching at module start, and finish searching when start == end.  
00661   Note: if start == end at the beginning of the function, we go all the way around
00662   the circular list.
00663 */
00664 SWIGRUNTIME swig_type_info *
00665 SWIG_TypeQueryModule(swig_module_info *start, 
00666                      swig_module_info *end, 
00667                      const char *name) {
00668   /* STEP 1: Search the name field using binary search */
00669   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
00670   if (ret) {
00671     return ret;
00672   } else {
00673     /* STEP 2: If the type hasn't been found, do a complete search
00674        of the str field (the human readable name) */
00675     swig_module_info *iter = start;
00676     do {
00677       register size_t i = 0;
00678       for (; i < iter->size; ++i) {
00679         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
00680           return iter->types[i];
00681       }
00682       iter = iter->next;
00683     } while (iter != end);
00684   }
00685   
00686   /* neither found a match */
00687   return 0;
00688 }
00689 
00690 /* 
00691    Pack binary data into a string
00692 */
00693 SWIGRUNTIME char *
00694 SWIG_PackData(char *c, void *ptr, size_t sz) {
00695   static const char hex[17] = "0123456789abcdef";
00696   register const unsigned char *u = (unsigned char *) ptr;
00697   register const unsigned char *eu =  u + sz;
00698   for (; u != eu; ++u) {
00699     register unsigned char uu = *u;
00700     *(c++) = hex[(uu & 0xf0) >> 4];
00701     *(c++) = hex[uu & 0xf];
00702   }
00703   return c;
00704 }
00705 
00706 /* 
00707    Unpack binary data from a string
00708 */
00709 SWIGRUNTIME const char *
00710 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
00711   register unsigned char *u = (unsigned char *) ptr;
00712   register const unsigned char *eu = u + sz;
00713   for (; u != eu; ++u) {
00714     register char d = *(c++);
00715     register unsigned char uu;
00716     if ((d >= '0') && (d <= '9'))
00717       uu = ((d - '0') << 4);
00718     else if ((d >= 'a') && (d <= 'f'))
00719       uu = ((d - ('a'-10)) << 4);
00720     else 
00721       return (char *) 0;
00722     d = *(c++);
00723     if ((d >= '0') && (d <= '9'))
00724       uu |= (d - '0');
00725     else if ((d >= 'a') && (d <= 'f'))
00726       uu |= (d - ('a'-10));
00727     else 
00728       return (char *) 0;
00729     *u = uu;
00730   }
00731   return c;
00732 }
00733 
00734 /* 
00735    Pack 'void *' into a string buffer.
00736 */
00737 SWIGRUNTIME char *
00738 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
00739   char *r = buff;
00740   if ((2*sizeof(void *) + 2) > bsz) return 0;
00741   *(r++) = '_';
00742   r = SWIG_PackData(r,&ptr,sizeof(void *));
00743   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
00744   strcpy(r,name);
00745   return buff;
00746 }
00747 
00748 SWIGRUNTIME const char *
00749 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
00750   if (*c != '_') {
00751     if (strcmp(c,"NULL") == 0) {
00752       *ptr = (void *) 0;
00753       return name;
00754     } else {
00755       return 0;
00756     }
00757   }
00758   return SWIG_UnpackData(++c,ptr,sizeof(void *));
00759 }
00760 
00761 SWIGRUNTIME char *
00762 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
00763   char *r = buff;
00764   size_t lname = (name ? strlen(name) : 0);
00765   if ((2*sz + 2 + lname) > bsz) return 0;
00766   *(r++) = '_';
00767   r = SWIG_PackData(r,ptr,sz);
00768   if (lname) {
00769     strncpy(r,name,lname+1);
00770   } else {
00771     *r = 0;
00772   }
00773   return buff;
00774 }
00775 
00776 SWIGRUNTIME const char *
00777 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
00778   if (*c != '_') {
00779     if (strcmp(c,"NULL") == 0) {
00780       memset(ptr,0,sz);
00781       return name;
00782     } else {
00783       return 0;
00784     }
00785   }
00786   return SWIG_UnpackData(++c,ptr,sz);
00787 }
00788 
00789 #ifdef __cplusplus
00790 }
00791 #endif
00792 
00793 /*  Errors in SWIG */
00794 #define  SWIG_UnknownError         -1 
00795 #define  SWIG_IOError              -2 
00796 #define  SWIG_RuntimeError         -3 
00797 #define  SWIG_IndexError           -4 
00798 #define  SWIG_TypeError            -5 
00799 #define  SWIG_DivisionByZero       -6 
00800 #define  SWIG_OverflowError        -7 
00801 #define  SWIG_SyntaxError          -8 
00802 #define  SWIG_ValueError           -9 
00803 #define  SWIG_SystemError          -10
00804 #define  SWIG_AttributeError       -11
00805 #define  SWIG_MemoryError          -12 
00806 #define  SWIG_NullReferenceError   -13
00807 
00808 
00809 
00810 #include <ruby.h>
00811 
00812 /* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
00813 #ifndef NUM2LL
00814 #define NUM2LL(x) NUM2LONG((x))
00815 #endif
00816 #ifndef LL2NUM
00817 #define LL2NUM(x) INT2NUM((long) (x))
00818 #endif
00819 #ifndef ULL2NUM
00820 #define ULL2NUM(x) UINT2NUM((unsigned long) (x))
00821 #endif
00822 
00823 /* Ruby 1.7 doesn't (yet) define NUM2ULL() */
00824 #ifndef NUM2ULL
00825 #ifdef HAVE_LONG_LONG
00826 #define NUM2ULL(x) rb_num2ull((x))
00827 #else
00828 #define NUM2ULL(x) NUM2ULONG(x)
00829 #endif
00830 #endif
00831 
00832 /* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
00833 /* Define these for older versions so we can just write code the new way */
00834 #ifndef RSTRING_LEN
00835 # define RSTRING_LEN(x) RSTRING(x)->len
00836 #endif
00837 #ifndef RSTRING_PTR
00838 # define RSTRING_PTR(x) RSTRING(x)->ptr
00839 #endif
00840 #ifndef RARRAY_LEN
00841 # define RARRAY_LEN(x) RARRAY(x)->len
00842 #endif
00843 #ifndef RARRAY_PTR
00844 # define RARRAY_PTR(x) RARRAY(x)->ptr
00845 #endif
00846 
00847 /*
00848  * Need to be very careful about how these macros are defined, especially
00849  * when compiling C++ code or C code with an ANSI C compiler.
00850  *
00851  * VALUEFUNC(f) is a macro used to typecast a C function that implements
00852  * a Ruby method so that it can be passed as an argument to API functions
00853  * like rb_define_method() and rb_define_singleton_method().
00854  *
00855  * VOIDFUNC(f) is a macro used to typecast a C function that implements
00856  * either the "mark" or "free" stuff for a Ruby Data object, so that it
00857  * can be passed as an argument to API functions like Data_Wrap_Struct()
00858  * and Data_Make_Struct().
00859  */
00860  
00861 #ifdef __cplusplus
00862 #  ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
00863 #    define PROTECTFUNC(f) ((VALUE (*)()) f)
00864 #    define VALUEFUNC(f) ((VALUE (*)()) f)
00865 #    define VOIDFUNC(f)  ((void (*)()) f)
00866 #  else
00867 #    ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
00868 #      define PROTECTFUNC(f) ((VALUE (*)()) f)
00869 #      define VALUEFUNC(f) ((VALUE (*)()) f)
00870 #      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
00871 #    else /* These definitions should work for Ruby 1.7+ */
00872 #      define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
00873 #      define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
00874 #      define VOIDFUNC(f)  ((RUBY_DATA_FUNC) f)
00875 #    endif
00876 #  endif
00877 #else
00878 #  define VALUEFUNC(f) (f)
00879 #  define VOIDFUNC(f) (f)
00880 #endif
00881 
00882 /* Don't use for expressions have side effect */
00883 #ifndef RB_STRING_VALUE
00884 #define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
00885 #endif
00886 #ifndef StringValue
00887 #define StringValue(s) RB_STRING_VALUE(s)
00888 #endif
00889 #ifndef StringValuePtr
00890 #define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
00891 #endif
00892 #ifndef StringValueLen
00893 #define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
00894 #endif
00895 #ifndef SafeStringValue
00896 #define SafeStringValue(v) do {\
00897     StringValue(v);\
00898     rb_check_safe_str(v);\
00899 } while (0)
00900 #endif
00901 
00902 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
00903 #define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
00904 #define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
00905 #endif
00906 
00907 
00908 /* -----------------------------------------------------------------------------
00909  * error manipulation
00910  * ----------------------------------------------------------------------------- */
00911 
00912 
00913 /* Define some additional error types */
00914 #define SWIG_ObjectPreviouslyDeletedError  -100
00915 
00916 
00917 /* Define custom exceptions for errors that do not map to existing Ruby
00918    exceptions.  Note this only works for C++ since a global cannot be
00919    initialized by a funtion in C.  For C, fallback to rb_eRuntimeError.*/
00920 
00921 SWIGINTERN VALUE 
00922 getNullReferenceError(void) {
00923   static int init = 0;
00924   static VALUE rb_eNullReferenceError ;
00925   if (!init) {
00926     init = 1;
00927     rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
00928   }
00929   return rb_eNullReferenceError;
00930 } 
00931 
00932 SWIGINTERN VALUE 
00933 getObjectPreviouslyDeletedError(void) {
00934   static int init = 0;
00935   static VALUE rb_eObjectPreviouslyDeleted ;
00936   if (!init) {
00937     init = 1;
00938     rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
00939   }
00940   return rb_eObjectPreviouslyDeleted;
00941 } 
00942 
00943 
00944 SWIGINTERN VALUE
00945 SWIG_Ruby_ErrorType(int SWIG_code) {
00946   VALUE type;
00947   switch (SWIG_code) {
00948   case SWIG_MemoryError:
00949     type = rb_eNoMemError;
00950     break;
00951   case SWIG_IOError:
00952     type = rb_eIOError;
00953     break;
00954   case SWIG_RuntimeError:
00955     type = rb_eRuntimeError;
00956     break;
00957   case SWIG_IndexError:
00958     type = rb_eIndexError;
00959     break;
00960   case SWIG_TypeError:
00961     type = rb_eTypeError;
00962     break;
00963   case SWIG_DivisionByZero:
00964     type = rb_eZeroDivError;
00965     break;
00966   case SWIG_OverflowError:
00967     type = rb_eRangeError;
00968     break;
00969   case SWIG_SyntaxError:
00970     type = rb_eSyntaxError;
00971     break;
00972   case SWIG_ValueError:
00973     type = rb_eArgError;
00974     break;
00975   case SWIG_SystemError:
00976     type = rb_eFatal;
00977     break;
00978   case SWIG_AttributeError:
00979     type = rb_eRuntimeError;
00980     break;
00981   case SWIG_NullReferenceError:
00982     type = getNullReferenceError();
00983     break;
00984   case SWIG_ObjectPreviouslyDeletedError:
00985     type = getObjectPreviouslyDeletedError();
00986     break;
00987   case SWIG_UnknownError:
00988     type = rb_eRuntimeError;
00989     break;
00990   default:
00991     type = rb_eRuntimeError;
00992   }
00993   return type;
00994 }
00995 
00996 
00997 
00998 
00999 /* -----------------------------------------------------------------------------
01000  * See the LICENSE file for information on copyright, usage and redistribution
01001  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
01002  *
01003  * rubytracking.swg
01004  *
01005  * This file contains support for tracking mappings from 
01006  * Ruby objects to C++ objects.  This functionality is needed
01007  * to implement mark functions for Ruby's mark and sweep
01008  * garbage collector.
01009  * ----------------------------------------------------------------------------- */
01010 
01011 #ifdef __cplusplus
01012 extern "C" {
01013 #endif
01014 
01015 
01016 /* Global Ruby hash table to store Trackings from C/C++
01017    structs to Ruby Objects. */
01018 static VALUE swig_ruby_trackings;
01019 
01020 /* Global variable that stores a reference to the ruby
01021    hash table delete function. */
01022 static ID swig_ruby_hash_delete = 0;
01023 
01024 /* Setup a Ruby hash table to store Trackings */
01025 SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
01026   /* Create a ruby hash table to store Trackings from C++ 
01027      objects to Ruby objects.  Also make sure to tell
01028      the garabage collector about the hash table. */
01029   swig_ruby_trackings = rb_hash_new();
01030   rb_gc_register_address(&swig_ruby_trackings);
01031   
01032   /* Now store a reference to the hash table delete function
01033      so that we only have to look it up once.*/
01034   swig_ruby_hash_delete = rb_intern("delete");
01035 }
01036 
01037 /* Get a Ruby number to reference a pointer */
01038 SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
01039   /* We cast the pointer to an unsigned long
01040      and then store a reference to it using
01041      a Ruby number object. */
01042 
01043   /* Convert the pointer to a Ruby number */
01044   unsigned long value = (unsigned long) ptr;
01045   return LONG2NUM(value);
01046 }
01047 
01048 /* Get a Ruby number to reference an object */
01049 SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
01050   /* We cast the object to an unsigned long
01051      and then store a reference to it using
01052      a Ruby number object. */
01053 
01054   /* Convert the Object to a Ruby number */
01055   unsigned long value = (unsigned long) object;
01056   return LONG2NUM(value);
01057 }
01058 
01059 /* Get a Ruby object from a previously stored reference */
01060 SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
01061   /* The provided Ruby number object is a reference
01062      to the Ruby object we want.*/
01063 
01064   /* First convert the Ruby number to a C number */
01065   unsigned long value = NUM2LONG(reference);
01066   return (VALUE) value;
01067 }
01068 
01069 /* Add a Tracking from a C/C++ struct to a Ruby object */
01070 SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
01071   /* In a Ruby hash table we store the pointer and
01072      the associated Ruby object.  The trick here is
01073      that we cannot store the Ruby object directly - if
01074      we do then it cannot be garbage collected.  So
01075      instead we typecast it as a unsigned long and
01076      convert it to a Ruby number object.*/
01077 
01078   /* Get a reference to the pointer as a Ruby number */
01079   VALUE key = SWIG_RubyPtrToReference(ptr);
01080 
01081   /* Get a reference to the Ruby object as a Ruby number */
01082   VALUE value = SWIG_RubyObjectToReference(object);
01083 
01084   /* Store the mapping to the global hash table. */
01085   rb_hash_aset(swig_ruby_trackings, key, value);
01086 }
01087 
01088 /* Get the Ruby object that owns the specified C/C++ struct */
01089 SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
01090   /* Get a reference to the pointer as a Ruby number */
01091   VALUE key = SWIG_RubyPtrToReference(ptr);
01092 
01093   /* Now lookup the value stored in the global hash table */
01094   VALUE value = rb_hash_aref(swig_ruby_trackings, key);
01095         
01096   if (value == Qnil) {
01097     /* No object exists - return nil. */
01098     return Qnil;
01099   }
01100   else {
01101     /* Convert this value to Ruby object */
01102     return SWIG_RubyReferenceToObject(value);
01103   }
01104 }
01105 
01106 /* Remove a Tracking from a C/C++ struct to a Ruby object.  It
01107    is very important to remove objects once they are destroyed
01108    since the same memory address may be reused later to create
01109    a new object. */
01110 SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
01111   /* Get a reference to the pointer as a Ruby number */
01112   VALUE key = SWIG_RubyPtrToReference(ptr);
01113 
01114   /* Delete the object from the hash table by calling Ruby's
01115      do this we need to call the Hash.delete method.*/
01116   rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key);
01117 }
01118 
01119 /* This is a helper method that unlinks a Ruby object from its
01120    underlying C++ object.  This is needed if the lifetime of the
01121    Ruby object is longer than the C++ object */
01122 SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
01123   VALUE object = SWIG_RubyInstanceFor(ptr);
01124 
01125   if (object != Qnil) {
01126     DATA_PTR(object) = 0;
01127   }
01128 }
01129 
01130 
01131 #ifdef __cplusplus
01132 }
01133 #endif
01134 
01135 /* -----------------------------------------------------------------------------
01136  * Ruby API portion that goes into the runtime
01137  * ----------------------------------------------------------------------------- */
01138 
01139 #ifdef __cplusplus
01140 extern "C" {
01141 #endif
01142 
01143 SWIGINTERN VALUE
01144 SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
01145   if (NIL_P(target)) {
01146     target = o;
01147   } else {
01148     if (TYPE(target) != T_ARRAY) {
01149       VALUE o2 = target;
01150       target = rb_ary_new();
01151       rb_ary_push(target, o2);
01152     }
01153     rb_ary_push(target, o);
01154   }
01155   return target;
01156 }
01157 
01158 #ifdef __cplusplus
01159 }
01160 #endif
01161 
01162 
01163 /* -----------------------------------------------------------------------------
01164  * See the LICENSE file for information on copyright, usage and redistribution
01165  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
01166  *
01167  * rubyrun.swg
01168  *
01169  * This file contains the runtime support for Ruby modules
01170  * and includes code for managing global variables and pointer
01171  * type checking.
01172  * ----------------------------------------------------------------------------- */
01173 
01174 /* For backward compatibility only */
01175 #define SWIG_POINTER_EXCEPTION  0
01176 
01177 /* for raw pointers */
01178 #define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
01179 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
01180 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Ruby_NewPointerObj(ptr, type, flags)
01181 #define SWIG_AcquirePtr(ptr, own)                       SWIG_Ruby_AcquirePtr(ptr, own)
01182 #define swig_owntype                                    ruby_owntype
01183 
01184 /* for raw packed data */
01185 #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
01186 #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
01187 
01188 /* for class or struct pointers */
01189 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
01190 #define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)
01191 
01192 /* for C or C++ function pointers */
01193 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_ConvertPtr(obj, pptr, type, 0)
01194 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_NewPointerObj(ptr, type, 0)
01195 
01196 /* for C++ member pointers, ie, member methods */
01197 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
01198 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Ruby_NewPackedObj(ptr, sz, type)
01199 
01200 
01201 /* Runtime API */
01202 
01203 #define SWIG_GetModule(clientdata)                      SWIG_Ruby_GetModule()   
01204 #define SWIG_SetModule(clientdata, pointer)             SWIG_Ruby_SetModule(pointer)
01205 
01206 
01207 /* Error manipulation */
01208 
01209 #define SWIG_ErrorType(code)                            SWIG_Ruby_ErrorType(code)               
01210 #define SWIG_Error(code, msg)                           rb_raise(SWIG_Ruby_ErrorType(code), msg)
01211 #define SWIG_fail                                       goto fail                                
01212 
01213 
01214 /* Ruby-specific SWIG API */
01215 
01216 #define SWIG_InitRuntime()                              SWIG_Ruby_InitRuntime()              
01217 #define SWIG_define_class(ty)                           SWIG_Ruby_define_class(ty)
01218 #define SWIG_NewClassInstance(value, ty)                SWIG_Ruby_NewClassInstance(value, ty)
01219 #define SWIG_MangleStr(value)                           SWIG_Ruby_MangleStr(value)                
01220 #define SWIG_CheckConvert(value, ty)                    SWIG_Ruby_CheckConvert(value, ty)         
01221 
01222 
01223 /* -----------------------------------------------------------------------------
01224  * pointers/data manipulation
01225  * ----------------------------------------------------------------------------- */
01226 
01227 #ifdef __cplusplus
01228 extern "C" {
01229 #if 0
01230 } /* cc-mode */
01231 #endif
01232 #endif
01233 
01234 typedef struct {
01235   VALUE klass;
01236   VALUE mImpl;
01237   void  (*mark)(void *);
01238   void  (*destroy)(void *);
01239   int trackObjects;
01240 } swig_class;
01241 
01242 
01243 static VALUE _mSWIG = Qnil;
01244 static VALUE _cSWIG_Pointer = Qnil;
01245 static VALUE swig_runtime_data_type_pointer = Qnil;
01246 
01247 SWIGRUNTIME VALUE 
01248 getExceptionClass(void) {
01249   static int init = 0;
01250   static VALUE rubyExceptionClass ;
01251   if (!init) {
01252     init = 1;
01253     rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
01254   }
01255   return rubyExceptionClass;
01256 } 
01257 
01258 /* This code checks to see if the Ruby object being raised as part
01259    of an exception inherits from the Ruby class Exception.  If so,
01260    the object is simply returned.  If not, then a new Ruby exception
01261    object is created and that will be returned to Ruby.*/
01262 SWIGRUNTIME VALUE
01263 SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
01264   VALUE exceptionClass = getExceptionClass();
01265   if (rb_obj_is_kind_of(obj, exceptionClass)) {
01266     return obj;
01267   }  else {
01268     return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
01269   }
01270 }
01271 
01272 /* Initialize Ruby runtime support */
01273 SWIGRUNTIME void
01274 SWIG_Ruby_InitRuntime(void)
01275 {
01276   if (_mSWIG == Qnil) {
01277     _mSWIG = rb_define_module("SWIG");
01278   }
01279 }
01280 
01281 /* Define Ruby class for C type */
01282 SWIGRUNTIME void
01283 SWIG_Ruby_define_class(swig_type_info *type)
01284 {
01285   VALUE klass;
01286   char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
01287   sprintf(klass_name, "TYPE%s", type->name);
01288   if (NIL_P(_cSWIG_Pointer)) {
01289     _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
01290     rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
01291   }
01292   klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
01293   free((void *) klass_name);
01294 }
01295 
01296 /* Create a new pointer object */
01297 SWIGRUNTIME VALUE
01298 SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
01299 {
01300   int own =  flags & SWIG_POINTER_OWN; 
01301   
01302   char *klass_name;
01303   swig_class *sklass;
01304   VALUE klass;
01305   VALUE obj;
01306   
01307   if (!ptr)
01308     return Qnil;
01309   
01310   if (type->clientdata) {
01311     sklass = (swig_class *) type->clientdata;
01312                 
01313     /* Are we tracking this class and have we already returned this Ruby object? */
01314     if (sklass->trackObjects) {
01315       obj = SWIG_RubyInstanceFor(ptr);
01316       
01317       /* Check the object's type and make sure it has the correct type.
01318         It might not in cases where methods do things like 
01319         downcast methods. */
01320       if (obj != Qnil) {
01321         VALUE value = rb_iv_get(obj, "__swigtype__");
01322         char* type_name = RSTRING_PTR(value);
01323                                 
01324         if (strcmp(type->name, type_name) == 0) {
01325           return obj;
01326         }
01327       }
01328     }
01329 
01330     /* Create a new Ruby object */
01331     obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), (own ? VOIDFUNC(sklass->destroy) : 0), ptr);
01332 
01333     /* If tracking is on for this class then track this object. */
01334     if (sklass->trackObjects) {
01335       SWIG_RubyAddTracking(ptr, obj);
01336     }
01337   } else {
01338     klass_name = (char *) malloc(4 + strlen(type->name) + 1);
01339     sprintf(klass_name, "TYPE%s", type->name);
01340     klass = rb_const_get(_mSWIG, rb_intern(klass_name));
01341     free((void *) klass_name);
01342     obj = Data_Wrap_Struct(klass, 0, 0, ptr);
01343   }
01344   rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
01345   
01346   return obj;
01347 }
01348 
01349 /* Create a new class instance (always owned) */
01350 SWIGRUNTIME VALUE
01351 SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
01352 {
01353   VALUE obj;
01354   swig_class *sklass = (swig_class *) type->clientdata;
01355   obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
01356   rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name));
01357   return obj;
01358 }
01359 
01360 /* Get type mangle from class name */
01361 SWIGRUNTIMEINLINE char *
01362 SWIG_Ruby_MangleStr(VALUE obj)
01363 {
01364   VALUE stype = rb_iv_get(obj, "__swigtype__");
01365   return StringValuePtr(stype);
01366 }
01367 
01368 /* Acquire a pointer value */
01369 typedef void (*ruby_owntype)(void*);
01370 
01371 SWIGRUNTIME ruby_owntype
01372 SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {
01373   if (obj) {
01374     ruby_owntype oldown = RDATA(obj)->dfree;
01375     RDATA(obj)->dfree = own;
01376     return oldown;
01377   } else {
01378     return 0;
01379   }
01380 }
01381 
01382 /* Convert a pointer value */
01383 SWIGRUNTIME int
01384 SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own)
01385 {
01386   char *c;
01387   swig_cast_info *tc;
01388   void *vptr = 0;
01389 
01390   /* Grab the pointer */
01391   if (NIL_P(obj)) {
01392     *ptr = 0;
01393     return SWIG_OK;
01394   } else {
01395     if (TYPE(obj) != T_DATA) {
01396       return SWIG_ERROR;
01397     }
01398     Data_Get_Struct(obj, void, vptr);
01399   }
01400   
01401   if (own) *own = RDATA(obj)->dfree;
01402     
01403   /* Check to see if the input object is giving up ownership
01404      of the underlying C struct or C++ object.  If so then we
01405      need to reset the destructor since the Ruby object no 
01406      longer owns the underlying C++ object.*/ 
01407   if (flags & SWIG_POINTER_DISOWN) {
01408     /* Is tracking on for this class? */
01409     int track = 0;
01410     if (ty && ty->clientdata) {
01411       swig_class *sklass = (swig_class *) ty->clientdata;
01412       track = sklass->trackObjects;
01413     }
01414                 
01415     if (track) {
01416       /* We are tracking objects for this class.  Thus we change the destructor
01417        * to SWIG_RubyRemoveTracking.  This allows us to
01418        * remove the mapping from the C++ to Ruby object
01419        * when the Ruby object is garbage collected.  If we don't
01420        * do this, then it is possible we will return a reference 
01421        * to a Ruby object that no longer exists thereby crashing Ruby. */
01422       RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
01423     } else {    
01424       RDATA(obj)->dfree = 0;
01425     }
01426   }
01427 
01428   /* Do type-checking if type info was provided */
01429   if (ty) {
01430     if (ty->clientdata) {
01431       if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
01432         if (vptr == 0) {
01433           /* The object has already been deleted */
01434           return SWIG_ObjectPreviouslyDeletedError;
01435         }
01436         *ptr = vptr;
01437         return SWIG_OK;
01438       }
01439     }
01440     if ((c = SWIG_MangleStr(obj)) == NULL) {
01441       return SWIG_ERROR;
01442     }
01443     tc = SWIG_TypeCheck(c, ty);
01444     if (!tc) {
01445       return SWIG_ERROR;
01446     }
01447     *ptr = SWIG_TypeCast(tc, vptr);
01448   } else {
01449     *ptr = vptr;
01450   }
01451   
01452   return SWIG_OK;
01453 }
01454 
01455 /* Check convert */
01456 SWIGRUNTIMEINLINE int
01457 SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
01458 {
01459   char *c = SWIG_MangleStr(obj);
01460   if (!c) return 0;
01461   return SWIG_TypeCheck(c,ty) != 0;
01462 }
01463 
01464 SWIGRUNTIME VALUE
01465 SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
01466   char result[1024];
01467   char *r = result;
01468   if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
01469   *(r++) = '_';
01470   r = SWIG_PackData(r, ptr, sz);
01471   strcpy(r, type->name);
01472   return rb_str_new2(result);
01473 }
01474 
01475 /* Convert a packed value value */
01476 SWIGRUNTIME int
01477 SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
01478   swig_cast_info *tc;
01479   const char  *c;
01480 
01481   if (TYPE(obj) != T_STRING) goto type_error;
01482   c = StringValuePtr(obj);
01483   /* Pointer values must start with leading underscore */
01484   if (*c != '_') goto type_error;
01485   c++;
01486   c = SWIG_UnpackData(c, ptr, sz);
01487   if (ty) {
01488     tc = SWIG_TypeCheck(c, ty);
01489     if (!tc) goto type_error;
01490   }
01491   return SWIG_OK;
01492 
01493  type_error:
01494   return SWIG_ERROR;
01495 }
01496 
01497 SWIGRUNTIME swig_module_info *
01498 SWIG_Ruby_GetModule(void)
01499 {
01500   VALUE pointer;
01501   swig_module_info *ret = 0;
01502   VALUE verbose = rb_gv_get("VERBOSE");
01503 
01504  /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
01505   rb_gv_set("VERBOSE", Qfalse);
01506   
01507   /* first check if pointer already created */
01508   pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
01509   if (pointer != Qnil) {
01510     Data_Get_Struct(pointer, swig_module_info, ret);
01511   }
01512 
01513   /* reinstate warnings */
01514   rb_gv_set("VERBOSE", verbose);
01515   return ret;
01516 }
01517 
01518 SWIGRUNTIME void 
01519 SWIG_Ruby_SetModule(swig_module_info *pointer)
01520 {
01521   /* register a new class */
01522   VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
01523   /* create and store the structure pointer to a global variable */
01524   swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
01525   rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
01526 }
01527 
01528 #ifdef __cplusplus
01529 #if 0
01530 { /* cc-mode */
01531 #endif
01532 }
01533 #endif
01534 
01535 
01536 
01537 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
01538 
01539 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
01540 
01541 
01542 
01543   #define SWIG_exception(code, msg) do { SWIG_Error(code, msg);; } while(0) 
01544 
01545 /* -----------------------------------------------------------------------------
01546  * See the LICENSE file for information on copyright, usage and redistribution
01547  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
01548  *
01549  * director.swg
01550  *
01551  * This file contains support for director classes that proxy
01552  * method calls from C++ to Ruby extensions.
01553  * ----------------------------------------------------------------------------- */
01554 
01555 /*
01556   Use -DSWIG_DIRECTOR_NOUEH if you prefer to avoid the use of the
01557   Undefined Exception Handler provided by swift
01558 */
01559 #ifndef SWIG_DIRECTOR_NOUEH
01560 #ifndef SWIG_DIRECTOR_UEH
01561 #define SWIG_DIRECTOR_UEH
01562 #endif
01563 #endif
01564 
01565 #ifdef __cplusplus
01566 
01567 #include <string>
01568 #include <iostream>
01569 #include <map>
01570 
01571 namespace Swig {
01572   /* memory handler */
01573   struct GCItem 
01574   {
01575     virtual ~GCItem()
01576     {
01577     }
01578 
01579     virtual ruby_owntype get_own() const
01580     {
01581       return 0;
01582     }
01583   };
01584   
01585   struct GCItem_var
01586   {
01587     GCItem_var(GCItem *item = 0) : _item(item)
01588     {
01589     }
01590 
01591     GCItem_var& operator=(GCItem *item)
01592     {
01593       GCItem *tmp = _item;
01594       _item = item;
01595       delete tmp;
01596       return *this;
01597     }
01598     
01599     ~GCItem_var() 
01600     {
01601       delete _item;
01602     }
01603     
01604     GCItem * operator->() const
01605     {
01606       return _item;
01607     }
01608     
01609   private:
01610     GCItem *_item;
01611   };
01612 
01613 
01614   template <typename Type>
01615   struct GCItem_T : GCItem
01616   {
01617     GCItem_T(Type *ptr) : _ptr(ptr)
01618     {
01619     }
01620     
01621     virtual ~GCItem_T() 
01622     {
01623       delete _ptr;
01624     }
01625     
01626   private:
01627     Type *_ptr;
01628   };
01629 
01630   struct GCItem_Object : GCItem
01631   {
01632     GCItem_Object(ruby_owntype own) : _own(own)
01633     {
01634     }
01635     
01636     virtual ~GCItem_Object() 
01637     {
01638     }
01639 
01640     ruby_owntype get_own() const
01641     {
01642       return _own;
01643     }
01644     
01645   private:
01646     ruby_owntype _own;
01647   };
01648 
01649 
01650   template <typename Type>
01651   struct GCArray_T : GCItem
01652   {
01653     GCArray_T(Type *ptr) : _ptr(ptr)
01654     {
01655     }
01656     
01657     virtual ~GCArray_T() 
01658     {
01659       delete[] _ptr;
01660     }
01661     
01662   private:
01663     Type *_ptr;
01664   };
01665 
01666 
01667   /* body args */
01668   struct body_args {
01669     VALUE recv;
01670     ID id;
01671     int argc;
01672     VALUE *argv;
01673   };
01674   
01675   /* Base class for director exceptions */
01676   class DirectorException {
01677   protected:
01678     VALUE swig_error;
01679     std::string swig_msg;
01680   protected:
01681     DirectorException(VALUE error)
01682       : swig_error(error)
01683     {
01684     }
01685     
01686     DirectorException(VALUE error, const char* hdr, const char* msg ="") 
01687       : swig_error(error), swig_msg(hdr) {
01688       if (strlen(msg)) {
01689         swig_msg += " ";
01690         swig_msg += msg;
01691       }
01692       if (swig_msg.size()) {
01693         VALUE str = rb_str_new(swig_msg.data(), swig_msg.size());
01694         swig_error = rb_exc_new3(error, str);
01695       } else {
01696         swig_error = error;
01697       }
01698     }
01699   public:
01700     VALUE getType() const  { 
01701       return CLASS_OF(swig_error); 
01702     }
01703     VALUE getError() const {
01704       return swig_error;
01705     }
01706     const std::string& getMessage() const 
01707     {
01708       return swig_msg;
01709     }
01710     
01711     virtual ~DirectorException() {}
01712   };
01713   
01714   /* unknown exception handler  */
01715 
01716   class UnknownExceptionHandler 
01717   {
01718 #ifdef SWIG_DIRECTOR_UEH
01719     static void handler() {
01720       try {
01721         throw;
01722       } catch (DirectorException& e) {
01723         std::cerr << "Swig Director exception caught:" << std::endl
01724                   << e.getMessage() << std::endl;
01725       } catch (std::exception& e) {
01726         std::cerr << "std::exception caught: "<< e.what() << std::endl;
01727       } catch (...) {
01728         std::cerr << "Unknown exception caught." << std::endl;
01729       }      
01730       std::cerr << std::endl
01731                 << "Ruby interpreter traceback:" << std::endl;
01732       std::cerr << std::endl;      
01733       std::cerr << "This exception was caught by the SWIG unexpected exception handler." << std::endl
01734                 << "Try using %feature(\"director:except\") to avoid reaching this point." << std::endl
01735                 << std::endl
01736                 << "Exception is being re-thrown, program will like abort/terminate." << std::endl;
01737       throw;
01738     }
01739     
01740   public:    
01741     std::unexpected_handler old;
01742     UnknownExceptionHandler(std::unexpected_handler nh = handler)
01743     {
01744       old = std::set_unexpected(nh);
01745     }
01746 
01747     ~UnknownExceptionHandler()
01748     {
01749       std::set_unexpected(old);
01750     }
01751 #endif
01752   };
01753 
01754 
01755   /* Type mismatch in the return value from a Ruby method call */
01756   class DirectorTypeMismatchException : public Swig::DirectorException {
01757   public:
01758     DirectorTypeMismatchException(VALUE error, const char *msg="")
01759       : Swig::DirectorException(error, "Swig director type mismatch", msg) 
01760     {
01761     }
01762 
01763     DirectorTypeMismatchException(const char *msg="")
01764       : Swig::DirectorException(rb_eTypeError, "Swig director type mismatch", msg) 
01765     {
01766     }
01767 
01768     static void raise(VALUE error, const char *msg) {
01769       throw DirectorTypeMismatchException(error, msg);
01770     }
01771 
01772     static void raise(const char *msg) {
01773       throw DirectorTypeMismatchException(msg);
01774     }
01775   };
01776 
01777   /* Any Ruby exception that occurs during a director method call */
01778   class DirectorMethodException : public Swig::DirectorException {
01779   public:
01780     DirectorMethodException(VALUE error) 
01781       : Swig::DirectorException(error) {
01782     }
01783 
01784     DirectorMethodException(const char* msg = "") 
01785       : Swig::DirectorException(rb_eRuntimeError, "Swig director method error", msg) {
01786     }
01787     
01788     static void raise(VALUE error)
01789     {
01790       throw DirectorMethodException(error);
01791     }    
01792   };
01793 
01794   /* Attempted to call a pure virtual method via a director method */
01795   class DirectorPureVirtualException : public Swig::DirectorException
01796   {
01797   public:
01798     DirectorPureVirtualException(const char* msg = "") 
01799       : DirectorException(rb_eRuntimeError, "Swig director pure virtual method called", msg)
01800     { 
01801     }
01802 
01803     static void raise(const char *msg) 
01804     {
01805       throw DirectorPureVirtualException(msg);
01806     }
01807   };
01808 
01809   /* Simple thread abstraction for pthreads on win32 */
01810 #ifdef __THREAD__
01811 # define __PTHREAD__
01812 # if defined(_WIN32) || defined(__WIN32__)
01813 #  define pthread_mutex_lock EnterCriticalSection
01814 #  define pthread_mutex_unlock LeaveCriticalSection
01815 #  define pthread_mutex_t CRITICAL_SECTION
01816 #  define SWIG_MUTEX_INIT(var) var
01817 # else
01818 #  include <pthread.h>
01819 #  define SWIG_MUTEX_INIT(var) var = PTHREAD_MUTEX_INITIALIZER 
01820 # endif
01821 #endif
01822 
01823 #ifdef  __PTHREAD__
01824   struct Guard
01825   {
01826     pthread_mutex_t *_mutex;
01827     
01828     Guard(pthread_mutex_t &mutex) : _mutex(&mutex)
01829     {
01830       pthread_mutex_lock(_mutex);
01831     }
01832     
01833     ~Guard()
01834     {
01835       pthread_mutex_unlock(_mutex);
01836     }
01837   };
01838 # define SWIG_GUARD(mutex) Guard _guard(mutex)
01839 #else
01840 # define SWIG_GUARD(mutex) 
01841 #endif
01842 
01843   /* director base class */
01844   class Director {
01845   private:
01846     /* pointer to the wrapped Ruby object */
01847     VALUE swig_self;
01848     /* flag indicating whether the object is owned by Ruby or c++ */
01849     mutable bool swig_disown_flag;
01850 
01851   public:
01852     /* wrap a Ruby object, optionally taking ownership */
01853     Director(VALUE self) : swig_self(self), swig_disown_flag(false) {
01854     }
01855 
01856     /* discard our reference at destruction */
01857     virtual ~Director() {
01858     }
01859 
01860     /* return a pointer to the wrapped Ruby object */
01861     VALUE swig_get_self() const { 
01862       return swig_self; 
01863     }
01864 
01865     /* acquire ownership of the wrapped Ruby object (the sense of "disown"
01866      * is from Ruby) */
01867     void swig_disown() const { 
01868       if (!swig_disown_flag) { 
01869         swig_disown_flag = true;
01870       } 
01871     }
01872 
01873   /* ownership management */
01874   private:
01875     typedef std::map<void*, GCItem_var> ownership_map;
01876     mutable ownership_map owner;
01877 #ifdef __PTHREAD__
01878     static pthread_mutex_t swig_mutex_own;
01879 #endif
01880 
01881   public:
01882     template <typename Type>
01883     void swig_acquire_ownership_array(Type *vptr)  const
01884     {
01885       if (vptr) {
01886         SWIG_GUARD(swig_mutex_own);
01887         owner[vptr] = new GCArray_T<Type>(vptr);
01888       }
01889     }
01890     
01891     template <typename Type>
01892     void swig_acquire_ownership(Type *vptr)  const
01893     {
01894       if (vptr) {       
01895         SWIG_GUARD(swig_mutex_own);
01896         owner[vptr] = new GCItem_T<Type>(vptr);
01897       }
01898     }
01899 
01900     void swig_acquire_ownership_obj(void *vptr, ruby_owntype own) const
01901     {
01902       if (vptr && own) {
01903         SWIG_GUARD(swig_mutex_own);
01904         owner[vptr] = new GCItem_Object(own);
01905       }
01906     }
01907     
01908     ruby_owntype swig_release_ownership(void *vptr) const
01909     {
01910       ruby_owntype own = 0;
01911       if (vptr) {
01912         SWIG_GUARD(swig_mutex_own);
01913         ownership_map::iterator iter = owner.find(vptr);
01914         if (iter != owner.end()) {
01915           own = iter->second->get_own();
01916           owner.erase(iter);
01917         }
01918       }
01919       return own;
01920     }
01921   };
01922 }
01923 
01924 #endif /* __cplusplus */
01925 
01926 
01927 
01928 /* -------- TYPES TABLE (BEGIN) -------- */
01929 
01930 #define SWIGTYPE_p_FUNCPTR swig_types[0]
01931 #define SWIGTYPE_p_SDL_Event swig_types[1]
01932 #define SWIGTYPE_p_bool swig_types[2]
01933 #define SWIGTYPE_p_callbackFunc swig_types[3]
01934 #define SWIGTYPE_p_char swig_types[4]
01935 #define SWIGTYPE_p_eCamera swig_types[5]
01936 #define SWIGTYPE_p_eCoord swig_types[6]
01937 #define SWIGTYPE_p_eFace swig_types[7]
01938 #define SWIGTYPE_p_eGameObject swig_types[8]
01939 #define SWIGTYPE_p_eGrid swig_types[9]
01940 #define SWIGTYPE_p_eHalfEdge swig_types[10]
01941 #define SWIGTYPE_p_eNetGameObject swig_types[11]
01942 #define SWIGTYPE_p_ePlayerNetID swig_types[12]
01943 #define SWIGTYPE_p_eSensor swig_types[13]
01944 #define SWIGTYPE_p_eTeam swig_types[14]
01945 #define SWIGTYPE_p_eTempEdge swig_types[15]
01946 #define SWIGTYPE_p_eWall swig_types[16]
01947 #define SWIGTYPE_p_f___void swig_types[17]
01948 #define SWIGTYPE_p_float swig_types[18]
01949 #define SWIGTYPE_p_gCycle swig_types[19]
01950 #define SWIGTYPE_p_gCycleMemory swig_types[20]
01951 #define SWIGTYPE_p_gCycleMovement swig_types[21]
01952 #define SWIGTYPE_p_gDestination swig_types[22]
01953 #define SWIGTYPE_p_gPlayerWall swig_types[23]
01954 #define SWIGTYPE_p_gRealColor swig_types[24]
01955 #define SWIGTYPE_p_gSensor swig_types[25]
01956 #define SWIGTYPE_p_gSensorWallType swig_types[26]
01957 #define SWIGTYPE_p_gSimpleAI swig_types[27]
01958 #define SWIGTYPE_p_gSimpleAIFactory swig_types[28]
01959 #define SWIGTYPE_p_gTextureCycle swig_types[29]
01960 #define SWIGTYPE_p_int swig_types[30]
01961 #define SWIGTYPE_p_ios_base__openmode swig_types[31]
01962 #define SWIGTYPE_p_istream swig_types[32]
01963 #define SWIGTYPE_p_istringstream swig_types[33]
01964 #define SWIGTYPE_p_nDescriptor swig_types[34]
01965 #define SWIGTYPE_p_nMachine swig_types[35]
01966 #define SWIGTYPE_p_nMessage swig_types[36]
01967 #define SWIGTYPE_p_nNetObject swig_types[37]
01968 #define SWIGTYPE_p_nNetObjectRegistrar swig_types[38]
01969 #define SWIGTYPE_p_nObserver swig_types[39]
01970 #define SWIGTYPE_p_rModel swig_types[40]
01971 #define SWIGTYPE_p_std__dequeTtString_t swig_types[41]
01972 #define SWIGTYPE_p_std__fstream swig_types[42]
01973 #define SWIGTYPE_p_std__ifstream swig_types[43]
01974 #define SWIGTYPE_p_std__ios__openmode swig_types[44]
01975 #define SWIGTYPE_p_std__ofstream swig_types[45]
01976 #define SWIGTYPE_p_std__ostream swig_types[46]
01977 #define SWIGTYPE_p_streambuf swig_types[47]
01978 #define SWIGTYPE_p_tArrayTtString_t swig_types[48]
01979 #define SWIGTYPE_p_tColoredString swig_types[49]
01980 #define SWIGTYPE_p_tConfItemBase swig_types[50]
01981 #define SWIGTYPE_p_tConsole swig_types[51]
01982 #define SWIGTYPE_p_tDirectories swig_types[52]
01983 #define SWIGTYPE_p_tOutput swig_types[53]
01984 #define SWIGTYPE_p_tPath swig_types[54]
01985 #define SWIGTYPE_p_tPathResource swig_types[55]
01986 #define SWIGTYPE_p_tPathScripts swig_types[56]
01987 #define SWIGTYPE_p_tString swig_types[57]
01988 #define SWIGTYPE_p_uActionPlayer swig_types[58]
01989 #define SWIGTYPE_p_uAutoCompleter swig_types[59]
01990 #define SWIGTYPE_p_uMenu swig_types[60]
01991 #define SWIGTYPE_p_uMenuItem swig_types[61]
01992 #define SWIGTYPE_p_uMenuItemAction swig_types[62]
01993 #define SWIGTYPE_p_uMenuItemExit swig_types[63]
01994 #define SWIGTYPE_p_uMenuItemFunction swig_types[64]
01995 #define SWIGTYPE_p_uMenuItemFunctionInt swig_types[65]
01996 #define SWIGTYPE_p_uMenuItemInt swig_types[66]
01997 #define SWIGTYPE_p_uMenuItemString swig_types[67]
01998 #define SWIGTYPE_p_uMenuItemStringWithHistory swig_types[68]
01999 #define SWIGTYPE_p_uMenuItemSubmenu swig_types[69]
02000 #define SWIGTYPE_p_uMenuItemToggle swig_types[70]
02001 #define SWIGTYPE_p_unsigned_short swig_types[71]
02002 static swig_type_info *swig_types[73];
02003 static swig_module_info swig_module = {swig_types, 72, 0, 0, 0, 0};
02004 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
02005 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
02006 
02007 /* -------- TYPES TABLE (END) -------- */
02008 
02009 #define SWIG_init    Init_armagetronad
02010 #define SWIG_name    "Armagetronad"
02011 
02012 static VALUE mArmagetronad;
02013 
02014 #define SWIGVERSION 0x010331 
02015 #define SWIG_VERSION SWIGVERSION
02016 
02017 
02018 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
02019 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
02020 
02021 
02022 #include <stdexcept>
02023 
02024 
02025 #include <stdexcept>
02026 
02027 
02028 #include <string>
02029 
02030 #define SWIG_FLOAT_P(x) ((TYPE(x) == T_FLOAT) || FIXNUM_P(x))
02031 
02032 bool SWIG_BOOL_P(VALUE) {
02033     // dummy test, RTEST should take care of everything
02034     return true;
02035 }
02036 bool SWIG_RB2BOOL(VALUE x) {
02037     return RTEST(x);
02038 }
02039 VALUE SWIG_BOOL2RB(bool b) {
02040     return b ? Qtrue : Qfalse;
02041 }
02042 double SWIG_NUM2DBL(VALUE x) {
02043     return (FIXNUM_P(x) ? FIX2INT(x) : NUM2DBL(x));
02044 }
02045 bool SWIG_STRING_P(VALUE x) {
02046     return TYPE(x) == T_STRING;
02047 }
02048 std::string SWIG_RB2STR(VALUE x) {
02049     return std::string(RSTRING_PTR(x), RSTRING_LEN(x));
02050 }
02051 VALUE SWIG_STR2RB(const std::string& s) {
02052     return rb_str_new(s.data(), s.size());
02053 }
02054 
02055 
02056 #include <string>
02057 
02058 
02059 #include <vector>
02060 #include <algorithm>
02061 #include <stdexcept>
02062 
02063 
02064 #include <map>
02065 #include <algorithm>
02066 #include <stdexcept>
02067 
02068 
02069 #include <utility>
02070 
02071 
02072 #include <sstream>
02073 using namespace std;
02074 
02075 
02076 SWIGINTERN swig_type_info*
02077 SWIG_pchar_descriptor(void)
02078 {
02079   static int init = 0;
02080   static swig_type_info* info = 0;
02081   if (!init) {
02082     info = SWIG_TypeQuery("_p_char");
02083     init = 1;
02084   }
02085   return info;
02086 }
02087 
02088 
02089 SWIGINTERN int
02090 SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
02091 {
02092   if (TYPE(obj) == T_STRING) {
02093     
02094 
02095 
02096     char *cstr = STR2CSTR(obj);
02097     
02098     size_t size = RSTRING_LEN(obj) + 1;
02099     if (cptr)  {
02100       if (alloc) {
02101         if (*alloc == SWIG_NEWOBJ) {
02102           *cptr = reinterpret_cast< char* >(memcpy((new char[size]), cstr, sizeof(char)*(size)));
02103         } else {
02104           *cptr = cstr;
02105           *alloc = SWIG_OLDOBJ;
02106         }
02107       }
02108     }
02109     if (psize) *psize = size;
02110     return SWIG_OK;
02111   } else {
02112     swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
02113     if (pchar_descriptor) {
02114       void* vptr = 0;
02115       if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
02116         if (cptr) *cptr = (char *)vptr;
02117         if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
02118         if (alloc) *alloc = SWIG_OLDOBJ;
02119         return SWIG_OK;
02120       }
02121     }
02122   }  
02123   return SWIG_TypeError;
02124 }
02125 
02126 
02127 SWIGINTERN int
02128 SWIG_AsPtr_std_string (VALUE obj, std::string **val) 
02129 {
02130   char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
02131   if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
02132     if (buf) {
02133       if (val) *val = new std::string(buf, size - 1);
02134       if (alloc == SWIG_NEWOBJ) delete[] buf;
02135       return SWIG_NEWOBJ;
02136     } else {
02137       if (val) *val = 0;
02138       return SWIG_OLDOBJ;
02139     }
02140   } else {
02141     static int init = 0;
02142     static swig_type_info* descriptor = 0;
02143     if (!init) {
02144       descriptor = SWIG_TypeQuery("std::string" " *");
02145       init = 1;
02146     }
02147     if (descriptor) {
02148       std::string *vptr;
02149       int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
02150       if (SWIG_IsOK(res) && val) *val = vptr;
02151       return res;
02152     }
02153   }
02154   return SWIG_ERROR;
02155 }
02156 
02157 
02158 #include "tConfiguration.h"
02159 
02160 
02161 
02162 
02163 SWIGINTERN void tConfItemBase_LoadString(std::string str){
02164             std::istringstream stream(str);
02165             tConfItemBase::LoadAll(stream);
02166         }
02167 
02168 #include "tLocale.h"
02169 
02170 
02171 #include <limits.h>
02172 #ifndef LLONG_MIN
02173 # define LLONG_MIN      LONG_LONG_MIN
02174 #endif
02175 #ifndef LLONG_MAX
02176 # define LLONG_MAX      LONG_LONG_MAX
02177 #endif
02178 #ifndef ULLONG_MAX
02179 # define ULLONG_MAX     ULONG_LONG_MAX
02180 #endif
02181 
02182 
02183 SWIGINTERN VALUE
02184 SWIG_ruby_failed(void)
02185 {
02186   return Qnil;
02187 } 
02188 
02189 
02190 /*@SWIG:%ruby_aux_method@*/
02191 SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
02192 {
02193   VALUE obj = args[0];
02194   VALUE type = TYPE(obj);
02195   long *res = (long *)(args[1]);
02196   *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
02197   return obj;
02198 }
02199 /*@SWIG@*/
02200 
02201 SWIGINTERN int
02202 SWIG_AsVal_long (VALUE obj, long* val)
02203 {
02204   VALUE type = TYPE(obj);
02205   if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
02206     long v;
02207     VALUE a[2];
02208     a[0] = obj;
02209     a[1] = (VALUE)(&v);
02210     if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
02211       if (val) *val = v;
02212       return SWIG_OK;
02213     }
02214   }
02215   return SWIG_TypeError;
02216 }
02217 
02218 
02219 SWIGINTERN int
02220 SWIG_AsVal_int (VALUE obj, int *val)
02221 {
02222   long v;
02223   int res = SWIG_AsVal_long (obj, &v);
02224   if (SWIG_IsOK(res)) {
02225     if ((v < INT_MIN || v > INT_MAX)) {
02226       return SWIG_OverflowError;
02227     } else {
02228       if (val) *val = static_cast< int >(v);
02229     }
02230   }  
02231   return res;
02232 }
02233 
02234 
02235 #include <float.h>
02236 
02237 
02238 /*@SWIG:%ruby_aux_method@*/
02239 SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
02240 {
02241   VALUE obj = args[0];
02242   VALUE type = TYPE(obj);
02243   double *res = (double *)(args[1]);
02244   *res = (type == T_FLOAT ? NUM2DBL(obj) : (type == T_FIXNUM ? (double) FIX2INT(obj) : rb_big2dbl(obj)));
02245   return obj;
02246 }
02247 /*@SWIG@*/
02248 
02249 SWIGINTERN int
02250 SWIG_AsVal_double (VALUE obj, double *val)
02251 {
02252   VALUE type = TYPE(obj);
02253   if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
02254     double v;
02255     VALUE a[2];
02256     a[0] = obj;
02257     a[1] = (VALUE)(&v);
02258     if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
02259       if (val) *val = v;
02260       return SWIG_OK;
02261     }
02262   }
02263   return SWIG_TypeError;
02264 }
02265 
02266 
02267 SWIGINTERN int
02268 SWIG_AsVal_float (VALUE obj, float *val)
02269 {
02270   double v;
02271   int res = SWIG_AsVal_double (obj, &v);
02272   if (SWIG_IsOK(res)) {
02273     if ((v < -FLT_MAX || v > FLT_MAX)) {
02274       return SWIG_OverflowError;
02275     } else {
02276       if (val) *val = static_cast< float >(v);
02277     }
02278   }  
02279   return res;
02280 }
02281 
02282 
02283 SWIGINTERNINLINE VALUE
02284 SWIG_From_bool  (bool value)
02285 {
02286   return value ? Qtrue : Qfalse;
02287 }
02288 
02289 
02290 #include "tDirectories.h"
02291 
02292 
02293   #define SWIG_From_long   LONG2NUM 
02294 
02295 
02296 SWIGINTERNINLINE VALUE
02297 SWIG_From_int  (int value)
02298 {    
02299   return SWIG_From_long  (value);
02300 }
02301 
02302 
02303 SWIGINTERN int
02304 SWIG_AsVal_bool (VALUE obj, bool *val)
02305 {
02306   if (obj == Qtrue) {
02307     if (val) *val = true;
02308     return SWIG_OK;
02309   } else if (obj == Qfalse) {
02310     if (val) *val = false;
02311     return SWIG_OK;
02312   } else {
02313     int res = 0;
02314     if (SWIG_AsVal_int (obj, &res) == SWIG_OK) {    
02315       if (val) *val = res ? true : false;
02316       return SWIG_OK;
02317     }
02318   }  
02319   return SWIG_TypeError;
02320 }
02321 
02322 
02323 #include "tString.h"
02324 
02325 
02326 #include "nNetObject.h"
02327 
02328 
02329 SWIGINTERNINLINE VALUE
02330 SWIG_From_unsigned_SS_long  (unsigned long value)
02331 {
02332   return ULONG2NUM(value); 
02333 }
02334 
02335 
02336 SWIGINTERNINLINE VALUE
02337 SWIG_From_unsigned_SS_short  (unsigned short value)
02338 {    
02339   return SWIG_From_unsigned_SS_long  (value);
02340 }
02341 
02342 
02343 #include "uMenu.h"
02344 
02345 
02346   #define SWIG_From_double   rb_float_new 
02347 
02348 
02349 SWIGINTERNINLINE VALUE
02350 SWIG_From_float  (float value)
02351 {    
02352   return SWIG_From_double  (value);
02353 }
02354 
02355 
02356 /*@SWIG:%ruby_aux_method@*/
02357 SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
02358 {
02359   VALUE obj = args[0];
02360   VALUE type = TYPE(obj);
02361   unsigned long *res = (unsigned long *)(args[1]);
02362   *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
02363   return obj;
02364 }
02365 /*@SWIG@*/
02366 
02367 SWIGINTERN int
02368 SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val) 
02369 {
02370   VALUE type = TYPE(obj);
02371   if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
02372     unsigned long v;
02373     VALUE a[2];
02374     a[0] = obj;
02375     a[1] = (VALUE)(&v);
02376     if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
02377       if (val) *val = v;
02378       return SWIG_OK;
02379     }
02380   }
02381   return SWIG_TypeError;
02382 }
02383 
02384 
02385 SWIGINTERN int
02386 SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
02387 {
02388   unsigned long v;
02389   int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
02390   if (SWIG_IsOK(res)) {
02391     if ((v > UINT_MAX)) {
02392       return SWIG_OverflowError;
02393     } else {
02394       if (val) *val = static_cast< unsigned int >(v);
02395     }
02396   }  
02397   return res;
02398 }
02399 
02400 
02401 #include "eGameObject.h"
02402 
02403 
02404 #include "eNetGameObject.h"
02405 
02406 
02407 #include "eSensor.h"
02408 
02409 
02410 #include "gAIBase.h"
02411 
02412 
02413 #include "gCycleMovement.h"
02414 
02415 
02416 #include "gCycle.h"
02417 
02418 
02419 #include "gSensor.h"
02420 
02421 /* ---------------------------------------------------
02422  * C++ director class helpers
02423  * --------------------------------------------------- */
02424 
02425 
02426 
02427 /* ---------------------------------------------------
02428  * C++ director class methods
02429  * --------------------------------------------------- */
02430 
02431 #include "armagetronad_wrap.h"
02432 
02433 SwigDirector_TConfItemBase::SwigDirector_TConfItemBase(VALUE self, char const *title, tConfItemBase::callbackFunc *cb): tConfItemBase(title, cb), Swig::Director(self) {
02434   
02435 }
02436 
02437 
02438 
02439 SwigDirector_TConfItemBase::~SwigDirector_TConfItemBase() {
02440 }
02441 
02442 void SwigDirector_TConfItemBase::ReadVal(std::istream &s) {
02443   VALUE obj0 = Qnil ;
02444   VALUE result;
02445   
02446   obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&s), SWIGTYPE_p_istream,  0 );
02447   result = rb_funcall(swig_get_self(), rb_intern("read_val"), 1,obj0);
02448 }
02449 
02450 
02451 void SwigDirector_TConfItemBase::WriteVal(std::ostream &s) {
02452   VALUE obj0 = Qnil ;
02453   VALUE result;
02454   
02455   obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&s), SWIGTYPE_p_std__ostream,  0 );
02456   result = rb_funcall(swig_get_self(), rb_intern("write_val"), 1,obj0);
02457 }
02458 
02459 
02460 SwigDirector_TPath::SwigDirector_TPath(VALUE self): tPath(), Swig::Director(self) {
02461   
02462 }
02463 
02464 
02465 
02466 SwigDirector_TPath::~SwigDirector_TPath() {
02467 }
02468 
02469 void SwigDirector_TPath::Paths(tArray<tString > &paths) const {
02470   VALUE obj0 = Qnil ;
02471   VALUE result;
02472   
02473   obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&paths), SWIGTYPE_p_tArrayTtString_t,  0 );
02474   result = rb_funcall(swig_get_self(), rb_intern("paths"), 1,obj0);
02475 }
02476 
02477 
02478 SwigDirector_NNetObject::SwigDirector_NNetObject(VALUE self, int owner): nNetObject(owner), Swig::Director(self) {
02479   
02480 }
02481 
02482 
02483 
02484 SwigDirector_NNetObject::SwigDirector_NNetObject(VALUE self, nMessage &m): nNetObject(m), Swig::Director(self) {
02485   
02486 }
02487 
02488 
02489 
02490 void SwigDirector_NNetObject::AddRef() {
02491   VALUE result;
02492   
02493   result = rb_funcall(swig_get_self(), rb_intern("add_ref"), 0, NULL);
02494 }
02495 
02496 
02497 void SwigDirector_NNetObject::Release() {
02498   VALUE result;
02499   
02500   result = rb_funcall(swig_get_self(), rb_intern("release"), 0, NULL);
02501 }
02502 
02503 
02504 void SwigDirector_NNetObject::ReleaseOwnership() {
02505   VALUE result;
02506   
02507   result = rb_funcall(swig_get_self(), rb_intern("release_ownership"), 0, NULL);
02508 }
02509 
02510 
02511 void SwigDirector_NNetObject::TakeOwnership() {
02512   VALUE result;
02513   
02514   result = rb_funcall(swig_get_self(), rb_intern("take_ownership"), 0, NULL);
02515 }
02516 
02517 
02518 void SwigDirector_NNetObject::Dump(tConsole &con) {
02519   VALUE obj0 = Qnil ;
02520   VALUE result;
02521   
02522   obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&con), SWIGTYPE_p_tConsole,  0 );
02523   result = rb_funcall(swig_get_self(), rb_intern("dump"), 1,obj0);
02524 }
02525 
02526 
02527 nDescriptor &SwigDirector_NNetObject::CreatorDescriptor() const {
02528   nDescriptor *c_result ;
02529   VALUE result;
02530   void *swig_argp ;
02531   int swig_res ;
02532   swig_owntype own ;
02533   
02534   result = rb_funcall(swig_get_self(), rb_intern("creator_descriptor"), 0, NULL);
02535   swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_nDescriptor,  0  | SWIG_POINTER_DISOWN, &own);
02536   if (!SWIG_IsOK(swig_res)) {
02537     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""nDescriptor &""'");
02538   }
02539   if (!swig_argp) {
02540     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ValueError), "invalid null reference " "in output value of type '""nDescriptor &""'"); 
02541   }
02542   c_result = reinterpret_cast< nDescriptor * >(swig_argp);
02543   swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
02544   return (nDescriptor &) *c_result;
02545 }
02546 
02547 
02548 void SwigDirector_NNetObject::InitAfterCreation() {
02549   VALUE result;
02550   
02551   result = rb_funcall(swig_get_self(), rb_intern("init_after_creation"), 0, NULL);
02552 }
02553 
02554 
02555 SwigDirector_NNetObject::~SwigDirector_NNetObject() {
02556 }
02557 
02558 nMachine &SwigDirector_NNetObject::DoGetMachine() const {
02559   nMachine *c_result ;
02560   VALUE result;
02561   void *swig_argp ;
02562   int swig_res ;
02563   swig_owntype own ;
02564   
02565   result = rb_funcall(swig_get_self(), rb_intern("do_get_machine"), 0, NULL);
02566   swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_nMachine,  0  | SWIG_POINTER_DISOWN, &own);
02567   if (!SWIG_IsOK(swig_res)) {
02568     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""nMachine &""'");
02569   }
02570   if (!swig_argp) {
02571     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ValueError), "invalid null reference " "in output value of type '""nMachine &""'"); 
02572   }
02573   c_result = reinterpret_cast< nMachine * >(swig_argp);
02574   swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
02575   return (nMachine &) *c_result;
02576 }
02577 
02578 
02579 bool SwigDirector_NNetObject::ActionOnQuit() {
02580   bool c_result ;
02581   VALUE result;
02582   
02583   result = rb_funcall(swig_get_self(), rb_intern("action_on_quit"), 0, NULL);
02584   bool swig_val;
02585   int swig_res = SWIG_AsVal_bool(result, &swig_val);
02586   if (!SWIG_IsOK(swig_res)) {
02587     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
02588   }
02589   c_result = static_cast< bool >(swig_val);
02590   return (bool) c_result;
02591 }
02592 
02593 
02594 void SwigDirector_NNetObject::ActionOnDelete() {
02595   VALUE result;
02596   
02597   result = rb_funcall(swig_get_self(), rb_intern("action_on_delete"), 0, NULL);
02598 }
02599 
02600 
02601 bool SwigDirector_NNetObject::BroadcastExistence() {
02602   bool c_result ;
02603   VALUE result;
02604   
02605   result = rb_funcall(swig_get_self(), rb_intern("broadcast_existence"), 0, NULL);
02606   bool swig_val;
02607   int swig_res = SWIG_AsVal_bool(result, &swig_val);
02608   if (!SWIG_IsOK(swig_res)) {
02609     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
02610   }
02611   c_result = static_cast< bool >(swig_val);
02612   return (bool) c_result;
02613 }
02614 
02615 
02616 void SwigDirector_NNetObject::PrintName(tString &s) const {
02617   VALUE obj0 = Qnil ;
02618   VALUE result;
02619   
02620   obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&s), SWIGTYPE_p_tString,  0 );
02621   result = rb_funcall(swig_get_self(), rb_intern("print_name"), 1,obj0);
02622 }
02623 
02624 
02625 bool SwigDirector_NNetObject::ClearToTransmit(int user) const {
02626   bool c_result ;
02627   VALUE obj0 = Qnil ;
02628   VALUE result;
02629   
02630   obj0 = SWIG_From_int(static_cast< int >(user));
02631   result = rb_funcall(swig_get_self(), rb_intern("clear_to_transmit"), 1,obj0);
02632   bool swig_val;
02633   int swig_res = SWIG_AsVal_bool(result, &swig_val);
02634   if (!SWIG_IsOK(swig_res)) {
02635     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
02636   }
02637   c_result = static_cast< bool >(swig_val);
02638   return (bool) c_result;
02639 }
02640 
02641 
02642 void SwigDirector_NNetObject::WriteSync(nMessage &m) {
02643   VALUE obj0 = Qnil ;
02644   VALUE result;
02645   
02646   obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&m), SWIGTYPE_p_nMessage,  0 );
02647   result = rb_funcall(swig_get_self(), rb_intern("write_sync"), 1,obj0);
02648 }
02649 
02650 
02651 void SwigDirector_NNetObject::ReadSync(nMessage &m) {
02652   VALUE obj0 = Qnil ;
02653   VALUE result;
02654   
02655   obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&m), SWIGTYPE_p_nMessage,  0 );
02656   result = rb_funcall(swig_get_self(), rb_intern("read_sync"), 1,obj0);
02657 }
02658 
02659 
02660 bool SwigDirector_NNetObject::SyncIsNew(nMessage &m) {
02661   bool c_result ;
02662   VALUE obj0 = Qnil ;
02663   VALUE result;
02664   
02665   obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&m), SWIGTYPE_p_nMessage,  0 );
02666   result = rb_funcall(swig_get_self(), rb_intern("sync_is_new"), 1,obj0);
02667   bool swig_val;
02668   int swig_res = SWIG_AsVal_bool(result, &swig_val);
02669   if (!SWIG_IsOK(swig_res)) {
02670     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
02671   }
02672   c_result = static_cast< bool >(swig_val);
02673   return (bool) c_result;
02674 }
02675 
02676 
02677 void SwigDirector_NNetObject::WriteCreate(nMessage &m) {
02678   VALUE obj0 = Qnil ;
02679   VALUE result;
02680   
02681   obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&m), SWIGTYPE_p_nMessage,  0 );
02682   result = rb_funcall(swig_get_self(), rb_intern("write_create"), 1,obj0);
02683 }
02684 
02685 
02686 void SwigDirector_NNetObject::ReceiveControlNet(nMessage &m) {
02687   VALUE obj0 = Qnil ;
02688   VALUE result;
02689   
02690   obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&m), SWIGTYPE_p_nMessage,  0 );
02691   result = rb_funcall(swig_get_self(), rb_intern("receive_control_net"), 1,obj0);
02692 }
02693 
02694 
02695 bool SwigDirector_NNetObject::AcceptClientSync() const {
02696   bool c_result ;
02697   VALUE result;
02698   
02699   result = rb_funcall(swig_get_self(), rb_intern("accept_client_sync"), 0, NULL);
02700   bool swig_val;
02701   int swig_res = SWIG_AsVal_bool(result, &swig_val);
02702   if (!SWIG_IsOK(swig_res)) {
02703     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
02704   }
02705   c_result = static_cast< bool >(swig_val);
02706   return (bool) c_result;
02707 }
02708 
02709 
02710 SwigDirector_UMenuItemAction::SwigDirector_UMenuItemAction(VALUE self, uMenu *M, tOutput const &name, tOutput const &help): uMenuItemAction(M, name, help), Swig::Director(self) {
02711   
02712 }
02713 
02714 
02715 
02716 SwigDirector_UMenuItemAction::~SwigDirector_UMenuItemAction() {
02717 }
02718 
02719 tString SwigDirector_UMenuItemAction::Help() {
02720   tString c_result ;
02721   VALUE result;
02722   void *swig_argp ;
02723   int swig_res = 0 ;
02724   
02725   result = rb_funcall(swig_get_self(), rb_intern("help"), 0, NULL);
02726   swig_res = SWIG_ConvertPtr(result,&swig_argp,SWIGTYPE_p_tString,  0 );
02727   if (!SWIG_IsOK(swig_res)) {
02728     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""tString""'");
02729   }
02730   c_result = *(reinterpret_cast< tString * >(swig_argp));
02731   return (tString) c_result;
02732 }
02733 
02734 
02735 void SwigDirector_UMenuItemAction::Render(REAL x, REAL y, REAL alpha, bool selected) {
02736   VALUE obj0 = Qnil ;
02737   VALUE obj1 = Qnil ;
02738   VALUE obj2 = Qnil ;
02739   VALUE obj3 = Qnil ;
02740   VALUE result;
02741   
02742   obj0 = SWIG_From_float(static_cast< float >(x));
02743   obj1 = SWIG_From_float(static_cast< float >(y));
02744   obj2 = SWIG_From_float(static_cast< float >(alpha));
02745   obj3 = SWIG_From_bool(static_cast< bool >(selected));
02746   result = rb_funcall(swig_get_self(), rb_intern("render"), 4,obj0,obj1,obj2,obj3);
02747 }
02748 
02749 
02750 void SwigDirector_UMenuItemAction::RenderBackground() {
02751   VALUE result;
02752   
02753   result = rb_funcall(swig_get_self(), rb_intern("render_background"), 0, NULL);
02754 }
02755 
02756 
02757 void SwigDirector_UMenuItemAction::LeftRight(int arg0) {
02758   VALUE obj0 = Qnil ;
02759   VALUE result;
02760   
02761   obj0 = SWIG_From_int(static_cast< int >(arg0));
02762   result = rb_funcall(swig_get_self(), rb_intern("left_right"), 1,obj0);
02763 }
02764 
02765 
02766 void SwigDirector_UMenuItemAction::LeftRightRelease() {
02767   VALUE result;
02768   
02769   result = rb_funcall(swig_get_self(), rb_intern("left_right_release"), 0, NULL);
02770 }
02771 
02772 
02773 void SwigDirector_UMenuItemAction::Enter() {
02774   VALUE result;
02775   
02776   result = rb_funcall(swig_get_self(), rb_intern("enter"), 0, NULL);
02777 }
02778 
02779 
02780 bool SwigDirector_UMenuItemAction::Event(SDL_Event &arg0) {
02781   bool c_result ;
02782   VALUE obj0 = Qnil ;
02783   VALUE result;
02784   
02785   obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_SDL_Event,  0 );
02786   result = rb_funcall(swig_get_self(), rb_intern("event"), 1,obj0);
02787   bool swig_val;
02788   int swig_res = SWIG_AsVal_bool(result, &swig_val);
02789   if (!SWIG_IsOK(swig_res)) {
02790     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
02791   }
02792   c_result = static_cast< bool >(swig_val);
02793   return (bool) c_result;
02794 }
02795 
02796 
02797 REAL SwigDirector_UMenuItemAction::SpaceRight() {
02798   REAL c_result ;
02799   VALUE result;
02800   
02801   result = rb_funcall(swig_get_self(), rb_intern("space_right"), 0, NULL);
02802   float swig_val;
02803   int swig_res = SWIG_AsVal_float(result, &swig_val);
02804   if (!SWIG_IsOK(swig_res)) {
02805     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""REAL""'");
02806   }
02807   c_result = static_cast< REAL >(swig_val);
02808   return (REAL) c_result;
02809 }
02810 
02811 
02812 bool SwigDirector_UMenuItemAction::IsSelectable() {
02813   bool c_result ;
02814   VALUE result;
02815   
02816   result = rb_funcall(swig_get_self(), rb_intern("is_selectable"), 0, NULL);
02817   bool swig_val;
02818   int swig_res = SWIG_AsVal_bool(result, &swig_val);
02819   if (!SWIG_IsOK(swig_res)) {
02820     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
02821   }
02822   c_result = static_cast< bool >(swig_val);
02823   return (bool) c_result;
02824 }
02825 
02826 
02827 SwigDirector_GSimpleAI::SwigDirector_GSimpleAI(VALUE self): gSimpleAI(), Swig::Director(self) {
02828   
02829 }
02830 
02831 
02832 
02833 SwigDirector_GSimpleAI::~SwigDirector_GSimpleAI() {
02834 }
02835 
02836 REAL SwigDirector_GSimpleAI::DoThink() {
02837   REAL c_result ;
02838   VALUE result;
02839   
02840   result = rb_funcall(swig_get_self(), rb_intern("do_think"), 0, NULL);
02841   float swig_val;
02842   int swig_res = SWIG_AsVal_float(result, &swig_val);
02843   if (!SWIG_IsOK(swig_res)) {
02844     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""REAL""'");
02845   }
02846   c_result = static_cast< REAL >(swig_val);
02847   return (REAL) c_result;
02848 }
02849 
02850 
02851 SwigDirector_GSimpleAIFactory::SwigDirector_GSimpleAIFactory(VALUE self): gSimpleAIFactory(), Swig::Director(self) {
02852   
02853 }
02854 
02855 
02856 
02857 gSimpleAI *SwigDirector_GSimpleAIFactory::DoCreate() const {
02858   gSimpleAI *c_result ;
02859   VALUE result;
02860   void *swig_argp ;
02861   int swig_res ;
02862   swig_owntype own ;
02863   
02864   result = rb_funcall(swig_get_self(), rb_intern("do_create"), 0, NULL);
02865   swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_gSimpleAI,  0  | SWIG_POINTER_DISOWN, &own);
02866   if (!SWIG_IsOK(swig_res)) {
02867     Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""gSimpleAI *""'");
02868   }
02869   c_result = reinterpret_cast< gSimpleAI * >(swig_argp);
02870   swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own);
02871   return (gSimpleAI *) c_result;
02872 }
02873 
02874 
02875 swig_class cIstream;
02876 
02877 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
02878 SWIGINTERN VALUE
02879 _wrap_Istream_allocate(VALUE self) {
02880 #else
02881   SWIGINTERN VALUE
02882   _wrap_Istream_allocate(int argc, VALUE *argv, VALUE self) {
02883 #endif
02884     
02885     
02886     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_istream);
02887 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
02888     rb_obj_call_init(vresult, argc, argv);
02889 #endif
02890     return vresult;
02891   }
02892   
02893 
02894 SWIGINTERN VALUE
02895 _wrap_new_Istream(int argc, VALUE *argv, VALUE self) {
02896   streambuf *arg1 = (streambuf *) 0 ;
02897   istream *result = 0 ;
02898   void *argp1 = 0 ;
02899   int res1 = 0 ;
02900   const char *classname SWIGUNUSED = "Armagetronad::Istream";
02901   
02902   if ((argc < 1) || (argc > 1)) {
02903     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
02904   }
02905   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_streambuf, 0 |  0 );
02906   if (!SWIG_IsOK(res1)) {
02907     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istream" "', argument " "1"" of type '" "streambuf *""'"); 
02908   }
02909   arg1 = reinterpret_cast< streambuf * >(argp1);
02910   result = (istream *)new istream(arg1);DATA_PTR(self) = result;
02911   
02912   return self;
02913 fail:
02914   return Qnil;
02915 }
02916 
02917 
02918 SWIGINTERN void
02919 free_istream(istream *arg1) {
02920     delete arg1;
02921 }
02922 
02923 swig_class cIstringstream;
02924 
02925 SWIGINTERN VALUE
02926 _wrap_new_Istringstream__SWIG_0(int argc, VALUE *argv, VALUE self) {
02927   std::string *arg1 = 0 ;
02928   ios_base::openmode arg2 ;
02929   istringstream *result = 0 ;
02930   int res1 = SWIG_OLDOBJ ;
02931   void *argp2 ;
02932   int res2 = 0 ;
02933   const char *classname SWIGUNUSED = "Armagetronad::Istringstream";
02934   
02935   if ((argc < 2) || (argc > 2)) {
02936     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
02937   }
02938   {
02939     std::string *ptr = (std::string *)0;
02940     res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
02941     if (!SWIG_IsOK(res1)) {
02942       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istringstream" "', argument " "1"" of type '" "std::string const &""'"); 
02943     }
02944     if (!ptr) {
02945       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istringstream" "', argument " "1"" of type '" "std::string const &""'"); 
02946     }
02947     arg1 = ptr;
02948   }
02949   {
02950     res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_ios_base__openmode,  0 );
02951     if (!SWIG_IsOK(res2)) {
02952       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "istringstream" "', argument " "2"" of type '" "ios_base::openmode""'"); 
02953     }  
02954     if (!argp2) {
02955       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istringstream" "', argument " "2"" of type '" "ios_base::openmode""'");
02956     } else {
02957       arg2 = *(reinterpret_cast< ios_base::openmode * >(argp2));
02958     }
02959   }
02960   result = (istringstream *)new istringstream((std::string const &)*arg1,arg2);DATA_PTR(self) = result;
02961   
02962   if (SWIG_IsNewObj(res1)) delete arg1;
02963   return self;
02964 fail:
02965   if (SWIG_IsNewObj(res1)) delete arg1;
02966   return Qnil;
02967 }
02968 
02969 
02970 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
02971 SWIGINTERN VALUE
02972 _wrap_Istringstream_allocate(VALUE self) {
02973 #else
02974   SWIGINTERN VALUE
02975   _wrap_Istringstream_allocate(int argc, VALUE *argv, VALUE self) {
02976 #endif
02977     
02978     
02979     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_istringstream);
02980 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
02981     rb_obj_call_init(vresult, argc, argv);
02982 #endif
02983     return vresult;
02984   }
02985   
02986 
02987 SWIGINTERN VALUE
02988 _wrap_new_Istringstream__SWIG_1(int argc, VALUE *argv, VALUE self) {
02989   std::string *arg1 = 0 ;
02990   istringstream *result = 0 ;
02991   int res1 = SWIG_OLDOBJ ;
02992   const char *classname SWIGUNUSED = "Armagetronad::Istringstream";
02993   
02994   if ((argc < 1) || (argc > 1)) {
02995     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
02996   }
02997   {
02998     std::string *ptr = (std::string *)0;
02999     res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
03000     if (!SWIG_IsOK(res1)) {
03001       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "istringstream" "', argument " "1"" of type '" "std::string const &""'"); 
03002     }
03003     if (!ptr) {
03004       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "istringstream" "', argument " "1"" of type '" "std::string const &""'"); 
03005     }
03006     arg1 = ptr;
03007   }
03008   result = (istringstream *)new istringstream((std::string const &)*arg1);DATA_PTR(self) = result;
03009   
03010   if (SWIG_IsNewObj(res1)) delete arg1;
03011   return self;
03012 fail:
03013   if (SWIG_IsNewObj(res1)) delete arg1;
03014   return Qnil;
03015 }
03016 
03017 
03018 SWIGINTERN VALUE _wrap_new_Istringstream(int nargs, VALUE *args, VALUE self) {
03019   int argc;
03020   VALUE argv[2];
03021   int ii;
03022   
03023   argc = nargs;
03024   if (argc > 2) SWIG_fail;
03025   for (ii = 0; (ii < argc); ii++) {
03026     argv[ii] = args[ii];
03027   }
03028   if (argc == 1) {
03029     int _v;
03030     int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
03031     _v = SWIG_CheckState(res);
03032     if (_v) {
03033       return _wrap_new_Istringstream__SWIG_1(nargs, args, self);
03034     }
03035   }
03036   if (argc == 2) {
03037     int _v;
03038     int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
03039     _v = SWIG_CheckState(res);
03040     if (_v) {
03041       void *vptr = 0;
03042       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ios_base__openmode, 0);
03043       _v = SWIG_CheckState(res);
03044       if (_v) {
03045         return _wrap_new_Istringstream__SWIG_0(nargs, args, self);
03046       }
03047     }
03048   }
03049   
03050 fail:
03051   rb_raise(rb_eArgError, "No matching function for overloaded 'new_Istringstream'");
03052   return Qnil;
03053 }
03054 
03055 
03056 SWIGINTERN void
03057 free_istringstream(istringstream *arg1) {
03058     delete arg1;
03059 }
03060 
03061 swig_class cTConfItemBase;
03062 
03063 SWIGINTERN VALUE
03064 _wrap_new_TConfItemBase__SWIG_0(int argc, VALUE *argv, VALUE self) {
03065   VALUE arg1 = (VALUE) 0 ;
03066   char *arg2 = (char *) 0 ;
03067   tConfItemBase::callbackFunc *arg3 = (tConfItemBase::callbackFunc *) 0 ;
03068   tConfItemBase *result = 0 ;
03069   int res2 ;
03070   char *buf2 = 0 ;
03071   int alloc2 = 0 ;
03072   const char *classname SWIGUNUSED = "Armagetronad::TConfItemBase";
03073   
03074   if ((argc < 2) || (argc > 2)) {
03075     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
03076   }
03077   arg1 = self;
03078   res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
03079   if (!SWIG_IsOK(res2)) {
03080     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tConfItemBase" "', argument " "2"" of type '" "char const *""'");
03081   }
03082   arg2 = reinterpret_cast< char * >(buf2);
03083   {
03084     int res = SWIG_ConvertFunctionPtr(argv[1], (void**)(&arg3), SWIGTYPE_p_f___void);
03085     if (!SWIG_IsOK(res)) {
03086       SWIG_exception_fail(SWIG_ArgError(res), "in method '" "tConfItemBase" "', argument " "3"" of type '" "tConfItemBase::callbackFunc *""'"); 
03087     }
03088   }
03089   if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
03090     /* subclassed */
03091     result = (tConfItemBase *)new SwigDirector_TConfItemBase(arg1,(char const *)arg2,arg3); 
03092   } else {
03093     rb_raise(rb_eNameError,"accessing abstract class or protected constructor"); 
03094     return Qnil;
03095   }
03096   DATA_PTR(self) = result;
03097   
03098   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
03099   return self;
03100 fail:
03101   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
03102   return Qnil;
03103 }
03104 
03105 
03106 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
03107 SWIGINTERN VALUE
03108 _wrap_TConfItemBase_allocate(VALUE self) {
03109 #else
03110   SWIGINTERN VALUE
03111   _wrap_TConfItemBase_allocate(int argc, VALUE *argv, VALUE self) {
03112 #endif
03113     
03114     
03115     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_tConfItemBase);
03116 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
03117     rb_obj_call_init(vresult, argc, argv);
03118 #endif
03119     return vresult;
03120   }
03121   
03122 
03123 SWIGINTERN VALUE
03124 _wrap_new_TConfItemBase__SWIG_1(int argc, VALUE *argv, VALUE self) {
03125   VALUE arg1 = (VALUE) 0 ;
03126   char *arg2 = (char *) 0 ;
03127   tConfItemBase *result = 0 ;
03128   int res2 ;
03129   char *buf2 = 0 ;
03130   int alloc2 = 0 ;
03131   const char *classname SWIGUNUSED = "Armagetronad::TConfItemBase";
03132   
03133   if ((argc < 1) || (argc > 1)) {
03134     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
03135   }
03136   arg1 = self;
03137   res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
03138   if (!SWIG_IsOK(res2)) {
03139     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tConfItemBase" "', argument " "2"" of type '" "char const *""'");
03140   }
03141   arg2 = reinterpret_cast< char * >(buf2);
03142   if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
03143     /* subclassed */
03144     result = (tConfItemBase *)new SwigDirector_TConfItemBase(arg1,(char const *)arg2); 
03145   } else {
03146     rb_raise(rb_eNameError,"accessing abstract class or protected constructor"); 
03147     return Qnil;
03148   }
03149   DATA_PTR(self) = result;
03150   
03151   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
03152   return self;
03153 fail:
03154   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
03155   return Qnil;
03156 }
03157 
03158 
03159 SWIGINTERN VALUE _wrap_new_TConfItemBase(int nargs, VALUE *args, VALUE self) {
03160   int argc;
03161   VALUE argv[4];
03162   int ii;
03163   
03164   argc = nargs + 1;
03165   argv[0] = self;
03166   if (argc > 4) SWIG_fail;
03167   for (ii = 1; (ii < argc); ii++) {
03168     argv[ii] = args[ii-1];
03169   }
03170   if (argc == 2) {
03171     int _v;
03172     _v = (argv[0] != 0);
03173     if (_v) {
03174       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
03175       _v = SWIG_CheckState(res);
03176       if (_v) {
03177         return _wrap_new_TConfItemBase__SWIG_1(nargs, args, self);
03178       }
03179     }
03180   }
03181   if (argc == 3) {
03182     int _v;
03183     _v = (argv[0] != 0);
03184     if (_v) {
03185       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
03186       _v = SWIG_CheckState(res);
03187       if (_v) {
03188         void *ptr = 0;
03189         int res = SWIG_ConvertFunctionPtr(argv[2], &ptr, SWIGTYPE_p_f___void);
03190         _v = SWIG_CheckState(res);
03191         if (_v) {
03192           return _wrap_new_TConfItemBase__SWIG_0(nargs, args, self);
03193         }
03194       }
03195     }
03196   }
03197   
03198 fail:
03199   rb_raise(rb_eArgError, "No matching function for overloaded 'new_TConfItemBase'");
03200   return Qnil;
03201 }
03202 
03203 
03204 SWIGINTERN void
03205 free_tConfItemBase(tConfItemBase *arg1) {
03206     delete arg1;
03207 }
03208 
03209 SWIGINTERN VALUE
03210 _wrap_TConfItemBase_load_all(int argc, VALUE *argv, VALUE self) {
03211   std::istream *arg1 = 0 ;
03212   void *argp1 = 0 ;
03213   int res1 = 0 ;
03214   
03215   if ((argc < 1) || (argc > 1)) {
03216     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
03217   }
03218   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_istream,  0 );
03219   if (!SWIG_IsOK(res1)) {
03220     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tConfItemBase::LoadAll" "', argument " "1"" of type '" "std::istream &""'"); 
03221   }
03222   if (!argp1) {
03223     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tConfItemBase::LoadAll" "', argument " "1"" of type '" "std::istream &""'"); 
03224   }
03225   arg1 = reinterpret_cast< std::istream * >(argp1);
03226   tConfItemBase::LoadAll(*arg1);
03227   return Qnil;
03228 fail:
03229   return Qnil;
03230 }
03231 
03232 
03233 SWIGINTERN VALUE
03234 _wrap_TConfItemBase_load_line(int argc, VALUE *argv, VALUE self) {
03235   std::istream *arg1 = 0 ;
03236   void *argp1 = 0 ;
03237   int res1 = 0 ;
03238   
03239   if ((argc < 1) || (argc > 1)) {
03240     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
03241   }
03242   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_istream,  0 );
03243   if (!SWIG_IsOK(res1)) {
03244     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tConfItemBase::LoadLine" "', argument " "1"" of type '" "std::istream &""'"); 
03245   }
03246   if (!argp1) {
03247     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tConfItemBase::LoadLine" "', argument " "1"" of type '" "std::istream &""'"); 
03248   }
03249   arg1 = reinterpret_cast< std::istream * >(argp1);
03250   tConfItemBase::LoadLine(*arg1);
03251   return Qnil;
03252 fail:
03253   return Qnil;
03254 }
03255 
03256 
03257 SWIGINTERN VALUE
03258 _wrap_TConfItemBase_find_config_item(int argc, VALUE *argv, VALUE self) {
03259   std::string *arg1 = 0 ;
03260   tConfItemBase *result = 0 ;
03261   int res1 = SWIG_OLDOBJ ;
03262   Swig::Director *director = 0;
03263   VALUE vresult = Qnil;
03264   
03265   if ((argc < 1) || (argc > 1)) {
03266     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
03267   }
03268   {
03269     std::string *ptr = (std::string *)0;
03270     res1 = SWIG_AsPtr_std_string(argv[0], &ptr);
03271     if (!SWIG_IsOK(res1)) {
03272       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tConfItemBase::FindConfigItem" "', argument " "1"" of type '" "std::string const &""'"); 
03273     }
03274     if (!ptr) {
03275       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tConfItemBase::FindConfigItem" "', argument " "1"" of type '" "std::string const &""'"); 
03276     }
03277     arg1 = ptr;
03278   }
03279   result = (tConfItemBase *)tConfItemBase::FindConfigItem((std::string const &)*arg1);
03280   director = dynamic_cast<Swig::Director *>(result);
03281   if (director) {
03282     vresult = director->swig_get_self();
03283   } else {
03284     vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_tConfItemBase, 0 |  0 );
03285   }
03286   if (SWIG_IsNewObj(res1)) delete arg1;
03287   return vresult;
03288 fail:
03289   if (SWIG_IsNewObj(res1)) delete arg1;
03290   return Qnil;
03291 }
03292 
03293 
03294 SWIGINTERN VALUE
03295 _wrap_TConfItemBase_load_string(int argc, VALUE *argv, VALUE self) {
03296   std::string arg1 ;
03297   
03298   if ((argc < 1) || (argc > 1)) {
03299     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
03300   }
03301   {
03302     std::string *ptr = (std::string *)0;
03303     int res = SWIG_AsPtr_std_string(argv[0], &ptr);
03304     if (!SWIG_IsOK(res) || !ptr) {
03305       SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "tConfItemBase_LoadString" "', argument " "1"" of type '" "std::string""'"); 
03306     }
03307     arg1 = *ptr;
03308     if (SWIG_IsNewObj(res)) delete ptr;
03309   }
03310   tConfItemBase_LoadString(arg1);
03311   return Qnil;
03312 fail:
03313   return Qnil;
03314 }
03315 
03316 
03317 SWIGINTERN VALUE
03318 _wrap_TConfItemBase_read_val(int argc, VALUE *argv, VALUE self) {
03319   tConfItemBase *arg1 = (tConfItemBase *) 0 ;
03320   std::istream *arg2 = 0 ;
03321   void *argp1 = 0 ;
03322   int res1 = 0 ;
03323   void *argp2 = 0 ;
03324   int res2 = 0 ;
03325   Swig::Director *director = 0;
03326   bool upcall = false;
03327   
03328   if ((argc < 1) || (argc > 1)) {
03329     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
03330   }
03331   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tConfItemBase, 0 |  0 );
03332   if (!SWIG_IsOK(res1)) {
03333     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReadVal" "', argument " "1"" of type '" "tConfItemBase *""'"); 
03334   }
03335   arg1 = reinterpret_cast< tConfItemBase * >(argp1);
03336   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_istream,  0 );
03337   if (!SWIG_IsOK(res2)) {
03338     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReadVal" "', argument " "2"" of type '" "std::istream &""'"); 
03339   }
03340   if (!argp2) {
03341     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReadVal" "', argument " "2"" of type '" "std::istream &""'"); 
03342   }
03343   arg2 = reinterpret_cast< std::istream * >(argp2);
03344   director = dynamic_cast<Swig::Director *>(arg1);
03345   upcall = (director && (director->swig_get_self() == self));
03346   try {
03347     if (upcall) {
03348       Swig::DirectorPureVirtualException::raise("tConfItemBase::ReadVal");
03349     } else {
03350       (arg1)->ReadVal(*arg2);
03351     }
03352   } catch (Swig::DirectorException& e) {
03353     rb_exc_raise(e.getError());
03354     SWIG_fail;
03355   }
03356   return Qnil;
03357 fail:
03358   return Qnil;
03359 }
03360 
03361 
03362 SWIGINTERN VALUE
03363 _wrap_TConfItemBase_write_val(int argc, VALUE *argv, VALUE self) {
03364   tConfItemBase *arg1 = (tConfItemBase *) 0 ;
03365   std::ostream *arg2 = 0 ;
03366   void *argp1 = 0 ;
03367   int res1 = 0 ;
03368   void *argp2 = 0 ;
03369   int res2 = 0 ;
03370   Swig::Director *director = 0;
03371   bool upcall = false;
03372   
03373   if ((argc < 1) || (argc > 1)) {
03374     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
03375   }
03376   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tConfItemBase, 0 |  0 );
03377   if (!SWIG_IsOK(res1)) {
03378     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WriteVal" "', argument " "1"" of type '" "tConfItemBase *""'"); 
03379   }
03380   arg1 = reinterpret_cast< tConfItemBase * >(argp1);
03381   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__ostream,  0 );
03382   if (!SWIG_IsOK(res2)) {
03383     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WriteVal" "', argument " "2"" of type '" "std::ostream &""'"); 
03384   }
03385   if (!argp2) {
03386     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WriteVal" "', argument " "2"" of type '" "std::ostream &""'"); 
03387   }
03388   arg2 = reinterpret_cast< std::ostream * >(argp2);
03389   director = dynamic_cast<Swig::Director *>(arg1);
03390   upcall = (director && (director->swig_get_self() == self));
03391   try {
03392     if (upcall) {
03393       Swig::DirectorPureVirtualException::raise("tConfItemBase::WriteVal");
03394     } else {
03395       (arg1)->WriteVal(*arg2);
03396     }
03397   } catch (Swig::DirectorException& e) {
03398     rb_exc_raise(e.getError());
03399     SWIG_fail;
03400   }
03401   return Qnil;
03402 fail:
03403   return Qnil;
03404 }
03405 
03406 
03407 SWIGINTERN VALUE
03408 _wrap_disown_TConfItemBase(int argc, VALUE *argv, VALUE self) {
03409   tConfItemBase *arg1 = (tConfItemBase *) 0 ;
03410   void *argp1 = 0 ;
03411   int res1 = 0 ;
03412   
03413   if ((argc < 1) || (argc > 1)) {
03414     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
03415   }
03416   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_tConfItemBase, 0 |  0 );
03417   if (!SWIG_IsOK(res1)) {
03418     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_TConfItemBase" "', argument " "1"" of type '" "tConfItemBase *""'"); 
03419   }
03420   arg1 = reinterpret_cast< tConfItemBase * >(argp1);
03421   {
03422     Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
03423     if (director) director->swig_disown();
03424   }
03425   
03426   return Qnil;
03427 fail:
03428   return Qnil;
03429 }
03430 
03431 
03432 swig_class cTOutput;
03433 
03434 SWIGINTERN VALUE
03435 _wrap_new_TOutput__SWIG_0(int argc, VALUE *argv, VALUE self) {
03436   tOutput *result = 0 ;
03437   const char *classname SWIGUNUSED = "Armagetronad::TOutput";
03438   
03439   if ((argc < 0) || (argc > 0)) {
03440     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
03441   }
03442   result = (tOutput *)new tOutput();DATA_PTR(self) = result;
03443   
03444   return self;
03445 fail:
03446   return Qnil;
03447 }
03448 
03449 
03450 SWIGINTERN void
03451 free_tOutput(tOutput *arg1) {
03452     delete arg1;
03453 }
03454 
03455 SWIGINTERN VALUE
03456 _wrap_TOutput_add_literal(int argc, VALUE *argv, VALUE self) {
03457   tOutput *arg1 = (tOutput *) 0 ;
03458   char *arg2 = (char *) 0 ;
03459   void *argp1 = 0 ;
03460   int res1 = 0 ;
03461   int res2 ;
03462   char *buf2 = 0 ;
03463   int alloc2 = 0 ;
03464   
03465   if ((argc < 1) || (argc > 1)) {
03466     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
03467   }
03468   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tOutput, 0 |  0 );
03469   if (!SWIG_IsOK(res1)) {
03470     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddLiteral" "', argument " "1"" of type '" "tOutput *""'"); 
03471   }
03472   arg1 = reinterpret_cast< tOutput * >(argp1);
03473   res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
03474   if (!SWIG_IsOK(res2)) {
03475     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddLiteral" "', argument " "2"" of type '" "char const *""'");
03476   }
03477   arg2 = reinterpret_cast< char * >(buf2);
03478   (arg1)->AddLiteral((char const *)arg2);
03479   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
03480   return Qnil;
03481 fail:
03482   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
03483   return Qnil;
03484 }
03485 
03486 
03487 SWIGINTERN VALUE
03488 _wrap_TOutput_add_locale(int argc, VALUE *argv, VALUE self) {
03489   tOutput *arg1 = (tOutput *) 0 ;
03490   char *arg2 = (char *) 0 ;
03491   void *argp1 = 0 ;
03492   int res1 = 0 ;
03493   int res2 ;
03494   char *buf2 = 0 ;
03495   int alloc2 = 0 ;
03496   
03497   if ((argc < 1) || (argc > 1)) {
03498     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
03499   }
03500   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tOutput, 0 |  0 );
03501   if (!SWIG_IsOK(res1)) {
03502     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddLocale" "', argument " "1"" of type '" "tOutput *""'"); 
03503   }
03504   arg1 = reinterpret_cast< tOutput * >(argp1);
03505   res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
03506   if (!SWIG_IsOK(res2)) {
03507     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddLocale" "', argument " "2"" of type '" "char const *""'");
03508   }
03509   arg2 = reinterpret_cast< char * >(buf2);
03510   (arg1)->AddLocale((char const *)arg2);
03511   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
03512   return Qnil;
03513 fail:
03514   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
03515   return Qnil;
03516 }
03517 
03518 
03519 SWIGINTERN VALUE
03520 _wrap_TOutput_add_space(int argc, VALUE *argv, VALUE self) {
03521   tOutput *arg1 = (tOutput *) 0 ;
03522   void *argp1 = 0 ;
03523   int res1 = 0 ;
03524   
03525   if ((argc < 0) || (argc > 0)) {
03526     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
03527   }
03528   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tOutput, 0 |  0 );
03529   if (!SWIG_IsOK(res1)) {
03530     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddSpace" "', argument " "1"" of type '" "tOutput *""'"); 
03531   }
03532   arg1 = reinterpret_cast< tOutput * >(argp1);
03533   (arg1)->AddSpace();
03534   return Qnil;
03535 fail:
03536   return Qnil;
03537 }
03538 
03539 
03540 SWIGINTERN VALUE
03541 _wrap_TOutput_set_template_parameter_string(int argc, VALUE *argv, VALUE self) {
03542   tOutput *arg1 = (tOutput *) 0 ;
03543   int arg2 ;
03544   char *arg3 = (char *) 0 ;
03545   tOutput *result = 0 ;
03546   void *argp1 = 0 ;
03547   int res1 = 0 ;
03548   int val2 ;
03549   int ecode2 = 0 ;
03550   int res3 ;
03551   char *buf3 = 0 ;
03552   int alloc3 = 0 ;
03553   VALUE vresult = Qnil;
03554   
03555   if ((argc < 2) || (argc > 2)) {
03556     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
03557   }
03558   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tOutput, 0 |  0 );
03559   if (!SWIG_IsOK(res1)) {
03560     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetTemplateParameter" "', argument " "1"" of type '" "tOutput *""'"); 
03561   }
03562   arg1 = reinterpret_cast< tOutput * >(argp1);
03563   ecode2 = SWIG_AsVal_int(argv[0], &val2);
03564   if (!SWIG_IsOK(ecode2)) {
03565     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetTemplateParameter" "', argument " "2"" of type '" "int""'");
03566   } 
03567   arg2 = static_cast< int >(val2);
03568   res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
03569   if (!SWIG_IsOK(res3)) {
03570     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SetTemplateParameter" "', argument " "3"" of type '" "char const *""'");
03571   }
03572   arg3 = reinterpret_cast< char * >(buf3);
03573   {
03574     tOutput &_result_ref = (arg1)->SetTemplateParameter(arg2,(char const *)arg3);
03575     result = (tOutput *) &_result_ref;
03576   }
03577   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_tOutput, 0 |  0 );
03578   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
03579   return vresult;
03580 fail:
03581   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
03582   return Qnil;
03583 }
03584 
03585 
03586 SWIGINTERN VALUE
03587 _wrap_TOutput_set_template_parameter_float(int argc, VALUE *argv, VALUE self) {
03588   tOutput *arg1 = (tOutput *) 0 ;
03589   int arg2 ;
03590   float arg3 ;
03591   tOutput *result = 0 ;
03592   void *argp1 = 0 ;
03593   int res1 = 0 ;
03594   int val2 ;
03595   int ecode2 = 0 ;
03596   float val3 ;
03597   int ecode3 = 0 ;
03598   VALUE vresult = Qnil;
03599   
03600   if ((argc < 2) || (argc > 2)) {
03601     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
03602   }
03603   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tOutput, 0 |  0 );
03604   if (!SWIG_IsOK(res1)) {
03605     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetTemplateParameter" "', argument " "1"" of type '" "tOutput *""'"); 
03606   }
03607   arg1 = reinterpret_cast< tOutput * >(argp1);
03608   ecode2 = SWIG_AsVal_int(argv[0], &val2);
03609   if (!SWIG_IsOK(ecode2)) {
03610     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetTemplateParameter" "', argument " "2"" of type '" "int""'");
03611   } 
03612   arg2 = static_cast< int >(val2);
03613   ecode3 = SWIG_AsVal_float(argv[1], &val3);
03614   if (!SWIG_IsOK(ecode3)) {
03615     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SetTemplateParameter" "', argument " "3"" of type '" "float""'");
03616   } 
03617   arg3 = static_cast< float >(val3);
03618   {
03619     tOutput &_result_ref = (arg1)->SetTemplateParameter(arg2,arg3);
03620     result = (tOutput *) &_result_ref;
03621   }
03622   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_tOutput, 0 |  0 );
03623   return vresult;
03624 fail:
03625   return Qnil;
03626 }
03627 
03628 
03629 SWIGINTERN VALUE
03630 _wrap_TOutput_clear(int argc, VALUE *argv, VALUE self) {
03631   tOutput *arg1 = (tOutput *) 0 ;
03632   void *argp1 = 0 ;
03633   int res1 = 0 ;
03634   
03635   if ((argc < 0) || (argc > 0)) {
03636     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
03637   }
03638   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tOutput, 0 |  0 );
03639   if (!SWIG_IsOK(res1)) {
03640     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Clear" "', argument " "1"" of type '" "tOutput *""'"); 
03641   }
03642   arg1 = reinterpret_cast< tOutput * >(argp1);
03643   (arg1)->Clear();
03644   return Qnil;
03645 fail:
03646   return Qnil;
03647 }
03648 
03649 
03650 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
03651 SWIGINTERN VALUE
03652 _wrap_TOutput_allocate(VALUE self) {
03653 #else
03654   SWIGINTERN VALUE
03655   _wrap_TOutput_allocate(int argc, VALUE *argv, VALUE self) {
03656 #endif
03657     
03658     
03659     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_tOutput);
03660 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
03661     rb_obj_call_init(vresult, argc, argv);
03662 #endif
03663     return vresult;
03664   }
03665   
03666 
03667 SWIGINTERN VALUE
03668 _wrap_new_TOutput__SWIG_1(int argc, VALUE *argv, VALUE self) {
03669   char *arg1 = (char *) 0 ;
03670   tOutput *result = 0 ;
03671   int res1 ;
03672   char *buf1 = 0 ;
03673   int alloc1 = 0 ;
03674   const char *classname SWIGUNUSED = "Armagetronad::TOutput";
03675   
03676   if ((argc < 1) || (argc > 1)) {
03677     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
03678   }
03679   res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
03680   if (!SWIG_IsOK(res1)) {
03681     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tOutput" "', argument " "1"" of type '" "char const *""'");
03682   }
03683   arg1 = reinterpret_cast< char * >(buf1);
03684   result = (tOutput *)new tOutput((char const *)arg1);DATA_PTR(self) = result;
03685   
03686   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
03687   return self;
03688 fail:
03689   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
03690   return Qnil;
03691 }
03692 
03693 
03694 SWIGINTERN VALUE _wrap_new_TOutput(int nargs, VALUE *args, VALUE self) {
03695   int argc;
03696   VALUE argv[1];
03697   int ii;
03698   
03699   argc = nargs;
03700   if (argc > 1) SWIG_fail;
03701   for (ii = 0; (ii < argc); ii++) {
03702     argv[ii] = args[ii];
03703   }
03704   if (argc == 0) {
03705     return _wrap_new_TOutput__SWIG_0(nargs, args, self);
03706   }
03707   if (argc == 1) {
03708     int _v;
03709     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
03710     _v = SWIG_CheckState(res);
03711     if (_v) {
03712       return _wrap_new_TOutput__SWIG_1(nargs, args, self);
03713     }
03714   }
03715   
03716 fail:
03717   rb_raise(rb_eArgError, "No matching function for overloaded 'new_TOutput'");
03718   return Qnil;
03719 }
03720 
03721 
03722 SWIGINTERN VALUE
03723 _wrap_TOutput_append(int argc, VALUE *argv, VALUE self) {
03724   tOutput *arg1 = (tOutput *) 0 ;
03725   tOutput *arg2 = 0 ;
03726   void *argp1 = 0 ;
03727   int res1 = 0 ;
03728   void *argp2 ;
03729   int res2 = 0 ;
03730   
03731   if ((argc < 1) || (argc > 1)) {
03732     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
03733   }
03734   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tOutput, 0 |  0 );
03735   if (!SWIG_IsOK(res1)) {
03736     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Append" "', argument " "1"" of type '" "tOutput *""'"); 
03737   }
03738   arg1 = reinterpret_cast< tOutput * >(argp1);
03739   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_tOutput,  0 );
03740   if (!SWIG_IsOK(res2)) {
03741     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Append" "', argument " "2"" of type '" "tOutput const &""'"); 
03742   }
03743   if (!argp2) {
03744     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Append" "', argument " "2"" of type '" "tOutput const &""'"); 
03745   }
03746   arg2 = reinterpret_cast< tOutput * >(argp2);
03747   (arg1)->Append((tOutput const &)*arg2);
03748   return Qnil;
03749 fail:
03750   return Qnil;
03751 }
03752 
03753 
03754 SWIGINTERN VALUE
03755 _wrap_TOutput_is_empty(int argc, VALUE *argv, VALUE self) {
03756   tOutput *arg1 = (tOutput *) 0 ;
03757   bool result;
03758   void *argp1 = 0 ;
03759   int res1 = 0 ;
03760   VALUE vresult = Qnil;
03761   
03762   if ((argc < 0) || (argc > 0)) {
03763     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
03764   }
03765   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tOutput, 0 |  0 );
03766   if (!SWIG_IsOK(res1)) {
03767     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsEmpty" "', argument " "1"" of type '" "tOutput const *""'"); 
03768   }
03769   arg1 = reinterpret_cast< tOutput * >(argp1);
03770   result = (bool)((tOutput const *)arg1)->IsEmpty();
03771   vresult = SWIG_From_bool(static_cast< bool >(result));
03772   return vresult;
03773 fail:
03774   return Qnil;
03775 }
03776 
03777 
03778 swig_class cTPath;
03779 
03780 SWIGINTERN VALUE
03781 _wrap_TPath_open__SWIG_0(int argc, VALUE *argv, VALUE self) {
03782   tPath *arg1 = (tPath *) 0 ;
03783   std::ifstream *arg2 = 0 ;
03784   char *arg3 = (char *) 0 ;
03785   bool result;
03786   void *argp1 = 0 ;
03787   int res1 = 0 ;
03788   void *argp2 = 0 ;
03789   int res2 = 0 ;
03790   int res3 ;
03791   char *buf3 = 0 ;
03792   int alloc3 = 0 ;
03793   VALUE vresult = Qnil;
03794   
03795   if ((argc < 2) || (argc > 2)) {
03796     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
03797   }
03798   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tPath, 0 |  0 );
03799   if (!SWIG_IsOK(res1)) {
03800     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Open" "', argument " "1"" of type '" "tPath const *""'"); 
03801   }
03802   arg1 = reinterpret_cast< tPath * >(argp1);
03803   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__ifstream,  0 );
03804   if (!SWIG_IsOK(res2)) {
03805     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Open" "', argument " "2"" of type '" "std::ifstream &""'"); 
03806   }
03807   if (!argp2) {
03808     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Open" "', argument " "2"" of type '" "std::ifstream &""'"); 
03809   }
03810   arg2 = reinterpret_cast< std::ifstream * >(argp2);
03811   res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
03812   if (!SWIG_IsOK(res3)) {
03813     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Open" "', argument " "3"" of type '" "char const *""'");
03814   }
03815   arg3 = reinterpret_cast< char * >(buf3);
03816   result = (bool)((tPath const *)arg1)->Open(*arg2,(char const *)arg3);
03817   vresult = SWIG_From_bool(static_cast< bool >(result));
03818   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
03819   return vresult;
03820 fail:
03821   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
03822   return Qnil;
03823 }
03824 
03825 
03826 SWIGINTERN VALUE
03827 _wrap_TPath_open__SWIG_1(int argc, VALUE *argv, VALUE self) {
03828   tPath *arg1 = (tPath *) 0 ;
03829   std::ofstream *arg2 = 0 ;
03830   char *arg3 = (char *) 0 ;
03831   std::ios::openmode arg4 ;
03832   bool result;
03833   void *argp1 = 0 ;
03834   int res1 = 0 ;
03835   void *argp2 = 0 ;
03836   int res2 = 0 ;
03837   int res3 ;
03838   char *buf3 = 0 ;
03839   int alloc3 = 0 ;
03840   void *argp4 ;
03841   int res4 = 0 ;
03842   VALUE vresult = Qnil;
03843   
03844   if ((argc < 3) || (argc > 3)) {
03845     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
03846   }
03847   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tPath, 0 |  0 );
03848   if (!SWIG_IsOK(res1)) {
03849     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Open" "', argument " "1"" of type '" "tPath const *""'"); 
03850   }
03851   arg1 = reinterpret_cast< tPath * >(argp1);
03852   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__ofstream,  0 );
03853   if (!SWIG_IsOK(res2)) {
03854     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Open" "', argument " "2"" of type '" "std::ofstream &""'"); 
03855   }
03856   if (!argp2) {
03857     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Open" "', argument " "2"" of type '" "std::ofstream &""'"); 
03858   }
03859   arg2 = reinterpret_cast< std::ofstream * >(argp2);
03860   res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
03861   if (!SWIG_IsOK(res3)) {
03862     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Open" "', argument " "3"" of type '" "char const *""'");
03863   }
03864   arg3 = reinterpret_cast< char * >(buf3);
03865   {
03866     res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_std__ios__openmode,  0 );
03867     if (!SWIG_IsOK(res4)) {
03868       SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Open" "', argument " "4"" of type '" "std::ios::openmode""'"); 
03869     }  
03870     if (!argp4) {
03871       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Open" "', argument " "4"" of type '" "std::ios::openmode""'");
03872     } else {
03873       arg4 = *(reinterpret_cast< std::ios::openmode * >(argp4));
03874     }
03875   }
03876   result = (bool)((tPath const *)arg1)->Open(*arg2,(char const *)arg3,arg4);
03877   vresult = SWIG_From_bool(static_cast< bool >(result));
03878   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
03879   return vresult;
03880 fail:
03881   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
03882   return Qnil;
03883 }
03884 
03885 
03886 SWIGINTERN VALUE
03887 _wrap_TPath_open__SWIG_2(int argc, VALUE *argv, VALUE self) {
03888   tPath *arg1 = (tPath *) 0 ;
03889   std::ofstream *arg2 = 0 ;
03890   char *arg3 = (char *) 0 ;
03891   bool result;
03892   void *argp1 = 0 ;
03893   int res1 = 0 ;
03894   void *argp2 = 0 ;
03895   int res2 = 0 ;
03896   int res3 ;
03897   char *buf3 = 0 ;
03898   int alloc3 = 0 ;
03899   VALUE vresult = Qnil;
03900   
03901   if ((argc < 2) || (argc > 2)) {
03902     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
03903   }
03904   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tPath, 0 |  0 );
03905   if (!SWIG_IsOK(res1)) {
03906     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Open" "', argument " "1"" of type '" "tPath const *""'"); 
03907   }
03908   arg1 = reinterpret_cast< tPath * >(argp1);
03909   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__ofstream,  0 );
03910   if (!SWIG_IsOK(res2)) {
03911     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Open" "', argument " "2"" of type '" "std::ofstream &""'"); 
03912   }
03913   if (!argp2) {
03914     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Open" "', argument " "2"" of type '" "std::ofstream &""'"); 
03915   }
03916   arg2 = reinterpret_cast< std::ofstream * >(argp2);
03917   res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
03918   if (!SWIG_IsOK(res3)) {
03919     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Open" "', argument " "3"" of type '" "char const *""'");
03920   }
03921   arg3 = reinterpret_cast< char * >(buf3);
03922   result = (bool)((tPath const *)arg1)->Open(*arg2,(char const *)arg3);
03923   vresult = SWIG_From_bool(static_cast< bool >(result));
03924   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
03925   return vresult;
03926 fail:
03927   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
03928   return Qnil;
03929 }
03930 
03931 
03932 SWIGINTERN VALUE
03933 _wrap_TPath_open__SWIG_3(int argc, VALUE *argv, VALUE self) {
03934   tPath *arg1 = (tPath *) 0 ;
03935   std::fstream *arg2 = 0 ;
03936   char *arg3 = (char *) 0 ;
03937   bool result;
03938   void *argp1 = 0 ;
03939   int res1 = 0 ;
03940   void *argp2 = 0 ;
03941   int res2 = 0 ;
03942   int res3 ;
03943   char *buf3 = 0 ;
03944   int alloc3 = 0 ;
03945   VALUE vresult = Qnil;
03946   
03947   if ((argc < 2) || (argc > 2)) {
03948     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
03949   }
03950   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tPath, 0 |  0 );
03951   if (!SWIG_IsOK(res1)) {
03952     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Open" "', argument " "1"" of type '" "tPath const *""'"); 
03953   }
03954   arg1 = reinterpret_cast< tPath * >(argp1);
03955   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__fstream,  0 );
03956   if (!SWIG_IsOK(res2)) {
03957     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Open" "', argument " "2"" of type '" "std::fstream &""'"); 
03958   }
03959   if (!argp2) {
03960     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Open" "', argument " "2"" of type '" "std::fstream &""'"); 
03961   }
03962   arg2 = reinterpret_cast< std::fstream * >(argp2);
03963   res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
03964   if (!SWIG_IsOK(res3)) {
03965     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Open" "', argument " "3"" of type '" "char const *""'");
03966   }
03967   arg3 = reinterpret_cast< char * >(buf3);
03968   result = (bool)((tPath const *)arg1)->Open(*arg2,(char const *)arg3);
03969   vresult = SWIG_From_bool(static_cast< bool >(result));
03970   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
03971   return vresult;
03972 fail:
03973   if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
03974   return Qnil;
03975 }
03976 
03977 
03978 SWIGINTERN VALUE _wrap_TPath_open(int nargs, VALUE *args, VALUE self) {
03979   int argc;
03980   VALUE argv[5];
03981   int ii;
03982   
03983   argc = nargs + 1;
03984   argv[0] = self;
03985   if (argc > 5) SWIG_fail;
03986   for (ii = 1; (ii < argc); ii++) {
03987     argv[ii] = args[ii-1];
03988   }
03989   if (argc == 3) {
03990     int _v;
03991     void *vptr = 0;
03992     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tPath, 0);
03993     _v = SWIG_CheckState(res);
03994     if (_v) {
03995       void *vptr = 0;
03996       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ifstream, 0);
03997       _v = SWIG_CheckState(res);
03998       if (_v) {
03999         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
04000         _v = SWIG_CheckState(res);
04001         if (_v) {
04002           return _wrap_TPath_open__SWIG_0(nargs, args, self);
04003         }
04004       }
04005     }
04006   }
04007   if (argc == 3) {
04008     int _v;
04009     void *vptr = 0;
04010     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tPath, 0);
04011     _v = SWIG_CheckState(res);
04012     if (_v) {
04013       void *vptr = 0;
04014       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ofstream, 0);
04015       _v = SWIG_CheckState(res);
04016       if (_v) {
04017         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
04018         _v = SWIG_CheckState(res);
04019         if (_v) {
04020           return _wrap_TPath_open__SWIG_2(nargs, args, self);
04021         }
04022       }
04023     }
04024   }
04025   if (argc == 3) {
04026     int _v;
04027     void *vptr = 0;
04028     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tPath, 0);
04029     _v = SWIG_CheckState(res);
04030     if (_v) {
04031       void *vptr = 0;
04032       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__fstream, 0);
04033       _v = SWIG_CheckState(res);
04034       if (_v) {
04035         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
04036         _v = SWIG_CheckState(res);
04037         if (_v) {
04038           return _wrap_TPath_open__SWIG_3(nargs, args, self);
04039         }
04040       }
04041     }
04042   }
04043   if (argc == 4) {
04044     int _v;
04045     void *vptr = 0;
04046     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tPath, 0);
04047     _v = SWIG_CheckState(res);
04048     if (_v) {
04049       void *vptr = 0;
04050       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ofstream, 0);
04051       _v = SWIG_CheckState(res);
04052       if (_v) {
04053         int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
04054         _v = SWIG_CheckState(res);
04055         if (_v) {
04056           void *vptr = 0;
04057           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__ios__openmode, 0);
04058           _v = SWIG_CheckState(res);
04059           if (_v) {
04060             return _wrap_TPath_open__SWIG_1(nargs, args, self);
04061           }
04062         }
04063       }
04064     }
04065   }
04066   
04067 fail:
04068   rb_raise(rb_eArgError, "No matching function for overloaded 'TPath_open'");
04069   return Qnil;
04070 }
04071 
04072 
04073 SWIGINTERN VALUE
04074 _wrap_TPath_get_read_path(int argc, VALUE *argv, VALUE self) {
04075   tPath *arg1 = (tPath *) 0 ;
04076   char *arg2 = (char *) 0 ;
04077   tString result;
04078   void *argp1 = 0 ;
04079   int res1 = 0 ;
04080   int res2 ;
04081   char *buf2 = 0 ;
04082   int alloc2 = 0 ;
04083   VALUE vresult = Qnil;
04084   
04085   if ((argc < 1) || (argc > 1)) {
04086     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
04087   }
04088   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tPath, 0 |  0 );
04089   if (!SWIG_IsOK(res1)) {
04090     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetReadPath" "', argument " "1"" of type '" "tPath const *""'"); 
04091   }
04092   arg1 = reinterpret_cast< tPath * >(argp1);
04093   res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
04094   if (!SWIG_IsOK(res2)) {
04095     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetReadPath" "', argument " "2"" of type '" "char const *""'");
04096   }
04097   arg2 = reinterpret_cast< char * >(buf2);
04098   result = ((tPath const *)arg1)->GetReadPath((char const *)arg2);
04099   vresult = SWIG_NewPointerObj((new tString(static_cast< const tString& >(result))), SWIGTYPE_p_tString, SWIG_POINTER_OWN |  0 );
04100   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
04101   return vresult;
04102 fail:
04103   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
04104   return Qnil;
04105 }
04106 
04107 
04108 SWIGINTERN VALUE
04109 _wrap_TPath_get_write_path(int argc, VALUE *argv, VALUE self) {
04110   tPath *arg1 = (tPath *) 0 ;
04111   char *arg2 = (char *) 0 ;
04112   tString result;
04113   void *argp1 = 0 ;
04114   int res1 = 0 ;
04115   int res2 ;
04116   char *buf2 = 0 ;
04117   int alloc2 = 0 ;
04118   VALUE vresult = Qnil;
04119   
04120   if ((argc < 1) || (argc > 1)) {
04121     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
04122   }
04123   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tPath, 0 |  0 );
04124   if (!SWIG_IsOK(res1)) {
04125     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetWritePath" "', argument " "1"" of type '" "tPath const *""'"); 
04126   }
04127   arg1 = reinterpret_cast< tPath * >(argp1);
04128   res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
04129   if (!SWIG_IsOK(res2)) {
04130     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetWritePath" "', argument " "2"" of type '" "char const *""'");
04131   }
04132   arg2 = reinterpret_cast< char * >(buf2);
04133   result = ((tPath const *)arg1)->GetWritePath((char const *)arg2);
04134   vresult = SWIG_NewPointerObj((new tString(static_cast< const tString& >(result))), SWIGTYPE_p_tString, SWIG_POINTER_OWN |  0 );
04135   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
04136   return vresult;
04137 fail:
04138   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
04139   return Qnil;
04140 }
04141 
04142 
04143 SWIGINTERN VALUE
04144 _wrap_TPath_is_valid_path(int argc, VALUE *argv, VALUE self) {
04145   char *arg1 = (char *) 0 ;
04146   bool result;
04147   int res1 ;
04148   char *buf1 = 0 ;
04149   int alloc1 = 0 ;
04150   VALUE vresult = Qnil;
04151   
04152   if ((argc < 1) || (argc > 1)) {
04153     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
04154   }
04155   res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
04156   if (!SWIG_IsOK(res1)) {
04157     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tPath::IsValidPath" "', argument " "1"" of type '" "char const *""'");
04158   }
04159   arg1 = reinterpret_cast< char * >(buf1);
04160   result = (bool)tPath::IsValidPath((char const *)arg1);
04161   vresult = SWIG_From_bool(static_cast< bool >(result));
04162   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
04163   return vresult;
04164 fail:
04165   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
04166   return Qnil;
04167 }
04168 
04169 
04170 SWIGINTERN VALUE
04171 _wrap_TPath_get_paths(int argc, VALUE *argv, VALUE self) {
04172   tPath *arg1 = (tPath *) 0 ;
04173   tString result;
04174   void *argp1 = 0 ;
04175   int res1 = 0 ;
04176   VALUE vresult = Qnil;
04177   
04178   if ((argc < 0) || (argc > 0)) {
04179     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
04180   }
04181   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tPath, 0 |  0 );
04182   if (!SWIG_IsOK(res1)) {
04183     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetPaths" "', argument " "1"" of type '" "tPath const *""'"); 
04184   }
04185   arg1 = reinterpret_cast< tPath * >(argp1);
04186   result = ((tPath const *)arg1)->GetPaths();
04187   vresult = SWIG_NewPointerObj((new tString(static_cast< const tString& >(result))), SWIGTYPE_p_tString, SWIG_POINTER_OWN |  0 );
04188   return vresult;
04189 fail:
04190   return Qnil;
04191 }
04192 
04193 
04194 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
04195 SWIGINTERN VALUE
04196 _wrap_TPath_allocate(VALUE self) {
04197 #else
04198   SWIGINTERN VALUE
04199   _wrap_TPath_allocate(int argc, VALUE *argv, VALUE self) {
04200 #endif
04201     
04202     
04203     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_tPath);
04204 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
04205     rb_obj_call_init(vresult, argc, argv);
04206 #endif
04207     return vresult;
04208   }
04209   
04210 
04211 SWIGINTERN VALUE
04212 _wrap_new_TPath(int argc, VALUE *argv, VALUE self) {
04213   VALUE arg1 = (VALUE) 0 ;
04214   tPath *result = 0 ;
04215   const char *classname SWIGUNUSED = "Armagetronad::TPath";
04216   
04217   if ((argc < 0) || (argc > 0)) {
04218     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
04219   }
04220   arg1 = self;
04221   if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
04222     /* subclassed */
04223     result = (tPath *)new SwigDirector_TPath(arg1); 
04224   } else {
04225     rb_raise(rb_eNameError,"accessing abstract class or protected constructor"); 
04226     return Qnil;
04227   }
04228   DATA_PTR(self) = result;
04229   
04230   return self;
04231 fail:
04232   return Qnil;
04233 }
04234 
04235 
04236 SWIGINTERN void
04237 free_tPath(tPath *arg1) {
04238     delete arg1;
04239 }
04240 
04241 SWIGINTERN VALUE
04242 _wrap_TPath_paths(int argc, VALUE *argv, VALUE self) {
04243   tPath *arg1 = (tPath *) 0 ;
04244   tArray<tString > *arg2 = 0 ;
04245   void *argp1 = 0 ;
04246   int res1 = 0 ;
04247   void *argp2 = 0 ;
04248   int res2 = 0 ;
04249   Swig::Director *director = 0;
04250   bool upcall = false;
04251   SwigDirector_TPath *darg = 0;
04252   
04253   if ((argc < 1) || (argc > 1)) {
04254     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
04255   }
04256   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tPath, 0 |  0 );
04257   if (!SWIG_IsOK(res1)) {
04258     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Paths" "', argument " "1"" of type '" "tPath const *""'"); 
04259   }
04260   arg1 = reinterpret_cast< tPath * >(argp1);
04261   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_tArrayTtString_t,  0 );
04262   if (!SWIG_IsOK(res2)) {
04263     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Paths" "', argument " "2"" of type '" "tArray<tString > &""'"); 
04264   }
04265   if (!argp2) {
04266     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Paths" "', argument " "2"" of type '" "tArray<tString > &""'"); 
04267   }
04268   arg2 = reinterpret_cast< tArray<tString > * >(argp2);
04269   director = dynamic_cast<Swig::Director *>(arg1);
04270   upcall = (director && (director->swig_get_self() == self));
04271   try {
04272     darg = dynamic_cast<SwigDirector_TPath *>(arg1);
04273     if (upcall) {
04274       Swig::DirectorPureVirtualException::raise("tPath::Paths");
04275     } else {
04276       ((SwigDirector_TPath const *)darg)->Paths(*arg2);
04277     }
04278   } catch (Swig::DirectorException& e) {
04279     rb_exc_raise(e.getError());
04280     SWIG_fail;
04281   }
04282   return Qnil;
04283 fail:
04284   return Qnil;
04285 }
04286 
04287 
04288 SWIGINTERN VALUE
04289 _wrap_disown_TPath(int argc, VALUE *argv, VALUE self) {
04290   tPath *arg1 = (tPath *) 0 ;
04291   void *argp1 = 0 ;
04292   int res1 = 0 ;
04293   
04294   if ((argc < 1) || (argc > 1)) {
04295     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
04296   }
04297   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_tPath, 0 |  0 );
04298   if (!SWIG_IsOK(res1)) {
04299     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_TPath" "', argument " "1"" of type '" "tPath *""'"); 
04300   }
04301   arg1 = reinterpret_cast< tPath * >(argp1);
04302   {
04303     Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
04304     if (director) director->swig_disown();
04305   }
04306   
04307   return Qnil;
04308 fail:
04309   return Qnil;
04310 }
04311 
04312 
04313 swig_class cTPathResource;
04314 
04315 SWIGINTERN VALUE
04316 _wrap_TPathResource_get_write_path(int argc, VALUE *argv, VALUE self) {
04317   tPathResource *arg1 = (tPathResource *) 0 ;
04318   char *arg2 = (char *) 0 ;
04319   tString result;
04320   void *argp1 = 0 ;
04321   int res1 = 0 ;
04322   int res2 ;
04323   char *buf2 = 0 ;
04324   int alloc2 = 0 ;
04325   VALUE vresult = Qnil;
04326   
04327   if ((argc < 1) || (argc > 1)) {
04328     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
04329   }
04330   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_tPathResource, 0 |  0 );
04331   if (!SWIG_IsOK(res1)) {
04332     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetWritePath" "', argument " "1"" of type '" "tPathResource const *""'"); 
04333   }
04334   arg1 = reinterpret_cast< tPathResource * >(argp1);
04335   res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
04336   if (!SWIG_IsOK(res2)) {
04337     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetWritePath" "', argument " "2"" of type '" "char const *""'");
04338   }
04339   arg2 = reinterpret_cast< char * >(buf2);
04340   result = ((tPathResource const *)arg1)->GetWritePath((char const *)arg2);
04341   vresult = SWIG_NewPointerObj((new tString(static_cast< const tString& >(result))), SWIGTYPE_p_tString, SWIG_POINTER_OWN |  0 );
04342   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
04343   return vresult;
04344 fail:
04345   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
04346   return Qnil;
04347 }
04348 
04349 
04350 SWIGINTERN VALUE
04351 _wrap_TPathResource_get_dir_path(int argc, VALUE *argv, VALUE self) {
04352   tString result;
04353   VALUE vresult = Qnil;
04354   
04355   if ((argc < 0) || (argc > 0)) {
04356     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
04357   }
04358   result = tPathResource::GetDirPath();
04359   vresult = SWIG_NewPointerObj((new tString(static_cast< const tString& >(result))), SWIGTYPE_p_tString, SWIG_POINTER_OWN |  0 );
04360   return vresult;
04361 fail:
04362   return Qnil;
04363 }
04364 
04365 
04366 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
04367 SWIGINTERN VALUE
04368 _wrap_TPathResource_allocate(VALUE self) {
04369 #else
04370   SWIGINTERN VALUE
04371   _wrap_TPathResource_allocate(int argc, VALUE *argv, VALUE self) {
04372 #endif
04373     
04374     
04375     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_tPathResource);
04376 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
04377     rb_obj_call_init(vresult, argc, argv);
04378 #endif
04379     return vresult;
04380   }
04381   
04382 
04383 SWIGINTERN VALUE
04384 _wrap_new_TPathResource(int argc, VALUE *argv, VALUE self) {
04385   tPathResource *result = 0 ;
04386   const char *classname SWIGUNUSED = "Armagetronad::TPathResource";
04387   
04388   if ((argc < 0) || (argc > 0)) {
04389     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
04390   }
04391   result = (tPathResource *)new tPathResource();DATA_PTR(self) = result;
04392   
04393   return self;
04394 fail:
04395   return Qnil;
04396 }
04397 
04398 
04399 SWIGINTERN void
04400 free_tPathResource(tPathResource *arg1) {
04401     delete arg1;
04402 }
04403 
04404 swig_class cTPathScripts;
04405 
04406 SWIGINTERN VALUE
04407 _wrap_TPathScripts_get_dir_path(int argc, VALUE *argv, VALUE self) {
04408   tString result;
04409   VALUE vresult = Qnil;
04410   
04411   if ((argc < 0) || (argc > 0)) {
04412     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
04413   }
04414   result = tPathScripts::GetDirPath();
04415   vresult = SWIG_NewPointerObj((new tString(static_cast< const tString& >(result))), SWIGTYPE_p_tString, SWIG_POINTER_OWN |  0 );
04416   return vresult;
04417 fail:
04418   return Qnil;
04419 }
04420 
04421 
04422 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
04423 SWIGINTERN VALUE
04424 _wrap_TPathScripts_allocate(VALUE self) {
04425 #else
04426   SWIGINTERN VALUE
04427   _wrap_TPathScripts_allocate(int argc, VALUE *argv, VALUE self) {
04428 #endif
04429     
04430     
04431     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_tPathScripts);
04432 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
04433     rb_obj_call_init(vresult, argc, argv);
04434 #endif
04435     return vresult;
04436   }
04437   
04438 
04439 SWIGINTERN VALUE
04440 _wrap_new_TPathScripts(int argc, VALUE *argv, VALUE self) {
04441   tPathScripts *result = 0 ;
04442   const char *classname SWIGUNUSED = "Armagetronad::TPathScripts";
04443   
04444   if ((argc < 0) || (argc > 0)) {
04445     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
04446   }
04447   result = (tPathScripts *)new tPathScripts();DATA_PTR(self) = result;
04448   
04449   return self;
04450 fail:
04451   return Qnil;
04452 }
04453 
04454 
04455 SWIGINTERN void
04456 free_tPathScripts(tPathScripts *arg1) {
04457     delete arg1;
04458 }
04459 
04460 swig_class cTDirectories;
04461 
04462 SWIGINTERN VALUE
04463 _wrap_TDirectories_data(int argc, VALUE *argv, VALUE self) {
04464   tPath *result = 0 ;
04465   Swig::Director *director = 0;
04466   VALUE vresult = Qnil;
04467   
04468   if ((argc < 0) || (argc > 0)) {
04469     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
04470   }
04471   {
04472     tPath const &_result_ref = tDirectories::Data();
04473     result = (tPath *) &_result_ref;
04474   }
04475   director = dynamic_cast<Swig::Director *>(result);
04476   if (director) {
04477     vresult = director->swig_get_self();
04478   } else {
04479     vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_tPath, 0 |  0 );
04480   }
04481   return vresult;
04482 fail:
04483   return Qnil;
04484 }
04485 
04486 
04487 SWIGINTERN VALUE
04488 _wrap_TDirectories_music(int argc, VALUE *argv, VALUE self) {
04489   tPath *result = 0 ;
04490   Swig::Director *director = 0;
04491   VALUE vresult = Qnil;
04492   
04493   if ((argc < 0) || (argc > 0)) {
04494     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
04495   }
04496   {
04497     tPath const &_result_ref = tDirectories::Music();
04498     result = (tPath *) &_result_ref;
04499   }
04500   director = dynamic_cast<Swig::Director *>(result);
04501   if (director) {
04502     vresult = director->swig_get_self();
04503   } else {
04504     vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_tPath, 0 |  0 );
04505   }
04506   return vresult;
04507 fail:
04508   return Qnil;
04509 }
04510 
04511 
04512 SWIGINTERN VALUE
04513 _wrap_TDirectories_config(int argc, VALUE *argv, VALUE self) {
04514   tPath *result = 0 ;
04515   Swig::Director *director = 0;
04516   VALUE vresult = Qnil;
04517   
04518   if ((argc < 0) || (argc > 0)) {
04519     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
04520   }
04521   {
04522     tPath const &_result_ref = tDirectories::Config();
04523     result = (tPath *) &_result_ref;
04524   }
04525   director = dynamic_cast<Swig::Director *>(result);
04526   if (director) {
04527     vresult = director->swig_get_self();
04528   } else {
04529     vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_tPath, 0 |  0 );
04530   }
04531   return vresult;
04532 fail:
04533   return Qnil;
04534 }
04535 
04536 
04537 SWIGINTERN VALUE
04538 _wrap_TDirectories_var(int argc, VALUE *argv, VALUE self) {
04539   tPath *result = 0 ;
04540   Swig::Director *director = 0;
04541   VALUE vresult = Qnil;
04542   
04543   if ((argc < 0) || (argc > 0)) {
04544     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
04545   }
04546   {
04547     tPath const &_result_ref = tDirectories::Var();
04548     result = (tPath *) &_result_ref;
04549   }
04550   director = dynamic_cast<Swig::Director *>(result);
04551   if (director) {
04552     vresult = director->swig_get_self();
04553   } else {
04554     vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_tPath, 0 |  0 );
04555   }
04556   return vresult;
04557 fail:
04558   return Qnil;
04559 }
04560 
04561 
04562 SWIGINTERN VALUE
04563 _wrap_TDirectories_screenshot(int argc, VALUE *argv, VALUE self) {
04564   tPath *result = 0 ;
04565   Swig::Director *director = 0;
04566   VALUE vresult = Qnil;
04567   
04568   if ((argc < 0) || (argc > 0)) {
04569     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
04570   }
04571   {
04572     tPath const &_result_ref = tDirectories::Screenshot();
04573     result = (tPath *) &_result_ref;
04574   }
04575   director = dynamic_cast<Swig::Director *>(result);
04576   if (director) {
04577     vresult = director->swig_get_self();
04578   } else {
04579     vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_tPath, 0 |  0 );
04580   }
04581   return vresult;
04582 fail:
04583   return Qnil;
04584 }
04585 
04586 
04587 SWIGINTERN VALUE
04588 _wrap_TDirectories_resource(int argc, VALUE *argv, VALUE self) {
04589   tPathResource *result = 0 ;
04590   VALUE vresult = Qnil;
04591   
04592   if ((argc < 0) || (argc > 0)) {
04593     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
04594   }
04595   {
04596     tPathResource const &_result_ref = tDirectories::Resource();
04597     result = (tPathResource *) &_result_ref;
04598   }
04599   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_tPathResource, 0 |  0 );
04600   return vresult;
04601 fail:
04602   return Qnil;
04603 }
04604 
04605 
04606 SWIGINTERN VALUE
04607 _wrap_TDirectories_scripts(int argc, VALUE *argv, VALUE self) {
04608   tPath *result = 0 ;
04609   Swig::Director *director = 0;
04610   VALUE vresult = Qnil;
04611   
04612   if ((argc < 0) || (argc > 0)) {
04613     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
04614   }
04615   {
04616     tPath const &_result_ref = tDirectories::Scripts();
04617     result = (tPath *) &_result_ref;
04618   }
04619   director = dynamic_cast<Swig::Director *>(result);
04620   if (director) {
04621     vresult = director->swig_get_self();
04622   } else {
04623     vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_tPath, 0 |  0 );
04624   }
04625   return vresult;
04626 fail:
04627   return Qnil;
04628 }
04629 
04630 
04631 SWIGINTERN VALUE
04632 _wrap_TDirectories_set_data(int argc, VALUE *argv, VALUE self) {
04633   tString *arg1 = 0 ;
04634   void *argp1 ;
04635   int res1 = 0 ;
04636   
04637   if ((argc < 1) || (argc > 1)) {
04638     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
04639   }
04640   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tString,  0 );
04641   if (!SWIG_IsOK(res1)) {
04642     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::SetData" "', argument " "1"" of type '" "tString const &""'"); 
04643   }
04644   if (!argp1) {
04645     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::SetData" "', argument " "1"" of type '" "tString const &""'"); 
04646   }
04647   arg1 = reinterpret_cast< tString * >(argp1);
04648   tDirectories::SetData((tString const &)*arg1);
04649   return Qnil;
04650 fail:
04651   return Qnil;
04652 }
04653 
04654 
04655 SWIGINTERN VALUE
04656 _wrap_TDirectories_set_user_data(int argc, VALUE *argv, VALUE self) {
04657   tString *arg1 = 0 ;
04658   void *argp1 ;
04659   int res1 = 0 ;
04660   
04661   if ((argc < 1) || (argc > 1)) {
04662     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
04663   }
04664   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tString,  0 );
04665   if (!SWIG_IsOK(res1)) {
04666     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::SetUserData" "', argument " "1"" of type '" "tString const &""'"); 
04667   }
04668   if (!argp1) {
04669     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::SetUserData" "', argument " "1"" of type '" "tString const &""'"); 
04670   }
04671   arg1 = reinterpret_cast< tString * >(argp1);
04672   tDirectories::SetUserData((tString const &)*arg1);
04673   return Qnil;
04674 fail:
04675   return Qnil;
04676 }
04677 
04678 
04679 SWIGINTERN VALUE
04680 _wrap_TDirectories_set_config(int argc, VALUE *argv, VALUE self) {
04681   tString *arg1 = 0 ;
04682   void *argp1 ;
04683   int res1 = 0 ;
04684   
04685   if ((argc < 1) || (argc > 1)) {
04686     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
04687   }
04688   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tString,  0 );
04689   if (!SWIG_IsOK(res1)) {
04690     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::SetConfig" "', argument " "1"" of type '" "tString const &""'"); 
04691   }
04692   if (!argp1) {
04693     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::SetConfig" "', argument " "1"" of type '" "tString const &""'"); 
04694   }
04695   arg1 = reinterpret_cast< tString * >(argp1);
04696   tDirectories::SetConfig((tString const &)*arg1);
04697   return Qnil;
04698 fail:
04699   return Qnil;
04700 }
04701 
04702 
04703 SWIGINTERN VALUE
04704 _wrap_TDirectories_set_user_config(int argc, VALUE *argv, VALUE self) {
04705   tString *arg1 = 0 ;
04706   void *argp1 ;
04707   int res1 = 0 ;
04708   
04709   if ((argc < 1) || (argc > 1)) {
04710     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
04711   }
04712   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tString,  0 );
04713   if (!SWIG_IsOK(res1)) {
04714     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::SetUserConfig" "', argument " "1"" of type '" "tString const &""'"); 
04715   }
04716   if (!argp1) {
04717     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::SetUserConfig" "', argument " "1"" of type '" "tString const &""'"); 
04718   }
04719   arg1 = reinterpret_cast< tString * >(argp1);
04720   tDirectories::SetUserConfig((tString const &)*arg1);
04721   return Qnil;
04722 fail:
04723   return Qnil;
04724 }
04725 
04726 
04727 SWIGINTERN VALUE
04728 _wrap_TDirectories_set_var(int argc, VALUE *argv, VALUE self) {
04729   tString *arg1 = 0 ;
04730   void *argp1 ;
04731   int res1 = 0 ;
04732   
04733   if ((argc < 1) || (argc > 1)) {
04734     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
04735   }
04736   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tString,  0 );
04737   if (!SWIG_IsOK(res1)) {
04738     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::SetVar" "', argument " "1"" of type '" "tString const &""'"); 
04739   }
04740   if (!argp1) {
04741     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::SetVar" "', argument " "1"" of type '" "tString const &""'"); 
04742   }
04743   arg1 = reinterpret_cast< tString * >(argp1);
04744   tDirectories::SetVar((tString const &)*arg1);
04745   return Qnil;
04746 fail:
04747   return Qnil;
04748 }
04749 
04750 
04751 SWIGINTERN VALUE
04752 _wrap_TDirectories_set_screenshot(int argc, VALUE *argv, VALUE self) {
04753   tString *arg1 = 0 ;
04754   void *argp1 ;
04755   int res1 = 0 ;
04756   
04757   if ((argc < 1) || (argc > 1)) {
04758     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
04759   }
04760   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tString,  0 );
04761   if (!SWIG_IsOK(res1)) {
04762     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::SetScreenshot" "', argument " "1"" of type '" "tString const &""'"); 
04763   }
04764   if (!argp1) {
04765     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::SetScreenshot" "', argument " "1"" of type '" "tString const &""'"); 
04766   }
04767   arg1 = reinterpret_cast< tString * >(argp1);
04768   tDirectories::SetScreenshot((tString const &)*arg1);
04769   return Qnil;
04770 fail:
04771   return Qnil;
04772 }
04773 
04774 
04775 SWIGINTERN VALUE
04776 _wrap_TDirectories_set_resource(int argc, VALUE *argv, VALUE self) {
04777   tString *arg1 = 0 ;
04778   void *argp1 ;
04779   int res1 = 0 ;
04780   
04781   if ((argc < 1) || (argc > 1)) {
04782     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
04783   }
04784   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tString,  0 );
04785   if (!SWIG_IsOK(res1)) {
04786     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::SetResource" "', argument " "1"" of type '" "tString const &""'"); 
04787   }
04788   if (!argp1) {
04789     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::SetResource" "', argument " "1"" of type '" "tString const &""'"); 
04790   }
04791   arg1 = reinterpret_cast< tString * >(argp1);
04792   tDirectories::SetResource((tString const &)*arg1);
04793   return Qnil;
04794 fail:
04795   return Qnil;
04796 }
04797 
04798 
04799 SWIGINTERN VALUE
04800 _wrap_TDirectories_set_auto_resource(int argc, VALUE *argv, VALUE self) {
04801   tString *arg1 = 0 ;
04802   void *argp1 ;
04803   int res1 = 0 ;
04804   
04805   if ((argc < 1) || (argc > 1)) {
04806     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
04807   }
04808   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tString,  0 );
04809   if (!SWIG_IsOK(res1)) {
04810     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::SetAutoResource" "', argument " "1"" of type '" "tString const &""'"); 
04811   }
04812   if (!argp1) {
04813     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::SetAutoResource" "', argument " "1"" of type '" "tString const &""'"); 
04814   }
04815   arg1 = reinterpret_cast< tString * >(argp1);
04816   tDirectories::SetAutoResource((tString const &)*arg1);
04817   return Qnil;
04818 fail:
04819   return Qnil;
04820 }
04821 
04822 
04823 SWIGINTERN VALUE
04824 _wrap_TDirectories_set_included_resource(int argc, VALUE *argv, VALUE self) {
04825   tString *arg1 = 0 ;
04826   void *argp1 ;
04827   int res1 = 0 ;
04828   
04829   if ((argc < 1) || (argc > 1)) {
04830     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
04831   }
04832   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tString,  0 );
04833   if (!SWIG_IsOK(res1)) {
04834     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::SetIncludedResource" "', argument " "1"" of type '" "tString const &""'"); 
04835   }
04836   if (!argp1) {
04837     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::SetIncludedResource" "', argument " "1"" of type '" "tString const &""'"); 
04838   }
04839   arg1 = reinterpret_cast< tString * >(argp1);
04840   tDirectories::SetIncludedResource((tString const &)*arg1);
04841   return Qnil;
04842 fail:
04843   return Qnil;
04844 }
04845 
04846 
04847 SWIGINTERN VALUE
04848 _wrap_TDirectories_get_files__SWIG_0(int argc, VALUE *argv, VALUE self) {
04849   tString *arg1 = 0 ;
04850   tString *arg2 = 0 ;
04851   tArray<tString > *arg3 = 0 ;
04852   int arg4 ;
04853   void *argp1 ;
04854   int res1 = 0 ;
04855   void *argp2 ;
04856   int res2 = 0 ;
04857   void *argp3 = 0 ;
04858   int res3 = 0 ;
04859   int val4 ;
04860   int ecode4 = 0 ;
04861   
04862   if ((argc < 4) || (argc > 4)) {
04863     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
04864   }
04865   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tString,  0 );
04866   if (!SWIG_IsOK(res1)) {
04867     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::GetFiles" "', argument " "1"" of type '" "tString const &""'"); 
04868   }
04869   if (!argp1) {
04870     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::GetFiles" "', argument " "1"" of type '" "tString const &""'"); 
04871   }
04872   arg1 = reinterpret_cast< tString * >(argp1);
04873   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_tString,  0 );
04874   if (!SWIG_IsOK(res2)) {
04875     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tDirectories::GetFiles" "', argument " "2"" of type '" "tString const &""'"); 
04876   }
04877   if (!argp2) {
04878     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::GetFiles" "', argument " "2"" of type '" "tString const &""'"); 
04879   }
04880   arg2 = reinterpret_cast< tString * >(argp2);
04881   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_tArrayTtString_t,  0 );
04882   if (!SWIG_IsOK(res3)) {
04883     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "tDirectories::GetFiles" "', argument " "3"" of type '" "tArray<tString > &""'"); 
04884   }
04885   if (!argp3) {
04886     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::GetFiles" "', argument " "3"" of type '" "tArray<tString > &""'"); 
04887   }
04888   arg3 = reinterpret_cast< tArray<tString > * >(argp3);
04889   ecode4 = SWIG_AsVal_int(argv[3], &val4);
04890   if (!SWIG_IsOK(ecode4)) {
04891     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "tDirectories::GetFiles" "', argument " "4"" of type '" "int""'");
04892   } 
04893   arg4 = static_cast< int >(val4);
04894   tDirectories::GetFiles((tString const &)*arg1,(tString const &)*arg2,*arg3,arg4);
04895   return Qnil;
04896 fail:
04897   return Qnil;
04898 }
04899 
04900 
04901 SWIGINTERN VALUE
04902 _wrap_TDirectories_get_files__SWIG_1(int argc, VALUE *argv, VALUE self) {
04903   tString *arg1 = 0 ;
04904   tString *arg2 = 0 ;
04905   tArray<tString > *arg3 = 0 ;
04906   void *argp1 ;
04907   int res1 = 0 ;
04908   void *argp2 ;
04909   int res2 = 0 ;
04910   void *argp3 = 0 ;
04911   int res3 = 0 ;
04912   
04913   if ((argc < 3) || (argc > 3)) {
04914     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
04915   }
04916   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tString,  0 );
04917   if (!SWIG_IsOK(res1)) {
04918     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::GetFiles" "', argument " "1"" of type '" "tString const &""'"); 
04919   }
04920   if (!argp1) {
04921     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::GetFiles" "', argument " "1"" of type '" "tString const &""'"); 
04922   }
04923   arg1 = reinterpret_cast< tString * >(argp1);
04924   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_tString,  0 );
04925   if (!SWIG_IsOK(res2)) {
04926     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tDirectories::GetFiles" "', argument " "2"" of type '" "tString const &""'"); 
04927   }
04928   if (!argp2) {
04929     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::GetFiles" "', argument " "2"" of type '" "tString const &""'"); 
04930   }
04931   arg2 = reinterpret_cast< tString * >(argp2);
04932   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_tArrayTtString_t,  0 );
04933   if (!SWIG_IsOK(res3)) {
04934     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "tDirectories::GetFiles" "', argument " "3"" of type '" "tArray<tString > &""'"); 
04935   }
04936   if (!argp3) {
04937     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::GetFiles" "', argument " "3"" of type '" "tArray<tString > &""'"); 
04938   }
04939   arg3 = reinterpret_cast< tArray<tString > * >(argp3);
04940   tDirectories::GetFiles((tString const &)*arg1,(tString const &)*arg2,*arg3);
04941   return Qnil;
04942 fail:
04943   return Qnil;
04944 }
04945 
04946 
04947 SWIGINTERN VALUE _wrap_TDirectories_get_files(int nargs, VALUE *args, VALUE self) {
04948   int argc;
04949   VALUE argv[4];
04950   int ii;
04951   
04952   argc = nargs;
04953   if (argc > 4) SWIG_fail;
04954   for (ii = 0; (ii < argc); ii++) {
04955     argv[ii] = args[ii];
04956   }
04957   if (argc == 3) {
04958     int _v;
04959     void *vptr = 0;
04960     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tString, 0);
04961     _v = SWIG_CheckState(res);
04962     if (_v) {
04963       void *vptr = 0;
04964       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_tString, 0);
04965       _v = SWIG_CheckState(res);
04966       if (_v) {
04967         void *vptr = 0;
04968         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_tArrayTtString_t, 0);
04969         _v = SWIG_CheckState(res);
04970         if (_v) {
04971           return _wrap_TDirectories_get_files__SWIG_1(nargs, args, self);
04972         }
04973       }
04974     }
04975   }
04976   if (argc == 4) {
04977     int _v;
04978     void *vptr = 0;
04979     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tString, 0);
04980     _v = SWIG_CheckState(res);
04981     if (_v) {
04982       void *vptr = 0;
04983       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_tString, 0);
04984       _v = SWIG_CheckState(res);
04985       if (_v) {
04986         void *vptr = 0;
04987         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_tArrayTtString_t, 0);
04988         _v = SWIG_CheckState(res);
04989         if (_v) {
04990           {
04991             int res = SWIG_AsVal_int(argv[3], NULL);
04992             _v = SWIG_CheckState(res);
04993           }
04994           if (_v) {
04995             return _wrap_TDirectories_get_files__SWIG_0(nargs, args, self);
04996           }
04997         }
04998       }
04999     }
05000   }
05001   
05002 fail:
05003   rb_raise(rb_eArgError, "No matching function for overloaded 'TDirectories_get_files'");
05004   return Qnil;
05005 }
05006 
05007 
05008 SWIGINTERN VALUE
05009 _wrap_TDirectories_file_matches_wildcard__SWIG_0(int argc, VALUE *argv, VALUE self) {
05010   char *arg1 = (char *) 0 ;
05011   char *arg2 = (char *) 0 ;
05012   bool arg3 ;
05013   bool result;
05014   int res1 ;
05015   char *buf1 = 0 ;
05016   int alloc1 = 0 ;
05017   int res2 ;
05018   char *buf2 = 0 ;
05019   int alloc2 = 0 ;
05020   bool val3 ;
05021   int ecode3 = 0 ;
05022   VALUE vresult = Qnil;
05023   
05024   if ((argc < 3) || (argc > 3)) {
05025     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
05026   }
05027   res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
05028   if (!SWIG_IsOK(res1)) {
05029     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::FileMatchesWildcard" "', argument " "1"" of type '" "char const *""'");
05030   }
05031   arg1 = reinterpret_cast< char * >(buf1);
05032   res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
05033   if (!SWIG_IsOK(res2)) {
05034     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tDirectories::FileMatchesWildcard" "', argument " "2"" of type '" "char const *""'");
05035   }
05036   arg2 = reinterpret_cast< char * >(buf2);
05037   ecode3 = SWIG_AsVal_bool(argv[2], &val3);
05038   if (!SWIG_IsOK(ecode3)) {
05039     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tDirectories::FileMatchesWildcard" "', argument " "3"" of type '" "bool""'");
05040   } 
05041   arg3 = static_cast< bool >(val3);
05042   result = (bool)tDirectories::FileMatchesWildcard((char const *)arg1,(char const *)arg2,arg3);
05043   vresult = SWIG_From_bool(static_cast< bool >(result));
05044   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
05045   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05046   return vresult;
05047 fail:
05048   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
05049   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05050   return Qnil;
05051 }
05052 
05053 
05054 SWIGINTERN VALUE
05055 _wrap_TDirectories_file_matches_wildcard__SWIG_1(int argc, VALUE *argv, VALUE self) {
05056   char *arg1 = (char *) 0 ;
05057   char *arg2 = (char *) 0 ;
05058   bool result;
05059   int res1 ;
05060   char *buf1 = 0 ;
05061   int alloc1 = 0 ;
05062   int res2 ;
05063   char *buf2 = 0 ;
05064   int alloc2 = 0 ;
05065   VALUE vresult = Qnil;
05066   
05067   if ((argc < 2) || (argc > 2)) {
05068     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
05069   }
05070   res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
05071   if (!SWIG_IsOK(res1)) {
05072     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::FileMatchesWildcard" "', argument " "1"" of type '" "char const *""'");
05073   }
05074   arg1 = reinterpret_cast< char * >(buf1);
05075   res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
05076   if (!SWIG_IsOK(res2)) {
05077     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tDirectories::FileMatchesWildcard" "', argument " "2"" of type '" "char const *""'");
05078   }
05079   arg2 = reinterpret_cast< char * >(buf2);
05080   result = (bool)tDirectories::FileMatchesWildcard((char const *)arg1,(char const *)arg2);
05081   vresult = SWIG_From_bool(static_cast< bool >(result));
05082   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
05083   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05084   return vresult;
05085 fail:
05086   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
05087   if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
05088   return Qnil;
05089 }
05090 
05091 
05092 SWIGINTERN VALUE _wrap_TDirectories_file_matches_wildcard(int nargs, VALUE *args, VALUE self) {
05093   int argc;
05094   VALUE argv[3];
05095   int ii;
05096   
05097   argc = nargs;
05098   if (argc > 3) SWIG_fail;
05099   for (ii = 0; (ii < argc); ii++) {
05100     argv[ii] = args[ii];
05101   }
05102   if (argc == 2) {
05103     int _v;
05104     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
05105     _v = SWIG_CheckState(res);
05106     if (_v) {
05107       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
05108       _v = SWIG_CheckState(res);
05109       if (_v) {
05110         return _wrap_TDirectories_file_matches_wildcard__SWIG_1(nargs, args, self);
05111       }
05112     }
05113   }
05114   if (argc == 3) {
05115     int _v;
05116     int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
05117     _v = SWIG_CheckState(res);
05118     if (_v) {
05119       int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
05120       _v = SWIG_CheckState(res);
05121       if (_v) {
05122         {
05123           int res = SWIG_AsVal_bool(argv[2], NULL);
05124           _v = SWIG_CheckState(res);
05125         }
05126         if (_v) {
05127           return _wrap_TDirectories_file_matches_wildcard__SWIG_0(nargs, args, self);
05128         }
05129       }
05130     }
05131   }
05132   
05133 fail:
05134   rb_raise(rb_eArgError, "No matching function for overloaded 'TDirectories_file_matches_wildcard'");
05135   return Qnil;
05136 }
05137 
05138 
05139 SWIGINTERN VALUE
05140 _wrap_TDirectories_file_name_to_menu_name(int argc, VALUE *argv, VALUE self) {
05141   char *arg1 = (char *) 0 ;
05142   tString *arg2 = 0 ;
05143   tString *result = 0 ;
05144   int res1 ;
05145   char *buf1 = 0 ;
05146   int alloc1 = 0 ;
05147   void *argp2 = 0 ;
05148   int res2 = 0 ;
05149   VALUE vresult = Qnil;
05150   
05151   if ((argc < 2) || (argc > 2)) {
05152     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
05153   }
05154   res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
05155   if (!SWIG_IsOK(res1)) {
05156     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::FileNameToMenuName" "', argument " "1"" of type '" "char const *""'");
05157   }
05158   arg1 = reinterpret_cast< char * >(buf1);
05159   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_tString,  0 );
05160   if (!SWIG_IsOK(res2)) {
05161     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tDirectories::FileNameToMenuName" "', argument " "2"" of type '" "tString &""'"); 
05162   }
05163   if (!argp2) {
05164     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::FileNameToMenuName" "', argument " "2"" of type '" "tString &""'"); 
05165   }
05166   arg2 = reinterpret_cast< tString * >(argp2);
05167   {
05168     tString &_result_ref = tDirectories::FileNameToMenuName((char const *)arg1,*arg2);
05169     result = (tString *) &_result_ref;
05170   }
05171   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_tString, 0 |  0 );
05172   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
05173   return vresult;
05174 fail:
05175   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
05176   return Qnil;
05177 }
05178 
05179 
05180 SWIGINTERN VALUE
05181 _wrap_TDirectories_get_spec_list(int argc, VALUE *argv, VALUE self) {
05182   tString *arg1 = 0 ;
05183   tArray<tString > *arg2 = 0 ;
05184   void *argp1 ;
05185   int res1 = 0 ;
05186   void *argp2 = 0 ;
05187   int res2 = 0 ;
05188   
05189   if ((argc < 2) || (argc > 2)) {
05190     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
05191   }
05192   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tString,  0 );
05193   if (!SWIG_IsOK(res1)) {
05194     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::GetSpecList" "', argument " "1"" of type '" "tString const &""'"); 
05195   }
05196   if (!argp1) {
05197     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::GetSpecList" "', argument " "1"" of type '" "tString const &""'"); 
05198   }
05199   arg1 = reinterpret_cast< tString * >(argp1);
05200   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_tArrayTtString_t,  0 );
05201   if (!SWIG_IsOK(res2)) {
05202     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tDirectories::GetSpecList" "', argument " "2"" of type '" "tArray<tString > &""'"); 
05203   }
05204   if (!argp2) {
05205     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::GetSpecList" "', argument " "2"" of type '" "tArray<tString > &""'"); 
05206   }
05207   arg2 = reinterpret_cast< tArray<tString > * >(argp2);
05208   tDirectories::GetSpecList((tString const &)*arg1,*arg2);
05209   return Qnil;
05210 fail:
05211   return Qnil;
05212 }
05213 
05214 
05215 SWIGINTERN VALUE
05216 _wrap_TDirectories_sort_files(int argc, VALUE *argv, VALUE self) {
05217   tArray<tString > *arg1 = 0 ;
05218   void *argp1 = 0 ;
05219   int res1 = 0 ;
05220   
05221   if ((argc < 1) || (argc > 1)) {
05222     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
05223   }
05224   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tArrayTtString_t,  0 );
05225   if (!SWIG_IsOK(res1)) {
05226     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tDirectories::SortFiles" "', argument " "1"" of type '" "tArray<tString > &""'"); 
05227   }
05228   if (!argp1) {
05229     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "tDirectories::SortFiles" "', argument " "1"" of type '" "tArray<tString > &""'"); 
05230   }
05231   arg1 = reinterpret_cast< tArray<tString > * >(argp1);
05232   tDirectories::SortFiles(*arg1);
05233   return Qnil;
05234 fail:
05235   return Qnil;
05236 }
05237 
05238 
05239 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
05240 SWIGINTERN VALUE
05241 _wrap_TDirectories_allocate(VALUE self) {
05242 #else
05243   SWIGINTERN VALUE
05244   _wrap_TDirectories_allocate(int argc, VALUE *argv, VALUE self) {
05245 #endif
05246     
05247     
05248     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_tDirectories);
05249 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
05250     rb_obj_call_init(vresult, argc, argv);
05251 #endif
05252     return vresult;
05253   }
05254   
05255 
05256 SWIGINTERN VALUE
05257 _wrap_new_TDirectories(int argc, VALUE *argv, VALUE self) {
05258   tDirectories *result = 0 ;
05259   const char *classname SWIGUNUSED = "Armagetronad::TDirectories";
05260   
05261   if ((argc < 0) || (argc > 0)) {
05262     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05263   }
05264   result = (tDirectories *)new tDirectories();DATA_PTR(self) = result;
05265   
05266   return self;
05267 fail:
05268   return Qnil;
05269 }
05270 
05271 
05272 SWIGINTERN void
05273 free_tDirectories(tDirectories *arg1) {
05274     delete arg1;
05275 }
05276 
05277 swig_class cTString;
05278 
05279 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
05280 SWIGINTERN VALUE
05281 _wrap_TString_allocate(VALUE self) {
05282 #else
05283   SWIGINTERN VALUE
05284   _wrap_TString_allocate(int argc, VALUE *argv, VALUE self) {
05285 #endif
05286     
05287     
05288     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_tString);
05289 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
05290     rb_obj_call_init(vresult, argc, argv);
05291 #endif
05292     return vresult;
05293   }
05294   
05295 
05296 SWIGINTERN VALUE
05297 _wrap_new_TString(int argc, VALUE *argv, VALUE self) {
05298   tString *result = 0 ;
05299   const char *classname SWIGUNUSED = "Armagetronad::TString";
05300   
05301   if ((argc < 0) || (argc > 0)) {
05302     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05303   }
05304   result = (tString *)new tString();DATA_PTR(self) = result;
05305   
05306   return self;
05307 fail:
05308   return Qnil;
05309 }
05310 
05311 
05312 SWIGINTERN void
05313 free_tString(tString *arg1) {
05314     delete arg1;
05315 }
05316 
05317 swig_class cTColoredString;
05318 
05319 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
05320 SWIGINTERN VALUE
05321 _wrap_TColoredString_allocate(VALUE self) {
05322 #else
05323   SWIGINTERN VALUE
05324   _wrap_TColoredString_allocate(int argc, VALUE *argv, VALUE self) {
05325 #endif
05326     
05327     
05328     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_tColoredString);
05329 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
05330     rb_obj_call_init(vresult, argc, argv);
05331 #endif
05332     return vresult;
05333   }
05334   
05335 
05336 SWIGINTERN VALUE
05337 _wrap_new_TColoredString(int argc, VALUE *argv, VALUE self) {
05338   tColoredString *result = 0 ;
05339   const char *classname SWIGUNUSED = "Armagetronad::TColoredString";
05340   
05341   if ((argc < 0) || (argc > 0)) {
05342     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05343   }
05344   result = (tColoredString *)new tColoredString();DATA_PTR(self) = result;
05345   
05346   return self;
05347 fail:
05348   return Qnil;
05349 }
05350 
05351 
05352 SWIGINTERN void
05353 free_tColoredString(tColoredString *arg1) {
05354     delete arg1;
05355 }
05356 
05357 swig_class cNNetObject;
05358 
05359 SWIGINTERN VALUE
05360 _wrap_NNetObject_do_debug_print(int argc, VALUE *argv, VALUE self) {
05361   bool result;
05362   VALUE vresult = Qnil;
05363   
05364   if ((argc < 0) || (argc > 0)) {
05365     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05366   }
05367   result = (bool)nNetObject::DoDebugPrint();
05368   vresult = SWIG_From_bool(static_cast< bool >(result));
05369   return vresult;
05370 fail:
05371   return Qnil;
05372 }
05373 
05374 
05375 SWIGINTERN VALUE
05376 _wrap_NNetObject_object_dangerous(int argc, VALUE *argv, VALUE self) {
05377   int arg1 ;
05378   nNetObject *result = 0 ;
05379   int val1 ;
05380   int ecode1 = 0 ;
05381   Swig::Director *director = 0;
05382   VALUE vresult = Qnil;
05383   
05384   if ((argc < 1) || (argc > 1)) {
05385     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
05386   }
05387   ecode1 = SWIG_AsVal_int(argv[0], &val1);
05388   if (!SWIG_IsOK(ecode1)) {
05389     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "nNetObject::ObjectDangerous" "', argument " "1"" of type '" "int""'");
05390   } 
05391   arg1 = static_cast< int >(val1);
05392   result = (nNetObject *)nNetObject::ObjectDangerous(arg1);
05393   director = dynamic_cast<Swig::Director *>(result);
05394   if (director) {
05395     vresult = director->swig_get_self();
05396   } else {
05397     vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_nNetObject, 0 |  0 );
05398   }
05399   return vresult;
05400 fail:
05401   return Qnil;
05402 }
05403 
05404 
05405 SWIGINTERN VALUE
05406 _wrap_NNetObject_add_ref(int argc, VALUE *argv, VALUE self) {
05407   nNetObject *arg1 = (nNetObject *) 0 ;
05408   void *argp1 = 0 ;
05409   int res1 = 0 ;
05410   Swig::Director *director = 0;
05411   bool upcall = false;
05412   
05413   if ((argc < 0) || (argc > 0)) {
05414     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05415   }
05416   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
05417   if (!SWIG_IsOK(res1)) {
05418     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddRef" "', argument " "1"" of type '" "nNetObject *""'"); 
05419   }
05420   arg1 = reinterpret_cast< nNetObject * >(argp1);
05421   director = dynamic_cast<Swig::Director *>(arg1);
05422   upcall = (director && (director->swig_get_self() == self));
05423   try {
05424     if (upcall) {
05425       (arg1)->nNetObject::AddRef();
05426     } else {
05427       (arg1)->AddRef();
05428     }
05429   } catch (Swig::DirectorException& e) {
05430     rb_exc_raise(e.getError());
05431     SWIG_fail;
05432   }
05433   return Qnil;
05434 fail:
05435   return Qnil;
05436 }
05437 
05438 
05439 SWIGINTERN VALUE
05440 _wrap_NNetObject_release(int argc, VALUE *argv, VALUE self) {
05441   nNetObject *arg1 = (nNetObject *) 0 ;
05442   void *argp1 = 0 ;
05443   int res1 = 0 ;
05444   Swig::Director *director = 0;
05445   bool upcall = false;
05446   
05447   if ((argc < 0) || (argc > 0)) {
05448     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05449   }
05450   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
05451   if (!SWIG_IsOK(res1)) {
05452     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Release" "', argument " "1"" of type '" "nNetObject *""'"); 
05453   }
05454   arg1 = reinterpret_cast< nNetObject * >(argp1);
05455   director = dynamic_cast<Swig::Director *>(arg1);
05456   upcall = (director && (director->swig_get_self() == self));
05457   try {
05458     if (upcall) {
05459       (arg1)->nNetObject::Release();
05460     } else {
05461       (arg1)->Release();
05462     }
05463   } catch (Swig::DirectorException& e) {
05464     rb_exc_raise(e.getError());
05465     SWIG_fail;
05466   }
05467   return Qnil;
05468 fail:
05469   return Qnil;
05470 }
05471 
05472 
05473 SWIGINTERN VALUE
05474 _wrap_NNetObject_get_refcount(int argc, VALUE *argv, VALUE self) {
05475   nNetObject *arg1 = (nNetObject *) 0 ;
05476   int result;
05477   void *argp1 = 0 ;
05478   int res1 = 0 ;
05479   VALUE vresult = Qnil;
05480   
05481   if ((argc < 0) || (argc > 0)) {
05482     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05483   }
05484   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
05485   if (!SWIG_IsOK(res1)) {
05486     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetRefcount" "', argument " "1"" of type '" "nNetObject const *""'"); 
05487   }
05488   arg1 = reinterpret_cast< nNetObject * >(argp1);
05489   result = (int)((nNetObject const *)arg1)->GetRefcount();
05490   vresult = SWIG_From_int(static_cast< int >(result));
05491   return vresult;
05492 fail:
05493   return Qnil;
05494 }
05495 
05496 
05497 SWIGINTERN VALUE
05498 _wrap_NNetObject_release_ownership(int argc, VALUE *argv, VALUE self) {
05499   nNetObject *arg1 = (nNetObject *) 0 ;
05500   void *argp1 = 0 ;
05501   int res1 = 0 ;
05502   Swig::Director *director = 0;
05503   bool upcall = false;
05504   
05505   if ((argc < 0) || (argc > 0)) {
05506     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05507   }
05508   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
05509   if (!SWIG_IsOK(res1)) {
05510     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReleaseOwnership" "', argument " "1"" of type '" "nNetObject *""'"); 
05511   }
05512   arg1 = reinterpret_cast< nNetObject * >(argp1);
05513   director = dynamic_cast<Swig::Director *>(arg1);
05514   upcall = (director && (director->swig_get_self() == self));
05515   try {
05516     if (upcall) {
05517       (arg1)->nNetObject::ReleaseOwnership();
05518     } else {
05519       (arg1)->ReleaseOwnership();
05520     }
05521   } catch (Swig::DirectorException& e) {
05522     rb_exc_raise(e.getError());
05523     SWIG_fail;
05524   }
05525   return Qnil;
05526 fail:
05527   return Qnil;
05528 }
05529 
05530 
05531 SWIGINTERN VALUE
05532 _wrap_NNetObject_take_ownership(int argc, VALUE *argv, VALUE self) {
05533   nNetObject *arg1 = (nNetObject *) 0 ;
05534   void *argp1 = 0 ;
05535   int res1 = 0 ;
05536   Swig::Director *director = 0;
05537   bool upcall = false;
05538   
05539   if ((argc < 0) || (argc > 0)) {
05540     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05541   }
05542   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
05543   if (!SWIG_IsOK(res1)) {
05544     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TakeOwnership" "', argument " "1"" of type '" "nNetObject *""'"); 
05545   }
05546   arg1 = reinterpret_cast< nNetObject * >(argp1);
05547   director = dynamic_cast<Swig::Director *>(arg1);
05548   upcall = (director && (director->swig_get_self() == self));
05549   try {
05550     if (upcall) {
05551       (arg1)->nNetObject::TakeOwnership();
05552     } else {
05553       (arg1)->TakeOwnership();
05554     }
05555   } catch (Swig::DirectorException& e) {
05556     rb_exc_raise(e.getError());
05557     SWIG_fail;
05558   }
05559   return Qnil;
05560 fail:
05561   return Qnil;
05562 }
05563 
05564 
05565 SWIGINTERN VALUE
05566 _wrap_NNetObject_owned(int argc, VALUE *argv, VALUE self) {
05567   nNetObject *arg1 = (nNetObject *) 0 ;
05568   bool result;
05569   void *argp1 = 0 ;
05570   int res1 = 0 ;
05571   VALUE vresult = Qnil;
05572   
05573   if ((argc < 0) || (argc > 0)) {
05574     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05575   }
05576   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
05577   if (!SWIG_IsOK(res1)) {
05578     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Owned" "', argument " "1"" of type '" "nNetObject *""'"); 
05579   }
05580   arg1 = reinterpret_cast< nNetObject * >(argp1);
05581   result = (bool)(arg1)->Owned();
05582   vresult = SWIG_From_bool(static_cast< bool >(result));
05583   return vresult;
05584 fail:
05585   return Qnil;
05586 }
05587 
05588 
05589 SWIGINTERN VALUE
05590 _wrap_NNetObject_get_observer(int argc, VALUE *argv, VALUE self) {
05591   nNetObject *arg1 = (nNetObject *) 0 ;
05592   nObserver *result = 0 ;
05593   void *argp1 = 0 ;
05594   int res1 = 0 ;
05595   VALUE vresult = Qnil;
05596   
05597   if ((argc < 0) || (argc > 0)) {
05598     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05599   }
05600   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
05601   if (!SWIG_IsOK(res1)) {
05602     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetObserver" "', argument " "1"" of type '" "nNetObject const *""'"); 
05603   }
05604   arg1 = reinterpret_cast< nNetObject * >(argp1);
05605   {
05606     nObserver &_result_ref = ((nNetObject const *)arg1)->GetObserver();
05607     result = (nObserver *) &_result_ref;
05608   }
05609   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_nObserver, 0 |  0 );
05610   return vresult;
05611 fail:
05612   return Qnil;
05613 }
05614 
05615 
05616 SWIGINTERN VALUE
05617 _wrap_NNetObject_dump(int argc, VALUE *argv, VALUE self) {
05618   nNetObject *arg1 = (nNetObject *) 0 ;
05619   tConsole *arg2 = 0 ;
05620   void *argp1 = 0 ;
05621   int res1 = 0 ;
05622   void *argp2 = 0 ;
05623   int res2 = 0 ;
05624   Swig::Director *director = 0;
05625   bool upcall = false;
05626   
05627   if ((argc < 1) || (argc > 1)) {
05628     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
05629   }
05630   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
05631   if (!SWIG_IsOK(res1)) {
05632     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Dump" "', argument " "1"" of type '" "nNetObject *""'"); 
05633   }
05634   arg1 = reinterpret_cast< nNetObject * >(argp1);
05635   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_tConsole,  0 );
05636   if (!SWIG_IsOK(res2)) {
05637     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Dump" "', argument " "2"" of type '" "tConsole &""'"); 
05638   }
05639   if (!argp2) {
05640     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Dump" "', argument " "2"" of type '" "tConsole &""'"); 
05641   }
05642   arg2 = reinterpret_cast< tConsole * >(argp2);
05643   director = dynamic_cast<Swig::Director *>(arg1);
05644   upcall = (director && (director->swig_get_self() == self));
05645   try {
05646     if (upcall) {
05647       (arg1)->nNetObject::Dump(*arg2);
05648     } else {
05649       (arg1)->Dump(*arg2);
05650     }
05651   } catch (Swig::DirectorException& e) {
05652     rb_exc_raise(e.getError());
05653     SWIG_fail;
05654   }
05655   return Qnil;
05656 fail:
05657   return Qnil;
05658 }
05659 
05660 
05661 SWIGINTERN VALUE
05662 _wrap_NNetObject_id(int argc, VALUE *argv, VALUE self) {
05663   nNetObject *arg1 = (nNetObject *) 0 ;
05664   unsigned short result;
05665   void *argp1 = 0 ;
05666   int res1 = 0 ;
05667   VALUE vresult = Qnil;
05668   
05669   if ((argc < 0) || (argc > 0)) {
05670     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05671   }
05672   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
05673   if (!SWIG_IsOK(res1)) {
05674     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ID" "', argument " "1"" of type '" "nNetObject const *""'"); 
05675   }
05676   arg1 = reinterpret_cast< nNetObject * >(argp1);
05677   result = (unsigned short)((nNetObject const *)arg1)->ID();
05678   vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
05679   return vresult;
05680 fail:
05681   return Qnil;
05682 }
05683 
05684 
05685 SWIGINTERN VALUE
05686 _wrap_NNetObject_owner(int argc, VALUE *argv, VALUE self) {
05687   nNetObject *arg1 = (nNetObject *) 0 ;
05688   unsigned short result;
05689   void *argp1 = 0 ;
05690   int res1 = 0 ;
05691   VALUE vresult = Qnil;
05692   
05693   if ((argc < 0) || (argc > 0)) {
05694     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05695   }
05696   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
05697   if (!SWIG_IsOK(res1)) {
05698     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Owner" "', argument " "1"" of type '" "nNetObject const *""'"); 
05699   }
05700   arg1 = reinterpret_cast< nNetObject * >(argp1);
05701   result = (unsigned short)((nNetObject const *)arg1)->Owner();
05702   vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
05703   return vresult;
05704 fail:
05705   return Qnil;
05706 }
05707 
05708 
05709 SWIGINTERN VALUE
05710 _wrap_NNetObject_get_machine(int argc, VALUE *argv, VALUE self) {
05711   nNetObject *arg1 = (nNetObject *) 0 ;
05712   nMachine *result = 0 ;
05713   void *argp1 = 0 ;
05714   int res1 = 0 ;
05715   VALUE vresult = Qnil;
05716   
05717   if ((argc < 0) || (argc > 0)) {
05718     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05719   }
05720   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
05721   if (!SWIG_IsOK(res1)) {
05722     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetMachine" "', argument " "1"" of type '" "nNetObject const *""'"); 
05723   }
05724   arg1 = reinterpret_cast< nNetObject * >(argp1);
05725   {
05726     nMachine &_result_ref = ((nNetObject const *)arg1)->GetMachine();
05727     result = (nMachine *) &_result_ref;
05728   }
05729   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_nMachine, 0 |  0 );
05730   return vresult;
05731 fail:
05732   return Qnil;
05733 }
05734 
05735 
05736 SWIGINTERN VALUE
05737 _wrap_NNetObject_creator_descriptor(int argc, VALUE *argv, VALUE self) {
05738   nNetObject *arg1 = (nNetObject *) 0 ;
05739   nDescriptor *result = 0 ;
05740   void *argp1 = 0 ;
05741   int res1 = 0 ;
05742   Swig::Director *director = 0;
05743   bool upcall = false;
05744   VALUE vresult = Qnil;
05745   
05746   if ((argc < 0) || (argc > 0)) {
05747     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05748   }
05749   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
05750   if (!SWIG_IsOK(res1)) {
05751     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreatorDescriptor" "', argument " "1"" of type '" "nNetObject const *""'"); 
05752   }
05753   arg1 = reinterpret_cast< nNetObject * >(argp1);
05754   director = dynamic_cast<Swig::Director *>(arg1);
05755   upcall = (director && (director->swig_get_self() == self));
05756   try {
05757     if (upcall) {
05758       Swig::DirectorPureVirtualException::raise("nNetObject::CreatorDescriptor");
05759     } else {
05760       {
05761         nDescriptor &_result_ref = ((nNetObject const *)arg1)->CreatorDescriptor();
05762         result = (nDescriptor *) &_result_ref;
05763       }
05764     }
05765   } catch (Swig::DirectorException& e) {
05766     rb_exc_raise(e.getError());
05767     SWIG_fail;
05768   }
05769   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_nDescriptor, 0 |  0 );
05770   if (director) {
05771     SWIG_AcquirePtr(vresult, director->swig_release_ownership(SWIG_as_voidptr(result)));
05772   }
05773   return vresult;
05774 fail:
05775   return Qnil;
05776 }
05777 
05778 
05779 SWIGINTERN VALUE
05780 _wrap_new_NNetObject__SWIG_0(int argc, VALUE *argv, VALUE self) {
05781   VALUE arg1 = (VALUE) 0 ;
05782   int arg2 ;
05783   nNetObject *result = 0 ;
05784   int val2 ;
05785   int ecode2 = 0 ;
05786   const char *classname SWIGUNUSED = "Armagetronad::NNetObject";
05787   
05788   if ((argc < 1) || (argc > 1)) {
05789     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
05790   }
05791   arg1 = self;
05792   ecode2 = SWIG_AsVal_int(argv[0], &val2);
05793   if (!SWIG_IsOK(ecode2)) {
05794     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nNetObject" "', argument " "2"" of type '" "int""'");
05795   } 
05796   arg2 = static_cast< int >(val2);
05797   if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
05798     /* subclassed */
05799     result = (nNetObject *)new SwigDirector_NNetObject(arg1,arg2); 
05800   } else {
05801     rb_raise(rb_eNameError,"accessing abstract class or protected constructor"); 
05802     return Qnil;
05803   }
05804   DATA_PTR(self) = result;
05805   
05806   return self;
05807 fail:
05808   return Qnil;
05809 }
05810 
05811 
05812 SWIGINTERN VALUE
05813 _wrap_new_NNetObject__SWIG_1(int argc, VALUE *argv, VALUE self) {
05814   VALUE arg1 = (VALUE) 0 ;
05815   nNetObject *result = 0 ;
05816   const char *classname SWIGUNUSED = "Armagetronad::NNetObject";
05817   
05818   if ((argc < 0) || (argc > 0)) {
05819     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05820   }
05821   arg1 = self;
05822   if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
05823     /* subclassed */
05824     result = (nNetObject *)new SwigDirector_NNetObject(arg1); 
05825   } else {
05826     rb_raise(rb_eNameError,"accessing abstract class or protected constructor"); 
05827     return Qnil;
05828   }
05829   DATA_PTR(self) = result;
05830   
05831   return self;
05832 fail:
05833   return Qnil;
05834 }
05835 
05836 
05837 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
05838 SWIGINTERN VALUE
05839 _wrap_NNetObject_allocate(VALUE self) {
05840 #else
05841   SWIGINTERN VALUE
05842   _wrap_NNetObject_allocate(int argc, VALUE *argv, VALUE self) {
05843 #endif
05844     
05845     
05846     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_nNetObject);
05847 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
05848     rb_obj_call_init(vresult, argc, argv);
05849 #endif
05850     return vresult;
05851   }
05852   
05853 
05854 SWIGINTERN VALUE
05855 _wrap_new_NNetObject__SWIG_2(int argc, VALUE *argv, VALUE self) {
05856   VALUE arg1 = (VALUE) 0 ;
05857   nMessage *arg2 = 0 ;
05858   nNetObject *result = 0 ;
05859   void *argp2 = 0 ;
05860   int res2 = 0 ;
05861   const char *classname SWIGUNUSED = "Armagetronad::NNetObject";
05862   
05863   if ((argc < 1) || (argc > 1)) {
05864     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
05865   }
05866   arg1 = self;
05867   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_nMessage,  0 );
05868   if (!SWIG_IsOK(res2)) {
05869     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nNetObject" "', argument " "2"" of type '" "nMessage &""'"); 
05870   }
05871   if (!argp2) {
05872     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "nNetObject" "', argument " "2"" of type '" "nMessage &""'"); 
05873   }
05874   arg2 = reinterpret_cast< nMessage * >(argp2);
05875   if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
05876     /* subclassed */
05877     result = (nNetObject *)new SwigDirector_NNetObject(arg1,*arg2); 
05878   } else {
05879     rb_raise(rb_eNameError,"accessing abstract class or protected constructor"); 
05880     return Qnil;
05881   }
05882   DATA_PTR(self) = result;
05883   
05884   return self;
05885 fail:
05886   return Qnil;
05887 }
05888 
05889 
05890 SWIGINTERN VALUE _wrap_new_NNetObject(int nargs, VALUE *args, VALUE self) {
05891   int argc;
05892   VALUE argv[3];
05893   int ii;
05894   
05895   argc = nargs + 1;
05896   argv[0] = self;
05897   if (argc > 3) SWIG_fail;
05898   for (ii = 1; (ii < argc); ii++) {
05899     argv[ii] = args[ii-1];
05900   }
05901   if (argc == 1) {
05902     int _v;
05903     _v = (argv[0] != 0);
05904     if (_v) {
05905       return _wrap_new_NNetObject__SWIG_1(nargs, args, self);
05906     }
05907   }
05908   if (argc == 2) {
05909     int _v;
05910     _v = (argv[0] != 0);
05911     if (_v) {
05912       void *vptr = 0;
05913       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_nMessage, 0);
05914       _v = SWIG_CheckState(res);
05915       if (_v) {
05916         return _wrap_new_NNetObject__SWIG_2(nargs, args, self);
05917       }
05918     }
05919   }
05920   if (argc == 2) {
05921     int _v;
05922     _v = (argv[0] != 0);
05923     if (_v) {
05924       {
05925         int res = SWIG_AsVal_int(argv[1], NULL);
05926         _v = SWIG_CheckState(res);
05927       }
05928       if (_v) {
05929         return _wrap_new_NNetObject__SWIG_0(nargs, args, self);
05930       }
05931     }
05932   }
05933   
05934 fail:
05935   rb_raise(rb_eArgError, "No matching function for overloaded 'new_NNetObject'");
05936   return Qnil;
05937 }
05938 
05939 
05940 SWIGINTERN VALUE
05941 _wrap_NNetObject_init_after_creation(int argc, VALUE *argv, VALUE self) {
05942   nNetObject *arg1 = (nNetObject *) 0 ;
05943   void *argp1 = 0 ;
05944   int res1 = 0 ;
05945   Swig::Director *director = 0;
05946   bool upcall = false;
05947   
05948   if ((argc < 0) || (argc > 0)) {
05949     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
05950   }
05951   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
05952   if (!SWIG_IsOK(res1)) {
05953     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitAfterCreation" "', argument " "1"" of type '" "nNetObject *""'"); 
05954   }
05955   arg1 = reinterpret_cast< nNetObject * >(argp1);
05956   director = dynamic_cast<Swig::Director *>(arg1);
05957   upcall = (director && (director->swig_get_self() == self));
05958   try {
05959     if (upcall) {
05960       (arg1)->nNetObject::InitAfterCreation();
05961     } else {
05962       (arg1)->InitAfterCreation();
05963     }
05964   } catch (Swig::DirectorException& e) {
05965     rb_exc_raise(e.getError());
05966     SWIG_fail;
05967   }
05968   return Qnil;
05969 fail:
05970   return Qnil;
05971 }
05972 
05973 
05974 SWIGINTERN VALUE
05975 _wrap_NNetObject_register(int argc, VALUE *argv, VALUE self) {
05976   nNetObject *arg1 = (nNetObject *) 0 ;
05977   nNetObjectRegistrar *arg2 = 0 ;
05978   void *argp1 = 0 ;
05979   int res1 = 0 ;
05980   void *argp2 ;
05981   int res2 = 0 ;
05982   
05983   if ((argc < 1) || (argc > 1)) {
05984     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
05985   }
05986   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
05987   if (!SWIG_IsOK(res1)) {
05988     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Register" "', argument " "1"" of type '" "nNetObject *""'"); 
05989   }
05990   arg1 = reinterpret_cast< nNetObject * >(argp1);
05991   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_nNetObjectRegistrar,  0 );
05992   if (!SWIG_IsOK(res2)) {
05993     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Register" "', argument " "2"" of type '" "nNetObjectRegistrar const &""'"); 
05994   }
05995   if (!argp2) {
05996     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Register" "', argument " "2"" of type '" "nNetObjectRegistrar const &""'"); 
05997   }
05998   arg2 = reinterpret_cast< nNetObjectRegistrar * >(argp2);
05999   (arg1)->Register((nNetObjectRegistrar const &)*arg2);
06000   return Qnil;
06001 fail:
06002   return Qnil;
06003 }
06004 
06005 
06006 SWIGINTERN VALUE
06007 _wrap_NNetObject_do_get_machine(int argc, VALUE *argv, VALUE self) {
06008   nNetObject *arg1 = (nNetObject *) 0 ;
06009   nMachine *result = 0 ;
06010   void *argp1 = 0 ;
06011   int res1 = 0 ;
06012   Swig::Director *director = 0;
06013   bool upcall = false;
06014   SwigDirector_NNetObject *darg = 0;
06015   VALUE vresult = Qnil;
06016   
06017   if ((argc < 0) || (argc > 0)) {
06018     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
06019   }
06020   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06021   if (!SWIG_IsOK(res1)) {
06022     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoGetMachine" "', argument " "1"" of type '" "nNetObject const *""'"); 
06023   }
06024   arg1 = reinterpret_cast< nNetObject * >(argp1);
06025   director = dynamic_cast<Swig::Director *>(arg1);
06026   upcall = (director && (director->swig_get_self() == self));
06027   try {
06028     darg = dynamic_cast<SwigDirector_NNetObject *>(arg1);
06029     if (upcall) {
06030       {
06031         nMachine &_result_ref = ((SwigDirector_NNetObject const *)darg)->DoGetMachineSwigPublic();
06032         result = (nMachine *) &_result_ref;
06033       }
06034     } else {
06035       {
06036         nMachine &_result_ref = ((SwigDirector_NNetObject const *)darg)->DoGetMachine();
06037         result = (nMachine *) &_result_ref;
06038       }
06039     }
06040   } catch (Swig::DirectorException& e) {
06041     rb_exc_raise(e.getError());
06042     SWIG_fail;
06043   }
06044   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_nMachine, 0 |  0 );
06045   if (director) {
06046     SWIG_AcquirePtr(vresult, director->swig_release_ownership(SWIG_as_voidptr(result)));
06047   }
06048   return vresult;
06049 fail:
06050   return Qnil;
06051 }
06052 
06053 
06054 SWIGINTERN VALUE
06055 _wrap_NNetObject_action_on_quit(int argc, VALUE *argv, VALUE self) {
06056   nNetObject *arg1 = (nNetObject *) 0 ;
06057   bool result;
06058   void *argp1 = 0 ;
06059   int res1 = 0 ;
06060   Swig::Director *director = 0;
06061   bool upcall = false;
06062   VALUE vresult = Qnil;
06063   
06064   if ((argc < 0) || (argc > 0)) {
06065     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
06066   }
06067   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06068   if (!SWIG_IsOK(res1)) {
06069     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionOnQuit" "', argument " "1"" of type '" "nNetObject *""'"); 
06070   }
06071   arg1 = reinterpret_cast< nNetObject * >(argp1);
06072   director = dynamic_cast<Swig::Director *>(arg1);
06073   upcall = (director && (director->swig_get_self() == self));
06074   try {
06075     if (upcall) {
06076       result = (bool)(arg1)->nNetObject::ActionOnQuit();
06077     } else {
06078       result = (bool)(arg1)->ActionOnQuit();
06079     }
06080   } catch (Swig::DirectorException& e) {
06081     rb_exc_raise(e.getError());
06082     SWIG_fail;
06083   }
06084   vresult = SWIG_From_bool(static_cast< bool >(result));
06085   return vresult;
06086 fail:
06087   return Qnil;
06088 }
06089 
06090 
06091 SWIGINTERN VALUE
06092 _wrap_NNetObject_action_on_delete(int argc, VALUE *argv, VALUE self) {
06093   nNetObject *arg1 = (nNetObject *) 0 ;
06094   void *argp1 = 0 ;
06095   int res1 = 0 ;
06096   Swig::Director *director = 0;
06097   bool upcall = false;
06098   
06099   if ((argc < 0) || (argc > 0)) {
06100     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
06101   }
06102   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06103   if (!SWIG_IsOK(res1)) {
06104     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionOnDelete" "', argument " "1"" of type '" "nNetObject *""'"); 
06105   }
06106   arg1 = reinterpret_cast< nNetObject * >(argp1);
06107   director = dynamic_cast<Swig::Director *>(arg1);
06108   upcall = (director && (director->swig_get_self() == self));
06109   try {
06110     if (upcall) {
06111       (arg1)->nNetObject::ActionOnDelete();
06112     } else {
06113       (arg1)->ActionOnDelete();
06114     }
06115   } catch (Swig::DirectorException& e) {
06116     rb_exc_raise(e.getError());
06117     SWIG_fail;
06118   }
06119   return Qnil;
06120 fail:
06121   return Qnil;
06122 }
06123 
06124 
06125 SWIGINTERN VALUE
06126 _wrap_NNetObject_broadcast_existence(int argc, VALUE *argv, VALUE self) {
06127   nNetObject *arg1 = (nNetObject *) 0 ;
06128   bool result;
06129   void *argp1 = 0 ;
06130   int res1 = 0 ;
06131   Swig::Director *director = 0;
06132   bool upcall = false;
06133   VALUE vresult = Qnil;
06134   
06135   if ((argc < 0) || (argc > 0)) {
06136     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
06137   }
06138   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06139   if (!SWIG_IsOK(res1)) {
06140     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BroadcastExistence" "', argument " "1"" of type '" "nNetObject *""'"); 
06141   }
06142   arg1 = reinterpret_cast< nNetObject * >(argp1);
06143   director = dynamic_cast<Swig::Director *>(arg1);
06144   upcall = (director && (director->swig_get_self() == self));
06145   try {
06146     if (upcall) {
06147       result = (bool)(arg1)->nNetObject::BroadcastExistence();
06148     } else {
06149       result = (bool)(arg1)->BroadcastExistence();
06150     }
06151   } catch (Swig::DirectorException& e) {
06152     rb_exc_raise(e.getError());
06153     SWIG_fail;
06154   }
06155   vresult = SWIG_From_bool(static_cast< bool >(result));
06156   return vresult;
06157 fail:
06158   return Qnil;
06159 }
06160 
06161 
06162 SWIGINTERN VALUE
06163 _wrap_NNetObject_print_name(int argc, VALUE *argv, VALUE self) {
06164   nNetObject *arg1 = (nNetObject *) 0 ;
06165   tString *arg2 = 0 ;
06166   void *argp1 = 0 ;
06167   int res1 = 0 ;
06168   void *argp2 = 0 ;
06169   int res2 = 0 ;
06170   Swig::Director *director = 0;
06171   bool upcall = false;
06172   
06173   if ((argc < 1) || (argc > 1)) {
06174     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
06175   }
06176   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06177   if (!SWIG_IsOK(res1)) {
06178     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrintName" "', argument " "1"" of type '" "nNetObject const *""'"); 
06179   }
06180   arg1 = reinterpret_cast< nNetObject * >(argp1);
06181   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_tString,  0 );
06182   if (!SWIG_IsOK(res2)) {
06183     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrintName" "', argument " "2"" of type '" "tString &""'"); 
06184   }
06185   if (!argp2) {
06186     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrintName" "', argument " "2"" of type '" "tString &""'"); 
06187   }
06188   arg2 = reinterpret_cast< tString * >(argp2);
06189   director = dynamic_cast<Swig::Director *>(arg1);
06190   upcall = (director && (director->swig_get_self() == self));
06191   try {
06192     if (upcall) {
06193       ((nNetObject const *)arg1)->nNetObject::PrintName(*arg2);
06194     } else {
06195       ((nNetObject const *)arg1)->PrintName(*arg2);
06196     }
06197   } catch (Swig::DirectorException& e) {
06198     rb_exc_raise(e.getError());
06199     SWIG_fail;
06200   }
06201   return Qnil;
06202 fail:
06203   return Qnil;
06204 }
06205 
06206 
06207 SWIGINTERN VALUE
06208 _wrap_NNetObject_has_been_transmitted(int argc, VALUE *argv, VALUE self) {
06209   nNetObject *arg1 = (nNetObject *) 0 ;
06210   int arg2 ;
06211   bool result;
06212   void *argp1 = 0 ;
06213   int res1 = 0 ;
06214   int val2 ;
06215   int ecode2 = 0 ;
06216   VALUE vresult = Qnil;
06217   
06218   if ((argc < 1) || (argc > 1)) {
06219     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
06220   }
06221   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06222   if (!SWIG_IsOK(res1)) {
06223     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HasBeenTransmitted" "', argument " "1"" of type '" "nNetObject const *""'"); 
06224   }
06225   arg1 = reinterpret_cast< nNetObject * >(argp1);
06226   ecode2 = SWIG_AsVal_int(argv[0], &val2);
06227   if (!SWIG_IsOK(ecode2)) {
06228     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HasBeenTransmitted" "', argument " "2"" of type '" "int""'");
06229   } 
06230   arg2 = static_cast< int >(val2);
06231   result = (bool)((nNetObject const *)arg1)->HasBeenTransmitted(arg2);
06232   vresult = SWIG_From_bool(static_cast< bool >(result));
06233   return vresult;
06234 fail:
06235   return Qnil;
06236 }
06237 
06238 
06239 SWIGINTERN VALUE
06240 _wrap_NNetObject_sync_requested(int argc, VALUE *argv, VALUE self) {
06241   nNetObject *arg1 = (nNetObject *) 0 ;
06242   int arg2 ;
06243   bool result;
06244   void *argp1 = 0 ;
06245   int res1 = 0 ;
06246   int val2 ;
06247   int ecode2 = 0 ;
06248   VALUE vresult = Qnil;
06249   
06250   if ((argc < 1) || (argc > 1)) {
06251     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
06252   }
06253   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06254   if (!SWIG_IsOK(res1)) {
06255     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "syncRequested" "', argument " "1"" of type '" "nNetObject const *""'"); 
06256   }
06257   arg1 = reinterpret_cast< nNetObject * >(argp1);
06258   ecode2 = SWIG_AsVal_int(argv[0], &val2);
06259   if (!SWIG_IsOK(ecode2)) {
06260     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "syncRequested" "', argument " "2"" of type '" "int""'");
06261   } 
06262   arg2 = static_cast< int >(val2);
06263   result = (bool)((nNetObject const *)arg1)->syncRequested(arg2);
06264   vresult = SWIG_From_bool(static_cast< bool >(result));
06265   return vresult;
06266 fail:
06267   return Qnil;
06268 }
06269 
06270 
06271 SWIGINTERN VALUE
06272 _wrap_NNetObject_clear_to_transmit(int argc, VALUE *argv, VALUE self) {
06273   nNetObject *arg1 = (nNetObject *) 0 ;
06274   int arg2 ;
06275   bool result;
06276   void *argp1 = 0 ;
06277   int res1 = 0 ;
06278   int val2 ;
06279   int ecode2 = 0 ;
06280   Swig::Director *director = 0;
06281   bool upcall = false;
06282   VALUE vresult = Qnil;
06283   
06284   if ((argc < 1) || (argc > 1)) {
06285     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
06286   }
06287   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06288   if (!SWIG_IsOK(res1)) {
06289     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClearToTransmit" "', argument " "1"" of type '" "nNetObject const *""'"); 
06290   }
06291   arg1 = reinterpret_cast< nNetObject * >(argp1);
06292   ecode2 = SWIG_AsVal_int(argv[0], &val2);
06293   if (!SWIG_IsOK(ecode2)) {
06294     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClearToTransmit" "', argument " "2"" of type '" "int""'");
06295   } 
06296   arg2 = static_cast< int >(val2);
06297   director = dynamic_cast<Swig::Director *>(arg1);
06298   upcall = (director && (director->swig_get_self() == self));
06299   try {
06300     if (upcall) {
06301       result = (bool)((nNetObject const *)arg1)->nNetObject::ClearToTransmit(arg2);
06302     } else {
06303       result = (bool)((nNetObject const *)arg1)->ClearToTransmit(arg2);
06304     }
06305   } catch (Swig::DirectorException& e) {
06306     rb_exc_raise(e.getError());
06307     SWIG_fail;
06308   }
06309   vresult = SWIG_From_bool(static_cast< bool >(result));
06310   return vresult;
06311 fail:
06312   return Qnil;
06313 }
06314 
06315 
06316 SWIGINTERN VALUE
06317 _wrap_NNetObject_write_sync(int argc, VALUE *argv, VALUE self) {
06318   nNetObject *arg1 = (nNetObject *) 0 ;
06319   nMessage *arg2 = 0 ;
06320   void *argp1 = 0 ;
06321   int res1 = 0 ;
06322   void *argp2 = 0 ;
06323   int res2 = 0 ;
06324   Swig::Director *director = 0;
06325   bool upcall = false;
06326   
06327   if ((argc < 1) || (argc > 1)) {
06328     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
06329   }
06330   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06331   if (!SWIG_IsOK(res1)) {
06332     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WriteSync" "', argument " "1"" of type '" "nNetObject *""'"); 
06333   }
06334   arg1 = reinterpret_cast< nNetObject * >(argp1);
06335   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_nMessage,  0 );
06336   if (!SWIG_IsOK(res2)) {
06337     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WriteSync" "', argument " "2"" of type '" "nMessage &""'"); 
06338   }
06339   if (!argp2) {
06340     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WriteSync" "', argument " "2"" of type '" "nMessage &""'"); 
06341   }
06342   arg2 = reinterpret_cast< nMessage * >(argp2);
06343   director = dynamic_cast<Swig::Director *>(arg1);
06344   upcall = (director && (director->swig_get_self() == self));
06345   try {
06346     if (upcall) {
06347       (arg1)->nNetObject::WriteSync(*arg2);
06348     } else {
06349       (arg1)->WriteSync(*arg2);
06350     }
06351   } catch (Swig::DirectorException& e) {
06352     rb_exc_raise(e.getError());
06353     SWIG_fail;
06354   }
06355   return Qnil;
06356 fail:
06357   return Qnil;
06358 }
06359 
06360 
06361 SWIGINTERN VALUE
06362 _wrap_NNetObject_read_sync(int argc, VALUE *argv, VALUE self) {
06363   nNetObject *arg1 = (nNetObject *) 0 ;
06364   nMessage *arg2 = 0 ;
06365   void *argp1 = 0 ;
06366   int res1 = 0 ;
06367   void *argp2 = 0 ;
06368   int res2 = 0 ;
06369   Swig::Director *director = 0;
06370   bool upcall = false;
06371   
06372   if ((argc < 1) || (argc > 1)) {
06373     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
06374   }
06375   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06376   if (!SWIG_IsOK(res1)) {
06377     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReadSync" "', argument " "1"" of type '" "nNetObject *""'"); 
06378   }
06379   arg1 = reinterpret_cast< nNetObject * >(argp1);
06380   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_nMessage,  0 );
06381   if (!SWIG_IsOK(res2)) {
06382     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReadSync" "', argument " "2"" of type '" "nMessage &""'"); 
06383   }
06384   if (!argp2) {
06385     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReadSync" "', argument " "2"" of type '" "nMessage &""'"); 
06386   }
06387   arg2 = reinterpret_cast< nMessage * >(argp2);
06388   director = dynamic_cast<Swig::Director *>(arg1);
06389   upcall = (director && (director->swig_get_self() == self));
06390   try {
06391     if (upcall) {
06392       (arg1)->nNetObject::ReadSync(*arg2);
06393     } else {
06394       (arg1)->ReadSync(*arg2);
06395     }
06396   } catch (Swig::DirectorException& e) {
06397     rb_exc_raise(e.getError());
06398     SWIG_fail;
06399   }
06400   return Qnil;
06401 fail:
06402   return Qnil;
06403 }
06404 
06405 
06406 SWIGINTERN VALUE
06407 _wrap_NNetObject_sync_is_new(int argc, VALUE *argv, VALUE self) {
06408   nNetObject *arg1 = (nNetObject *) 0 ;
06409   nMessage *arg2 = 0 ;
06410   bool result;
06411   void *argp1 = 0 ;
06412   int res1 = 0 ;
06413   void *argp2 = 0 ;
06414   int res2 = 0 ;
06415   Swig::Director *director = 0;
06416   bool upcall = false;
06417   VALUE vresult = Qnil;
06418   
06419   if ((argc < 1) || (argc > 1)) {
06420     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
06421   }
06422   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06423   if (!SWIG_IsOK(res1)) {
06424     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SyncIsNew" "', argument " "1"" of type '" "nNetObject *""'"); 
06425   }
06426   arg1 = reinterpret_cast< nNetObject * >(argp1);
06427   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_nMessage,  0 );
06428   if (!SWIG_IsOK(res2)) {
06429     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SyncIsNew" "', argument " "2"" of type '" "nMessage &""'"); 
06430   }
06431   if (!argp2) {
06432     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SyncIsNew" "', argument " "2"" of type '" "nMessage &""'"); 
06433   }
06434   arg2 = reinterpret_cast< nMessage * >(argp2);
06435   director = dynamic_cast<Swig::Director *>(arg1);
06436   upcall = (director && (director->swig_get_self() == self));
06437   try {
06438     if (upcall) {
06439       result = (bool)(arg1)->nNetObject::SyncIsNew(*arg2);
06440     } else {
06441       result = (bool)(arg1)->SyncIsNew(*arg2);
06442     }
06443   } catch (Swig::DirectorException& e) {
06444     rb_exc_raise(e.getError());
06445     SWIG_fail;
06446   }
06447   vresult = SWIG_From_bool(static_cast< bool >(result));
06448   return vresult;
06449 fail:
06450   return Qnil;
06451 }
06452 
06453 
06454 SWIGINTERN VALUE
06455 _wrap_NNetObject_write_create(int argc, VALUE *argv, VALUE self) {
06456   nNetObject *arg1 = (nNetObject *) 0 ;
06457   nMessage *arg2 = 0 ;
06458   void *argp1 = 0 ;
06459   int res1 = 0 ;
06460   void *argp2 = 0 ;
06461   int res2 = 0 ;
06462   Swig::Director *director = 0;
06463   bool upcall = false;
06464   
06465   if ((argc < 1) || (argc > 1)) {
06466     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
06467   }
06468   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06469   if (!SWIG_IsOK(res1)) {
06470     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WriteCreate" "', argument " "1"" of type '" "nNetObject *""'"); 
06471   }
06472   arg1 = reinterpret_cast< nNetObject * >(argp1);
06473   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_nMessage,  0 );
06474   if (!SWIG_IsOK(res2)) {
06475     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WriteCreate" "', argument " "2"" of type '" "nMessage &""'"); 
06476   }
06477   if (!argp2) {
06478     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WriteCreate" "', argument " "2"" of type '" "nMessage &""'"); 
06479   }
06480   arg2 = reinterpret_cast< nMessage * >(argp2);
06481   director = dynamic_cast<Swig::Director *>(arg1);
06482   upcall = (director && (director->swig_get_self() == self));
06483   try {
06484     if (upcall) {
06485       (arg1)->nNetObject::WriteCreate(*arg2);
06486     } else {
06487       (arg1)->WriteCreate(*arg2);
06488     }
06489   } catch (Swig::DirectorException& e) {
06490     rb_exc_raise(e.getError());
06491     SWIG_fail;
06492   }
06493   return Qnil;
06494 fail:
06495   return Qnil;
06496 }
06497 
06498 
06499 SWIGINTERN VALUE
06500 _wrap_NNetObject_receive_control_net(int argc, VALUE *argv, VALUE self) {
06501   nNetObject *arg1 = (nNetObject *) 0 ;
06502   nMessage *arg2 = 0 ;
06503   void *argp1 = 0 ;
06504   int res1 = 0 ;
06505   void *argp2 = 0 ;
06506   int res2 = 0 ;
06507   Swig::Director *director = 0;
06508   bool upcall = false;
06509   
06510   if ((argc < 1) || (argc > 1)) {
06511     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
06512   }
06513   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06514   if (!SWIG_IsOK(res1)) {
06515     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReceiveControlNet" "', argument " "1"" of type '" "nNetObject *""'"); 
06516   }
06517   arg1 = reinterpret_cast< nNetObject * >(argp1);
06518   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_nMessage,  0 );
06519   if (!SWIG_IsOK(res2)) {
06520     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReceiveControlNet" "', argument " "2"" of type '" "nMessage &""'"); 
06521   }
06522   if (!argp2) {
06523     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReceiveControlNet" "', argument " "2"" of type '" "nMessage &""'"); 
06524   }
06525   arg2 = reinterpret_cast< nMessage * >(argp2);
06526   director = dynamic_cast<Swig::Director *>(arg1);
06527   upcall = (director && (director->swig_get_self() == self));
06528   try {
06529     if (upcall) {
06530       (arg1)->nNetObject::ReceiveControlNet(*arg2);
06531     } else {
06532       (arg1)->ReceiveControlNet(*arg2);
06533     }
06534   } catch (Swig::DirectorException& e) {
06535     rb_exc_raise(e.getError());
06536     SWIG_fail;
06537   }
06538   return Qnil;
06539 fail:
06540   return Qnil;
06541 }
06542 
06543 
06544 SWIGINTERN VALUE
06545 _wrap_NNetObject_accept_client_sync(int argc, VALUE *argv, VALUE self) {
06546   nNetObject *arg1 = (nNetObject *) 0 ;
06547   bool result;
06548   void *argp1 = 0 ;
06549   int res1 = 0 ;
06550   Swig::Director *director = 0;
06551   bool upcall = false;
06552   VALUE vresult = Qnil;
06553   
06554   if ((argc < 0) || (argc > 0)) {
06555     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
06556   }
06557   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06558   if (!SWIG_IsOK(res1)) {
06559     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceptClientSync" "', argument " "1"" of type '" "nNetObject const *""'"); 
06560   }
06561   arg1 = reinterpret_cast< nNetObject * >(argp1);
06562   director = dynamic_cast<Swig::Director *>(arg1);
06563   upcall = (director && (director->swig_get_self() == self));
06564   try {
06565     if (upcall) {
06566       result = (bool)((nNetObject const *)arg1)->nNetObject::AcceptClientSync();
06567     } else {
06568       result = (bool)((nNetObject const *)arg1)->AcceptClientSync();
06569     }
06570   } catch (Swig::DirectorException& e) {
06571     rb_exc_raise(e.getError());
06572     SWIG_fail;
06573   }
06574   vresult = SWIG_From_bool(static_cast< bool >(result));
06575   return vresult;
06576 fail:
06577   return Qnil;
06578 }
06579 
06580 
06581 SWIGINTERN VALUE
06582 _wrap_NNetObject_get_id(int argc, VALUE *argv, VALUE self) {
06583   nNetObject *arg1 = (nNetObject *) 0 ;
06584   void *argp1 = 0 ;
06585   int res1 = 0 ;
06586   
06587   if ((argc < 0) || (argc > 0)) {
06588     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
06589   }
06590   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06591   if (!SWIG_IsOK(res1)) {
06592     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetID" "', argument " "1"" of type '" "nNetObject *""'"); 
06593   }
06594   arg1 = reinterpret_cast< nNetObject * >(argp1);
06595   (arg1)->GetID();
06596   return Qnil;
06597 fail:
06598   return Qnil;
06599 }
06600 
06601 
06602 SWIGINTERN VALUE
06603 _wrap_NNetObject_request_sync__SWIG_0(int argc, VALUE *argv, VALUE self) {
06604   nNetObject *arg1 = (nNetObject *) 0 ;
06605   bool arg2 ;
06606   void *argp1 = 0 ;
06607   int res1 = 0 ;
06608   bool val2 ;
06609   int ecode2 = 0 ;
06610   
06611   if ((argc < 1) || (argc > 1)) {
06612     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
06613   }
06614   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06615   if (!SWIG_IsOK(res1)) {
06616     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestSync" "', argument " "1"" of type '" "nNetObject *""'"); 
06617   }
06618   arg1 = reinterpret_cast< nNetObject * >(argp1);
06619   ecode2 = SWIG_AsVal_bool(argv[0], &val2);
06620   if (!SWIG_IsOK(ecode2)) {
06621     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RequestSync" "', argument " "2"" of type '" "bool""'");
06622   } 
06623   arg2 = static_cast< bool >(val2);
06624   (arg1)->RequestSync(arg2);
06625   return Qnil;
06626 fail:
06627   return Qnil;
06628 }
06629 
06630 
06631 SWIGINTERN VALUE
06632 _wrap_NNetObject_request_sync__SWIG_1(int argc, VALUE *argv, VALUE self) {
06633   nNetObject *arg1 = (nNetObject *) 0 ;
06634   void *argp1 = 0 ;
06635   int res1 = 0 ;
06636   
06637   if ((argc < 0) || (argc > 0)) {
06638     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
06639   }
06640   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06641   if (!SWIG_IsOK(res1)) {
06642     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestSync" "', argument " "1"" of type '" "nNetObject *""'"); 
06643   }
06644   arg1 = reinterpret_cast< nNetObject * >(argp1);
06645   (arg1)->RequestSync();
06646   return Qnil;
06647 fail:
06648   return Qnil;
06649 }
06650 
06651 
06652 SWIGINTERN VALUE
06653 _wrap_NNetObject_request_sync__SWIG_2(int argc, VALUE *argv, VALUE self) {
06654   nNetObject *arg1 = (nNetObject *) 0 ;
06655   int arg2 ;
06656   bool arg3 ;
06657   void *argp1 = 0 ;
06658   int res1 = 0 ;
06659   int val2 ;
06660   int ecode2 = 0 ;
06661   bool val3 ;
06662   int ecode3 = 0 ;
06663   
06664   if ((argc < 2) || (argc > 2)) {
06665     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
06666   }
06667   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06668   if (!SWIG_IsOK(res1)) {
06669     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestSync" "', argument " "1"" of type '" "nNetObject *""'"); 
06670   }
06671   arg1 = reinterpret_cast< nNetObject * >(argp1);
06672   ecode2 = SWIG_AsVal_int(argv[0], &val2);
06673   if (!SWIG_IsOK(ecode2)) {
06674     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RequestSync" "', argument " "2"" of type '" "int""'");
06675   } 
06676   arg2 = static_cast< int >(val2);
06677   ecode3 = SWIG_AsVal_bool(argv[1], &val3);
06678   if (!SWIG_IsOK(ecode3)) {
06679     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RequestSync" "', argument " "3"" of type '" "bool""'");
06680   } 
06681   arg3 = static_cast< bool >(val3);
06682   (arg1)->RequestSync(arg2,arg3);
06683   return Qnil;
06684 fail:
06685   return Qnil;
06686 }
06687 
06688 
06689 SWIGINTERN VALUE _wrap_NNetObject_request_sync(int nargs, VALUE *args, VALUE self) {
06690   int argc;
06691   VALUE argv[4];
06692   int ii;
06693   
06694   argc = nargs + 1;
06695   argv[0] = self;
06696   if (argc > 4) SWIG_fail;
06697   for (ii = 1; (ii < argc); ii++) {
06698     argv[ii] = args[ii-1];
06699   }
06700   if (argc == 1) {
06701     int _v;
06702     void *vptr = 0;
06703     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_nNetObject, 0);
06704     _v = SWIG_CheckState(res);
06705     if (_v) {
06706       return _wrap_NNetObject_request_sync__SWIG_1(nargs, args, self);
06707     }
06708   }
06709   if (argc == 2) {
06710     int _v;
06711     void *vptr = 0;
06712     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_nNetObject, 0);
06713     _v = SWIG_CheckState(res);
06714     if (_v) {
06715       {
06716         int res = SWIG_AsVal_bool(argv[1], NULL);
06717         _v = SWIG_CheckState(res);
06718       }
06719       if (_v) {
06720         return _wrap_NNetObject_request_sync__SWIG_0(nargs, args, self);
06721       }
06722     }
06723   }
06724   if (argc == 3) {
06725     int _v;
06726     void *vptr = 0;
06727     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_nNetObject, 0);
06728     _v = SWIG_CheckState(res);
06729     if (_v) {
06730       {
06731         int res = SWIG_AsVal_int(argv[1], NULL);
06732         _v = SWIG_CheckState(res);
06733       }
06734       if (_v) {
06735         {
06736           int res = SWIG_AsVal_bool(argv[2], NULL);
06737           _v = SWIG_CheckState(res);
06738         }
06739         if (_v) {
06740           return _wrap_NNetObject_request_sync__SWIG_2(nargs, args, self);
06741         }
06742       }
06743     }
06744   }
06745   
06746 fail:
06747   rb_raise(rb_eArgError, "No matching function for overloaded 'NNetObject_request_sync'");
06748   return Qnil;
06749 }
06750 
06751 
06752 SWIGINTERN VALUE
06753 _wrap_NNetObject_sync_all(int argc, VALUE *argv, VALUE self) {
06754   if ((argc < 0) || (argc > 0)) {
06755     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
06756   }
06757   nNetObject::SyncAll();
06758   return Qnil;
06759 fail:
06760   return Qnil;
06761 }
06762 
06763 
06764 SWIGINTERN VALUE
06765 _wrap_NNetObject_clear_all(int argc, VALUE *argv, VALUE self) {
06766   if ((argc < 0) || (argc > 0)) {
06767     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
06768   }
06769   nNetObject::ClearAll();
06770   return Qnil;
06771 fail:
06772   return Qnil;
06773 }
06774 
06775 
06776 SWIGINTERN VALUE
06777 _wrap_NNetObject_clear_all_deleted(int argc, VALUE *argv, VALUE self) {
06778   if ((argc < 0) || (argc > 0)) {
06779     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
06780   }
06781   nNetObject::ClearAllDeleted();
06782   return Qnil;
06783 fail:
06784   return Qnil;
06785 }
06786 
06787 
06788 SWIGINTERN VALUE
06789 _wrap_NNetObject_clear_knows(int argc, VALUE *argv, VALUE self) {
06790   int arg1 ;
06791   bool arg2 ;
06792   int val1 ;
06793   int ecode1 = 0 ;
06794   bool val2 ;
06795   int ecode2 = 0 ;
06796   
06797   if ((argc < 2) || (argc > 2)) {
06798     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
06799   }
06800   ecode1 = SWIG_AsVal_int(argv[0], &val1);
06801   if (!SWIG_IsOK(ecode1)) {
06802     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "nNetObject::ClearKnows" "', argument " "1"" of type '" "int""'");
06803   } 
06804   arg1 = static_cast< int >(val1);
06805   ecode2 = SWIG_AsVal_bool(argv[1], &val2);
06806   if (!SWIG_IsOK(ecode2)) {
06807     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nNetObject::ClearKnows" "', argument " "2"" of type '" "bool""'");
06808   } 
06809   arg2 = static_cast< bool >(val2);
06810   nNetObject::ClearKnows(arg1,arg2);
06811   return Qnil;
06812 fail:
06813   return Qnil;
06814 }
06815 
06816 
06817 SWIGINTERN VALUE
06818 _wrap_NNetObject_relabel_on_connect(int argc, VALUE *argv, VALUE self) {
06819   if ((argc < 0) || (argc > 0)) {
06820     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
06821   }
06822   nNetObject::RelabelOnConnect();
06823   return Qnil;
06824 fail:
06825   return Qnil;
06826 }
06827 
06828 
06829 SWIGINTERN VALUE
06830 _wrap_disown_NNetObject(int argc, VALUE *argv, VALUE self) {
06831   nNetObject *arg1 = (nNetObject *) 0 ;
06832   void *argp1 = 0 ;
06833   int res1 = 0 ;
06834   
06835   if ((argc < 1) || (argc > 1)) {
06836     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
06837   }
06838   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_nNetObject, 0 |  0 );
06839   if (!SWIG_IsOK(res1)) {
06840     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_NNetObject" "', argument " "1"" of type '" "nNetObject *""'"); 
06841   }
06842   arg1 = reinterpret_cast< nNetObject * >(argp1);
06843   {
06844     Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
06845     if (director) director->swig_disown();
06846   }
06847   
06848   return Qnil;
06849 fail:
06850   return Qnil;
06851 }
06852 
06853 
06854 swig_class cUMenu;
06855 
06856 SWIGINTERN VALUE
06857 UMenu_wrap_get(VALUE self) {
06858   VALUE _val;
06859   
06860   _val = SWIG_From_bool(static_cast< bool >(uMenu::wrap));
06861   return _val;
06862 }
06863 
06864 
06865 SWIGINTERN VALUE
06866 UMenu_wrap_set(VALUE self, VALUE _val) {
06867   {
06868     bool val;
06869     int res = SWIG_AsVal_bool(_val, &val);
06870     if (!SWIG_IsOK(res)) {
06871       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""uMenu::wrap""' of type '""bool""'");
06872     }
06873     uMenu::wrap = static_cast< bool >(val);
06874   }
06875   return _val;
06876 fail:
06877   return Qnil;
06878 }
06879 
06880 
06881 SWIGINTERN VALUE
06882 UMenu_quickexit_get(VALUE self) {
06883   VALUE _val;
06884   
06885   _val = SWIG_From_bool(static_cast< bool >(uMenu::quickexit));
06886   return _val;
06887 }
06888 
06889 
06890 SWIGINTERN VALUE
06891 UMenu_quickexit_set(VALUE self, VALUE _val) {
06892   {
06893     bool val;
06894     int res = SWIG_AsVal_bool(_val, &val);
06895     if (!SWIG_IsOK(res)) {
06896       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""uMenu::quickexit""' of type '""bool""'");
06897     }
06898     uMenu::quickexit = static_cast< bool >(val);
06899   }
06900   return _val;
06901 fail:
06902   return Qnil;
06903 }
06904 
06905 
06906 SWIGINTERN VALUE
06907 UMenu_exitToMain_get(VALUE self) {
06908   VALUE _val;
06909   
06910   _val = SWIG_From_bool(static_cast< bool >(uMenu::exitToMain));
06911   return _val;
06912 }
06913 
06914 
06915 SWIGINTERN VALUE
06916 UMenu_exitToMain_set(VALUE self, VALUE _val) {
06917   {
06918     bool val;
06919     int res = SWIG_AsVal_bool(_val, &val);
06920     if (!SWIG_IsOK(res)) {
06921       SWIG_exception_fail(SWIG_ArgError(res), "in variable '""uMenu::exitToMain""' of type '""bool""'");
06922     }
06923     uMenu::exitToMain = static_cast< bool >(val);
06924   }
06925   return _val;
06926 fail:
06927   return Qnil;
06928 }
06929 
06930 
06931 SWIGINTERN VALUE
06932 _wrap_UMenu_title_set(int argc, VALUE *argv, VALUE self) {
06933   uMenu *arg1 = (uMenu *) 0 ;
06934   tOutput *arg2 = (tOutput *) 0 ;
06935   void *argp1 = 0 ;
06936   int res1 = 0 ;
06937   void *argp2 = 0 ;
06938   int res2 = 0 ;
06939   
06940   if ((argc < 1) || (argc > 1)) {
06941     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
06942   }
06943   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
06944   if (!SWIG_IsOK(res1)) {
06945     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "title" "', argument " "1"" of type '" "uMenu *""'"); 
06946   }
06947   arg1 = reinterpret_cast< uMenu * >(argp1);
06948   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_tOutput, 0 |  0 );
06949   if (!SWIG_IsOK(res2)) {
06950     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "title" "', argument " "2"" of type '" "tOutput *""'"); 
06951   }
06952   arg2 = reinterpret_cast< tOutput * >(argp2);
06953   if (arg1) (arg1)->title = *arg2;
06954   
06955   return Qnil;
06956 fail:
06957   return Qnil;
06958 }
06959 
06960 
06961 SWIGINTERN VALUE
06962 _wrap_UMenu_title_get(int argc, VALUE *argv, VALUE self) {
06963   uMenu *arg1 = (uMenu *) 0 ;
06964   tOutput *result = 0 ;
06965   void *argp1 = 0 ;
06966   int res1 = 0 ;
06967   VALUE vresult = Qnil;
06968   
06969   if ((argc < 0) || (argc > 0)) {
06970     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
06971   }
06972   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
06973   if (!SWIG_IsOK(res1)) {
06974     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "title" "', argument " "1"" of type '" "uMenu *""'"); 
06975   }
06976   arg1 = reinterpret_cast< uMenu * >(argp1);
06977   result = (tOutput *)& ((arg1)->title);
06978   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_tOutput, 0 |  0 );
06979   return vresult;
06980 fail:
06981   return Qnil;
06982 }
06983 
06984 
06985 SWIGINTERN VALUE
06986 _wrap_UMenu_idle_func(int argc, VALUE *argv, VALUE self) {
06987   uMenu *arg1 = (uMenu *) 0 ;
06988   FUNCPTR result;
06989   void *argp1 = 0 ;
06990   int res1 = 0 ;
06991   VALUE vresult = Qnil;
06992   
06993   if ((argc < 0) || (argc > 0)) {
06994     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
06995   }
06996   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
06997   if (!SWIG_IsOK(res1)) {
06998     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleFunc" "', argument " "1"" of type '" "uMenu *""'"); 
06999   }
07000   arg1 = reinterpret_cast< uMenu * >(argp1);
07001   result = (arg1)->IdleFunc();
07002   vresult = SWIG_NewPointerObj((new FUNCPTR(static_cast< const FUNCPTR& >(result))), SWIGTYPE_p_FUNCPTR, SWIG_POINTER_OWN |  0 );
07003   return vresult;
07004 fail:
07005   return Qnil;
07006 }
07007 
07008 
07009 SWIGINTERN VALUE
07010 _wrap_UMenu_set_idle(int argc, VALUE *argv, VALUE self) {
07011   FUNCPTR arg1 ;
07012   void *argp1 ;
07013   int res1 = 0 ;
07014   
07015   if ((argc < 1) || (argc > 1)) {
07016     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
07017   }
07018   {
07019     res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_FUNCPTR,  0 );
07020     if (!SWIG_IsOK(res1)) {
07021       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uMenu::SetIdle" "', argument " "1"" of type '" "FUNCPTR""'"); 
07022     }  
07023     if (!argp1) {
07024       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenu::SetIdle" "', argument " "1"" of type '" "FUNCPTR""'");
07025     } else {
07026       arg1 = *(reinterpret_cast< FUNCPTR * >(argp1));
07027     }
07028   }
07029   uMenu::SetIdle(arg1);
07030   return Qnil;
07031 fail:
07032   return Qnil;
07033 }
07034 
07035 
07036 SWIGINTERN VALUE
07037 _wrap_UMenu_set_center(int argc, VALUE *argv, VALUE self) {
07038   uMenu *arg1 = (uMenu *) 0 ;
07039   REAL arg2 ;
07040   void *argp1 = 0 ;
07041   int res1 = 0 ;
07042   float val2 ;
07043   int ecode2 = 0 ;
07044   
07045   if ((argc < 1) || (argc > 1)) {
07046     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
07047   }
07048   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
07049   if (!SWIG_IsOK(res1)) {
07050     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCenter" "', argument " "1"" of type '" "uMenu *""'"); 
07051   }
07052   arg1 = reinterpret_cast< uMenu * >(argp1);
07053   ecode2 = SWIG_AsVal_float(argv[0], &val2);
07054   if (!SWIG_IsOK(ecode2)) {
07055     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetCenter" "', argument " "2"" of type '" "REAL""'");
07056   } 
07057   arg2 = static_cast< REAL >(val2);
07058   (arg1)->SetCenter(arg2);
07059   return Qnil;
07060 fail:
07061   return Qnil;
07062 }
07063 
07064 
07065 SWIGINTERN VALUE
07066 _wrap_UMenu_set_top(int argc, VALUE *argv, VALUE self) {
07067   uMenu *arg1 = (uMenu *) 0 ;
07068   REAL arg2 ;
07069   void *argp1 = 0 ;
07070   int res1 = 0 ;
07071   float val2 ;
07072   int ecode2 = 0 ;
07073   
07074   if ((argc < 1) || (argc > 1)) {
07075     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
07076   }
07077   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
07078   if (!SWIG_IsOK(res1)) {
07079     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetTop" "', argument " "1"" of type '" "uMenu *""'"); 
07080   }
07081   arg1 = reinterpret_cast< uMenu * >(argp1);
07082   ecode2 = SWIG_AsVal_float(argv[0], &val2);
07083   if (!SWIG_IsOK(ecode2)) {
07084     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetTop" "', argument " "2"" of type '" "REAL""'");
07085   } 
07086   arg2 = static_cast< REAL >(val2);
07087   (arg1)->SetTop(arg2);
07088   return Qnil;
07089 fail:
07090   return Qnil;
07091 }
07092 
07093 
07094 SWIGINTERN VALUE
07095 _wrap_UMenu_set_bot(int argc, VALUE *argv, VALUE self) {
07096   uMenu *arg1 = (uMenu *) 0 ;
07097   REAL arg2 ;
07098   void *argp1 = 0 ;
07099   int res1 = 0 ;
07100   float val2 ;
07101   int ecode2 = 0 ;
07102   
07103   if ((argc < 1) || (argc > 1)) {
07104     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
07105   }
07106   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
07107   if (!SWIG_IsOK(res1)) {
07108     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetBot" "', argument " "1"" of type '" "uMenu *""'"); 
07109   }
07110   arg1 = reinterpret_cast< uMenu * >(argp1);
07111   ecode2 = SWIG_AsVal_float(argv[0], &val2);
07112   if (!SWIG_IsOK(ecode2)) {
07113     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetBot" "', argument " "2"" of type '" "REAL""'");
07114   } 
07115   arg2 = static_cast< REAL >(val2);
07116   (arg1)->SetBot(arg2);
07117   return Qnil;
07118 fail:
07119   return Qnil;
07120 }
07121 
07122 
07123 SWIGINTERN VALUE
07124 _wrap_UMenu_set_selected(int argc, VALUE *argv, VALUE self) {
07125   uMenu *arg1 = (uMenu *) 0 ;
07126   int arg2 ;
07127   void *argp1 = 0 ;
07128   int res1 = 0 ;
07129   int val2 ;
07130   int ecode2 = 0 ;
07131   
07132   if ((argc < 1) || (argc > 1)) {
07133     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
07134   }
07135   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
07136   if (!SWIG_IsOK(res1)) {
07137     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetSelected" "', argument " "1"" of type '" "uMenu *""'"); 
07138   }
07139   arg1 = reinterpret_cast< uMenu * >(argp1);
07140   ecode2 = SWIG_AsVal_int(argv[0], &val2);
07141   if (!SWIG_IsOK(ecode2)) {
07142     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetSelected" "', argument " "2"" of type '" "int""'");
07143   } 
07144   arg2 = static_cast< int >(val2);
07145   (arg1)->SetSelected(arg2);
07146   return Qnil;
07147 fail:
07148   return Qnil;
07149 }
07150 
07151 
07152 SWIGINTERN VALUE
07153 _wrap_UMenu_num_items(int argc, VALUE *argv, VALUE self) {
07154   uMenu *arg1 = (uMenu *) 0 ;
07155   int result;
07156   void *argp1 = 0 ;
07157   int res1 = 0 ;
07158   VALUE vresult = Qnil;
07159   
07160   if ((argc < 0) || (argc > 0)) {
07161     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
07162   }
07163   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
07164   if (!SWIG_IsOK(res1)) {
07165     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NumItems" "', argument " "1"" of type '" "uMenu *""'"); 
07166   }
07167   arg1 = reinterpret_cast< uMenu * >(argp1);
07168   result = (int)(arg1)->NumItems();
07169   vresult = SWIG_From_int(static_cast< int >(result));
07170   return vresult;
07171 fail:
07172   return Qnil;
07173 }
07174 
07175 
07176 SWIGINTERN VALUE
07177 _wrap_UMenu_item(int argc, VALUE *argv, VALUE self) {
07178   uMenu *arg1 = (uMenu *) 0 ;
07179   int arg2 ;
07180   uMenuItem *result = 0 ;
07181   void *argp1 = 0 ;
07182   int res1 = 0 ;
07183   int val2 ;
07184   int ecode2 = 0 ;
07185   VALUE vresult = Qnil;
07186   
07187   if ((argc < 1) || (argc > 1)) {
07188     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
07189   }
07190   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
07191   if (!SWIG_IsOK(res1)) {
07192     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Item" "', argument " "1"" of type '" "uMenu *""'"); 
07193   }
07194   arg1 = reinterpret_cast< uMenu * >(argp1);
07195   ecode2 = SWIG_AsVal_int(argv[0], &val2);
07196   if (!SWIG_IsOK(ecode2)) {
07197     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Item" "', argument " "2"" of type '" "int""'");
07198   } 
07199   arg2 = static_cast< int >(val2);
07200   result = (uMenuItem *)(arg1)->Item(arg2);
07201   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uMenuItem, 0 |  0 );
07202   return vresult;
07203 fail:
07204   return Qnil;
07205 }
07206 
07207 
07208 SWIGINTERN VALUE
07209 _wrap_UMenu_add_item(int argc, VALUE *argv, VALUE self) {
07210   uMenu *arg1 = (uMenu *) 0 ;
07211   uMenuItem *arg2 = (uMenuItem *) 0 ;
07212   void *argp1 = 0 ;
07213   int res1 = 0 ;
07214   void *argp2 = 0 ;
07215   int res2 = 0 ;
07216   
07217   if ((argc < 1) || (argc > 1)) {
07218     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
07219   }
07220   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
07221   if (!SWIG_IsOK(res1)) {
07222     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddItem" "', argument " "1"" of type '" "uMenu *""'"); 
07223   }
07224   arg1 = reinterpret_cast< uMenu * >(argp1);
07225   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_uMenuItem, 0 |  0 );
07226   if (!SWIG_IsOK(res2)) {
07227     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddItem" "', argument " "2"" of type '" "uMenuItem *""'"); 
07228   }
07229   arg2 = reinterpret_cast< uMenuItem * >(argp2);
07230   (arg1)->AddItem(arg2);
07231   return Qnil;
07232 fail:
07233   return Qnil;
07234 }
07235 
07236 
07237 SWIGINTERN VALUE
07238 _wrap_UMenu_remove_item(int argc, VALUE *argv, VALUE self) {
07239   uMenu *arg1 = (uMenu *) 0 ;
07240   uMenuItem *arg2 = (uMenuItem *) 0 ;
07241   void *argp1 = 0 ;
07242   int res1 = 0 ;
07243   void *argp2 = 0 ;
07244   int res2 = 0 ;
07245   
07246   if ((argc < 1) || (argc > 1)) {
07247     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
07248   }
07249   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
07250   if (!SWIG_IsOK(res1)) {
07251     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoveItem" "', argument " "1"" of type '" "uMenu *""'"); 
07252   }
07253   arg1 = reinterpret_cast< uMenu * >(argp1);
07254   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_uMenuItem, 0 |  0 );
07255   if (!SWIG_IsOK(res2)) {
07256     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RemoveItem" "', argument " "2"" of type '" "uMenuItem *""'"); 
07257   }
07258   arg2 = reinterpret_cast< uMenuItem * >(argp2);
07259   (arg1)->RemoveItem(arg2);
07260   return Qnil;
07261 fail:
07262   return Qnil;
07263 }
07264 
07265 
07266 SWIGINTERN VALUE
07267 _wrap_new_UMenu__SWIG_0(int argc, VALUE *argv, VALUE self) {
07268   tOutput *arg1 = 0 ;
07269   bool arg2 ;
07270   uMenu *result = 0 ;
07271   void *argp1 ;
07272   int res1 = 0 ;
07273   bool val2 ;
07274   int ecode2 = 0 ;
07275   const char *classname SWIGUNUSED = "Armagetronad::UMenu";
07276   
07277   if ((argc < 2) || (argc > 2)) {
07278     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
07279   }
07280   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tOutput,  0 );
07281   if (!SWIG_IsOK(res1)) {
07282     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uMenu" "', argument " "1"" of type '" "tOutput const &""'"); 
07283   }
07284   if (!argp1) {
07285     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenu" "', argument " "1"" of type '" "tOutput const &""'"); 
07286   }
07287   arg1 = reinterpret_cast< tOutput * >(argp1);
07288   ecode2 = SWIG_AsVal_bool(argv[1], &val2);
07289   if (!SWIG_IsOK(ecode2)) {
07290     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "uMenu" "', argument " "2"" of type '" "bool""'");
07291   } 
07292   arg2 = static_cast< bool >(val2);
07293   result = (uMenu *)new uMenu((tOutput const &)*arg1,arg2);DATA_PTR(self) = result;
07294   
07295   return self;
07296 fail:
07297   return Qnil;
07298 }
07299 
07300 
07301 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
07302 SWIGINTERN VALUE
07303 _wrap_UMenu_allocate(VALUE self) {
07304 #else
07305   SWIGINTERN VALUE
07306   _wrap_UMenu_allocate(int argc, VALUE *argv, VALUE self) {
07307 #endif
07308     
07309     
07310     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_uMenu);
07311 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
07312     rb_obj_call_init(vresult, argc, argv);
07313 #endif
07314     return vresult;
07315   }
07316   
07317 
07318 SWIGINTERN VALUE
07319 _wrap_new_UMenu__SWIG_1(int argc, VALUE *argv, VALUE self) {
07320   tOutput *arg1 = 0 ;
07321   uMenu *result = 0 ;
07322   void *argp1 ;
07323   int res1 = 0 ;
07324   const char *classname SWIGUNUSED = "Armagetronad::UMenu";
07325   
07326   if ((argc < 1) || (argc > 1)) {
07327     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
07328   }
07329   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tOutput,  0 );
07330   if (!SWIG_IsOK(res1)) {
07331     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uMenu" "', argument " "1"" of type '" "tOutput const &""'"); 
07332   }
07333   if (!argp1) {
07334     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenu" "', argument " "1"" of type '" "tOutput const &""'"); 
07335   }
07336   arg1 = reinterpret_cast< tOutput * >(argp1);
07337   result = (uMenu *)new uMenu((tOutput const &)*arg1);DATA_PTR(self) = result;
07338   
07339   return self;
07340 fail:
07341   return Qnil;
07342 }
07343 
07344 
07345 SWIGINTERN VALUE _wrap_new_UMenu(int nargs, VALUE *args, VALUE self) {
07346   int argc;
07347   VALUE argv[2];
07348   int ii;
07349   
07350   argc = nargs;
07351   if (argc > 2) SWIG_fail;
07352   for (ii = 0; (ii < argc); ii++) {
07353     argv[ii] = args[ii];
07354   }
07355   if (argc == 1) {
07356     int _v;
07357     void *vptr = 0;
07358     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tOutput, 0);
07359     _v = SWIG_CheckState(res);
07360     if (_v) {
07361       return _wrap_new_UMenu__SWIG_1(nargs, args, self);
07362     }
07363   }
07364   if (argc == 2) {
07365     int _v;
07366     void *vptr = 0;
07367     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tOutput, 0);
07368     _v = SWIG_CheckState(res);
07369     if (_v) {
07370       {
07371         int res = SWIG_AsVal_bool(argv[1], NULL);
07372         _v = SWIG_CheckState(res);
07373       }
07374       if (_v) {
07375         return _wrap_new_UMenu__SWIG_0(nargs, args, self);
07376       }
07377     }
07378   }
07379   
07380 fail:
07381   rb_raise(rb_eArgError, "No matching function for overloaded 'new_UMenu'");
07382   return Qnil;
07383 }
07384 
07385 
07386 SWIGINTERN void
07387 free_uMenu(uMenu *arg1) {
07388     delete arg1;
07389 }
07390 
07391 SWIGINTERN VALUE
07392 _wrap_UMenu_enter(int argc, VALUE *argv, VALUE self) {
07393   uMenu *arg1 = (uMenu *) 0 ;
07394   void *argp1 = 0 ;
07395   int res1 = 0 ;
07396   
07397   if ((argc < 0) || (argc > 0)) {
07398     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
07399   }
07400   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
07401   if (!SWIG_IsOK(res1)) {
07402     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enter" "', argument " "1"" of type '" "uMenu *""'"); 
07403   }
07404   arg1 = reinterpret_cast< uMenu * >(argp1);
07405   (arg1)->Enter();
07406   return Qnil;
07407 fail:
07408   return Qnil;
07409 }
07410 
07411 
07412 SWIGINTERN VALUE
07413 _wrap_UMenu_reverse_items(int argc, VALUE *argv, VALUE self) {
07414   uMenu *arg1 = (uMenu *) 0 ;
07415   void *argp1 = 0 ;
07416   int res1 = 0 ;
07417   
07418   if ((argc < 0) || (argc > 0)) {
07419     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
07420   }
07421   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
07422   if (!SWIG_IsOK(res1)) {
07423     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReverseItems" "', argument " "1"" of type '" "uMenu *""'"); 
07424   }
07425   arg1 = reinterpret_cast< uMenu * >(argp1);
07426   (arg1)->ReverseItems();
07427   return Qnil;
07428 fail:
07429   return Qnil;
07430 }
07431 
07432 
07433 SWIGINTERN VALUE
07434 _wrap_UMenu_generic_background(int argc, VALUE *argv, VALUE self) {
07435   if ((argc < 0) || (argc > 0)) {
07436     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
07437   }
07438   uMenu::GenericBackground();
07439   return Qnil;
07440 fail:
07441   return Qnil;
07442 }
07443 
07444 
07445 SWIGINTERN VALUE
07446 _wrap_UMenu_exit(int argc, VALUE *argv, VALUE self) {
07447   uMenu *arg1 = (uMenu *) 0 ;
07448   void *argp1 = 0 ;
07449   int res1 = 0 ;
07450   
07451   if ((argc < 0) || (argc > 0)) {
07452     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
07453   }
07454   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
07455   if (!SWIG_IsOK(res1)) {
07456     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Exit" "', argument " "1"" of type '" "uMenu *""'"); 
07457   }
07458   arg1 = reinterpret_cast< uMenu * >(argp1);
07459   (arg1)->Exit();
07460   return Qnil;
07461 fail:
07462   return Qnil;
07463 }
07464 
07465 
07466 SWIGINTERN VALUE
07467 _wrap_UMenu_request_space_below(int argc, VALUE *argv, VALUE self) {
07468   uMenu *arg1 = (uMenu *) 0 ;
07469   REAL arg2 ;
07470   void *argp1 = 0 ;
07471   int res1 = 0 ;
07472   float val2 ;
07473   int ecode2 = 0 ;
07474   
07475   if ((argc < 1) || (argc > 1)) {
07476     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
07477   }
07478   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
07479   if (!SWIG_IsOK(res1)) {
07480     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestSpaceBelow" "', argument " "1"" of type '" "uMenu *""'"); 
07481   }
07482   arg1 = reinterpret_cast< uMenu * >(argp1);
07483   ecode2 = SWIG_AsVal_float(argv[0], &val2);
07484   if (!SWIG_IsOK(ecode2)) {
07485     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RequestSpaceBelow" "', argument " "2"" of type '" "REAL""'");
07486   } 
07487   arg2 = static_cast< REAL >(val2);
07488   (arg1)->RequestSpaceBelow(arg2);
07489   return Qnil;
07490 fail:
07491   return Qnil;
07492 }
07493 
07494 
07495 SWIGINTERN VALUE
07496 _wrap_UMenu_message__SWIG_0(int argc, VALUE *argv, VALUE self) {
07497   tOutput *arg1 = 0 ;
07498   tOutput *arg2 = 0 ;
07499   REAL arg3 ;
07500   void *argp1 ;
07501   int res1 = 0 ;
07502   void *argp2 ;
07503   int res2 = 0 ;
07504   float val3 ;
07505   int ecode3 = 0 ;
07506   
07507   if ((argc < 3) || (argc > 3)) {
07508     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
07509   }
07510   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tOutput,  0 );
07511   if (!SWIG_IsOK(res1)) {
07512     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uMenu::Message" "', argument " "1"" of type '" "tOutput const &""'"); 
07513   }
07514   if (!argp1) {
07515     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenu::Message" "', argument " "1"" of type '" "tOutput const &""'"); 
07516   }
07517   arg1 = reinterpret_cast< tOutput * >(argp1);
07518   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_tOutput,  0 );
07519   if (!SWIG_IsOK(res2)) {
07520     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "uMenu::Message" "', argument " "2"" of type '" "tOutput const &""'"); 
07521   }
07522   if (!argp2) {
07523     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenu::Message" "', argument " "2"" of type '" "tOutput const &""'"); 
07524   }
07525   arg2 = reinterpret_cast< tOutput * >(argp2);
07526   ecode3 = SWIG_AsVal_float(argv[2], &val3);
07527   if (!SWIG_IsOK(ecode3)) {
07528     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "uMenu::Message" "', argument " "3"" of type '" "REAL""'");
07529   } 
07530   arg3 = static_cast< REAL >(val3);
07531   uMenu::Message((tOutput const &)*arg1,(tOutput const &)*arg2,arg3);
07532   return Qnil;
07533 fail:
07534   return Qnil;
07535 }
07536 
07537 
07538 SWIGINTERN VALUE
07539 _wrap_UMenu_message__SWIG_1(int argc, VALUE *argv, VALUE self) {
07540   tOutput *arg1 = 0 ;
07541   tOutput *arg2 = 0 ;
07542   void *argp1 ;
07543   int res1 = 0 ;
07544   void *argp2 ;
07545   int res2 = 0 ;
07546   
07547   if ((argc < 2) || (argc > 2)) {
07548     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
07549   }
07550   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_tOutput,  0 );
07551   if (!SWIG_IsOK(res1)) {
07552     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uMenu::Message" "', argument " "1"" of type '" "tOutput const &""'"); 
07553   }
07554   if (!argp1) {
07555     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenu::Message" "', argument " "1"" of type '" "tOutput const &""'"); 
07556   }
07557   arg1 = reinterpret_cast< tOutput * >(argp1);
07558   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_tOutput,  0 );
07559   if (!SWIG_IsOK(res2)) {
07560     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "uMenu::Message" "', argument " "2"" of type '" "tOutput const &""'"); 
07561   }
07562   if (!argp2) {
07563     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenu::Message" "', argument " "2"" of type '" "tOutput const &""'"); 
07564   }
07565   arg2 = reinterpret_cast< tOutput * >(argp2);
07566   uMenu::Message((tOutput const &)*arg1,(tOutput const &)*arg2);
07567   return Qnil;
07568 fail:
07569   return Qnil;
07570 }
07571 
07572 
07573 SWIGINTERN VALUE _wrap_UMenu_message(int nargs, VALUE *args, VALUE self) {
07574   int argc;
07575   VALUE argv[3];
07576   int ii;
07577   
07578   argc = nargs;
07579   if (argc > 3) SWIG_fail;
07580   for (ii = 0; (ii < argc); ii++) {
07581     argv[ii] = args[ii];
07582   }
07583   if (argc == 2) {
07584     int _v;
07585     void *vptr = 0;
07586     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tOutput, 0);
07587     _v = SWIG_CheckState(res);
07588     if (_v) {
07589       void *vptr = 0;
07590       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_tOutput, 0);
07591       _v = SWIG_CheckState(res);
07592       if (_v) {
07593         return _wrap_UMenu_message__SWIG_1(nargs, args, self);
07594       }
07595     }
07596   }
07597   if (argc == 3) {
07598     int _v;
07599     void *vptr = 0;
07600     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_tOutput, 0);
07601     _v = SWIG_CheckState(res);
07602     if (_v) {
07603       void *vptr = 0;
07604       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_tOutput, 0);
07605       _v = SWIG_CheckState(res);
07606       if (_v) {
07607         {
07608           int res = SWIG_AsVal_float(argv[2], NULL);
07609           _v = SWIG_CheckState(res);
07610         }
07611         if (_v) {
07612           return _wrap_UMenu_message__SWIG_0(nargs, args, self);
07613         }
07614       }
07615     }
07616   }
07617   
07618 fail:
07619   rb_raise(rb_eArgError, "No matching function for overloaded 'UMenu_message'");
07620   return Qnil;
07621 }
07622 
07623 
07624 SWIGINTERN VALUE
07625 _wrap_UMenu_menu_active(int argc, VALUE *argv, VALUE self) {
07626   bool result;
07627   VALUE vresult = Qnil;
07628   
07629   if ((argc < 0) || (argc > 0)) {
07630     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
07631   }
07632   result = (bool)uMenu::MenuActive();
07633   vresult = SWIG_From_bool(static_cast< bool >(result));
07634   return vresult;
07635 fail:
07636   return Qnil;
07637 }
07638 
07639 
07640 swig_class cUMenuItem;
07641 
07642 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
07643 SWIGINTERN VALUE
07644 _wrap_UMenuItem_allocate(VALUE self) {
07645 #else
07646   SWIGINTERN VALUE
07647   _wrap_UMenuItem_allocate(int argc, VALUE *argv, VALUE self) {
07648 #endif
07649     
07650     
07651     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_uMenuItem);
07652 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
07653     rb_obj_call_init(vresult, argc, argv);
07654 #endif
07655     return vresult;
07656   }
07657   
07658 
07659 SWIGINTERN VALUE
07660 _wrap_new_UMenuItem(int argc, VALUE *argv, VALUE self) {
07661   uMenu *arg1 = (uMenu *) 0 ;
07662   tOutput *arg2 = 0 ;
07663   uMenuItem *result = 0 ;
07664   void *argp1 = 0 ;
07665   int res1 = 0 ;
07666   void *argp2 ;
07667   int res2 = 0 ;
07668   const char *classname SWIGUNUSED = "Armagetronad::UMenuItem";
07669   
07670   if ((argc < 2) || (argc > 2)) {
07671     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
07672   }
07673   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
07674   if (!SWIG_IsOK(res1)) {
07675     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uMenuItem" "', argument " "1"" of type '" "uMenu *""'"); 
07676   }
07677   arg1 = reinterpret_cast< uMenu * >(argp1);
07678   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_tOutput,  0 );
07679   if (!SWIG_IsOK(res2)) {
07680     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "uMenuItem" "', argument " "2"" of type '" "tOutput const &""'"); 
07681   }
07682   if (!argp2) {
07683     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItem" "', argument " "2"" of type '" "tOutput const &""'"); 
07684   }
07685   arg2 = reinterpret_cast< tOutput * >(argp2);
07686   result = (uMenuItem *)new uMenuItem(arg1,(tOutput const &)*arg2);DATA_PTR(self) = result;
07687   
07688   return self;
07689 fail:
07690   return Qnil;
07691 }
07692 
07693 
07694 SWIGINTERN void
07695 free_uMenuItem(uMenuItem *arg1) {
07696     delete arg1;
07697 }
07698 
07699 SWIGINTERN VALUE
07700 _wrap_UMenuItem_help(int argc, VALUE *argv, VALUE self) {
07701   uMenuItem *arg1 = (uMenuItem *) 0 ;
07702   tString result;
07703   void *argp1 = 0 ;
07704   int res1 = 0 ;
07705   VALUE vresult = Qnil;
07706   
07707   if ((argc < 0) || (argc > 0)) {
07708     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
07709   }
07710   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItem, 0 |  0 );
07711   if (!SWIG_IsOK(res1)) {
07712     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Help" "', argument " "1"" of type '" "uMenuItem *""'"); 
07713   }
07714   arg1 = reinterpret_cast< uMenuItem * >(argp1);
07715   result = (arg1)->Help();
07716   vresult = SWIG_NewPointerObj((new tString(static_cast< const tString& >(result))), SWIGTYPE_p_tString, SWIG_POINTER_OWN |  0 );
07717   return vresult;
07718 fail:
07719   return Qnil;
07720 }
07721 
07722 
07723 SWIGINTERN VALUE
07724 _wrap_UMenuItem_render__SWIG_0(int argc, VALUE *argv, VALUE self) {
07725   uMenuItem *arg1 = (uMenuItem *) 0 ;
07726   REAL arg2 ;
07727   REAL arg3 ;
07728   REAL arg4 ;
07729   bool arg5 ;
07730   void *argp1 = 0 ;
07731   int res1 = 0 ;
07732   float val2 ;
07733   int ecode2 = 0 ;
07734   float val3 ;
07735   int ecode3 = 0 ;
07736   float val4 ;
07737   int ecode4 = 0 ;
07738   bool val5 ;
07739   int ecode5 = 0 ;
07740   
07741   if ((argc < 4) || (argc > 4)) {
07742     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
07743   }
07744   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItem, 0 |  0 );
07745   if (!SWIG_IsOK(res1)) {
07746     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItem *""'"); 
07747   }
07748   arg1 = reinterpret_cast< uMenuItem * >(argp1);
07749   ecode2 = SWIG_AsVal_float(argv[0], &val2);
07750   if (!SWIG_IsOK(ecode2)) {
07751     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
07752   } 
07753   arg2 = static_cast< REAL >(val2);
07754   ecode3 = SWIG_AsVal_float(argv[1], &val3);
07755   if (!SWIG_IsOK(ecode3)) {
07756     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
07757   } 
07758   arg3 = static_cast< REAL >(val3);
07759   ecode4 = SWIG_AsVal_float(argv[2], &val4);
07760   if (!SWIG_IsOK(ecode4)) {
07761     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Render" "', argument " "4"" of type '" "REAL""'");
07762   } 
07763   arg4 = static_cast< REAL >(val4);
07764   ecode5 = SWIG_AsVal_bool(argv[3], &val5);
07765   if (!SWIG_IsOK(ecode5)) {
07766     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Render" "', argument " "5"" of type '" "bool""'");
07767   } 
07768   arg5 = static_cast< bool >(val5);
07769   (arg1)->Render(arg2,arg3,arg4,arg5);
07770   return Qnil;
07771 fail:
07772   return Qnil;
07773 }
07774 
07775 
07776 SWIGINTERN VALUE
07777 _wrap_UMenuItem_render__SWIG_1(int argc, VALUE *argv, VALUE self) {
07778   uMenuItem *arg1 = (uMenuItem *) 0 ;
07779   REAL arg2 ;
07780   REAL arg3 ;
07781   REAL arg4 ;
07782   void *argp1 = 0 ;
07783   int res1 = 0 ;
07784   float val2 ;
07785   int ecode2 = 0 ;
07786   float val3 ;
07787   int ecode3 = 0 ;
07788   float val4 ;
07789   int ecode4 = 0 ;
07790   
07791   if ((argc < 3) || (argc > 3)) {
07792     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
07793   }
07794   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItem, 0 |  0 );
07795   if (!SWIG_IsOK(res1)) {
07796     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItem *""'"); 
07797   }
07798   arg1 = reinterpret_cast< uMenuItem * >(argp1);
07799   ecode2 = SWIG_AsVal_float(argv[0], &val2);
07800   if (!SWIG_IsOK(ecode2)) {
07801     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
07802   } 
07803   arg2 = static_cast< REAL >(val2);
07804   ecode3 = SWIG_AsVal_float(argv[1], &val3);
07805   if (!SWIG_IsOK(ecode3)) {
07806     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
07807   } 
07808   arg3 = static_cast< REAL >(val3);
07809   ecode4 = SWIG_AsVal_float(argv[2], &val4);
07810   if (!SWIG_IsOK(ecode4)) {
07811     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Render" "', argument " "4"" of type '" "REAL""'");
07812   } 
07813   arg4 = static_cast< REAL >(val4);
07814   (arg1)->Render(arg2,arg3,arg4);
07815   return Qnil;
07816 fail:
07817   return Qnil;
07818 }
07819 
07820 
07821 SWIGINTERN VALUE
07822 _wrap_UMenuItem_render__SWIG_2(int argc, VALUE *argv, VALUE self) {
07823   uMenuItem *arg1 = (uMenuItem *) 0 ;
07824   REAL arg2 ;
07825   REAL arg3 ;
07826   void *argp1 = 0 ;
07827   int res1 = 0 ;
07828   float val2 ;
07829   int ecode2 = 0 ;
07830   float val3 ;
07831   int ecode3 = 0 ;
07832   
07833   if ((argc < 2) || (argc > 2)) {
07834     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
07835   }
07836   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItem, 0 |  0 );
07837   if (!SWIG_IsOK(res1)) {
07838     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItem *""'"); 
07839   }
07840   arg1 = reinterpret_cast< uMenuItem * >(argp1);
07841   ecode2 = SWIG_AsVal_float(argv[0], &val2);
07842   if (!SWIG_IsOK(ecode2)) {
07843     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
07844   } 
07845   arg2 = static_cast< REAL >(val2);
07846   ecode3 = SWIG_AsVal_float(argv[1], &val3);
07847   if (!SWIG_IsOK(ecode3)) {
07848     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
07849   } 
07850   arg3 = static_cast< REAL >(val3);
07851   (arg1)->Render(arg2,arg3);
07852   return Qnil;
07853 fail:
07854   return Qnil;
07855 }
07856 
07857 
07858 SWIGINTERN VALUE _wrap_UMenuItem_render(int nargs, VALUE *args, VALUE self) {
07859   int argc;
07860   VALUE argv[6];
07861   int ii;
07862   
07863   argc = nargs + 1;
07864   argv[0] = self;
07865   if (argc > 6) SWIG_fail;
07866   for (ii = 1; (ii < argc); ii++) {
07867     argv[ii] = args[ii-1];
07868   }
07869   if (argc == 3) {
07870     int _v;
07871     void *vptr = 0;
07872     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItem, 0);
07873     _v = SWIG_CheckState(res);
07874     if (_v) {
07875       {
07876         int res = SWIG_AsVal_float(argv[1], NULL);
07877         _v = SWIG_CheckState(res);
07878       }
07879       if (_v) {
07880         {
07881           int res = SWIG_AsVal_float(argv[2], NULL);
07882           _v = SWIG_CheckState(res);
07883         }
07884         if (_v) {
07885           return _wrap_UMenuItem_render__SWIG_2(nargs, args, self);
07886         }
07887       }
07888     }
07889   }
07890   if (argc == 4) {
07891     int _v;
07892     void *vptr = 0;
07893     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItem, 0);
07894     _v = SWIG_CheckState(res);
07895     if (_v) {
07896       {
07897         int res = SWIG_AsVal_float(argv[1], NULL);
07898         _v = SWIG_CheckState(res);
07899       }
07900       if (_v) {
07901         {
07902           int res = SWIG_AsVal_float(argv[2], NULL);
07903           _v = SWIG_CheckState(res);
07904         }
07905         if (_v) {
07906           {
07907             int res = SWIG_AsVal_float(argv[3], NULL);
07908             _v = SWIG_CheckState(res);
07909           }
07910           if (_v) {
07911             return _wrap_UMenuItem_render__SWIG_1(nargs, args, self);
07912           }
07913         }
07914       }
07915     }
07916   }
07917   if (argc == 5) {
07918     int _v;
07919     void *vptr = 0;
07920     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItem, 0);
07921     _v = SWIG_CheckState(res);
07922     if (_v) {
07923       {
07924         int res = SWIG_AsVal_float(argv[1], NULL);
07925         _v = SWIG_CheckState(res);
07926       }
07927       if (_v) {
07928         {
07929           int res = SWIG_AsVal_float(argv[2], NULL);
07930           _v = SWIG_CheckState(res);
07931         }
07932         if (_v) {
07933           {
07934             int res = SWIG_AsVal_float(argv[3], NULL);
07935             _v = SWIG_CheckState(res);
07936           }
07937           if (_v) {
07938             {
07939               int res = SWIG_AsVal_bool(argv[4], NULL);
07940               _v = SWIG_CheckState(res);
07941             }
07942             if (_v) {
07943               return _wrap_UMenuItem_render__SWIG_0(nargs, args, self);
07944             }
07945           }
07946         }
07947       }
07948     }
07949   }
07950   
07951 fail:
07952   rb_raise(rb_eArgError, "No matching function for overloaded 'UMenuItem_render'");
07953   return Qnil;
07954 }
07955 
07956 
07957 SWIGINTERN VALUE
07958 _wrap_UMenuItem_render_background(int argc, VALUE *argv, VALUE self) {
07959   uMenuItem *arg1 = (uMenuItem *) 0 ;
07960   void *argp1 = 0 ;
07961   int res1 = 0 ;
07962   
07963   if ((argc < 0) || (argc > 0)) {
07964     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
07965   }
07966   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItem, 0 |  0 );
07967   if (!SWIG_IsOK(res1)) {
07968     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RenderBackground" "', argument " "1"" of type '" "uMenuItem *""'"); 
07969   }
07970   arg1 = reinterpret_cast< uMenuItem * >(argp1);
07971   (arg1)->RenderBackground();
07972   return Qnil;
07973 fail:
07974   return Qnil;
07975 }
07976 
07977 
07978 SWIGINTERN VALUE
07979 _wrap_UMenuItem_left_right(int argc, VALUE *argv, VALUE self) {
07980   uMenuItem *arg1 = (uMenuItem *) 0 ;
07981   int arg2 ;
07982   void *argp1 = 0 ;
07983   int res1 = 0 ;
07984   int val2 ;
07985   int ecode2 = 0 ;
07986   
07987   if ((argc < 1) || (argc > 1)) {
07988     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
07989   }
07990   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItem, 0 |  0 );
07991   if (!SWIG_IsOK(res1)) {
07992     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeftRight" "', argument " "1"" of type '" "uMenuItem *""'"); 
07993   }
07994   arg1 = reinterpret_cast< uMenuItem * >(argp1);
07995   ecode2 = SWIG_AsVal_int(argv[0], &val2);
07996   if (!SWIG_IsOK(ecode2)) {
07997     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LeftRight" "', argument " "2"" of type '" "int""'");
07998   } 
07999   arg2 = static_cast< int >(val2);
08000   (arg1)->LeftRight(arg2);
08001   return Qnil;
08002 fail:
08003   return Qnil;
08004 }
08005 
08006 
08007 SWIGINTERN VALUE
08008 _wrap_UMenuItem_left_right_release(int argc, VALUE *argv, VALUE self) {
08009   uMenuItem *arg1 = (uMenuItem *) 0 ;
08010   void *argp1 = 0 ;
08011   int res1 = 0 ;
08012   
08013   if ((argc < 0) || (argc > 0)) {
08014     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
08015   }
08016   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItem, 0 |  0 );
08017   if (!SWIG_IsOK(res1)) {
08018     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeftRightRelease" "', argument " "1"" of type '" "uMenuItem *""'"); 
08019   }
08020   arg1 = reinterpret_cast< uMenuItem * >(argp1);
08021   (arg1)->LeftRightRelease();
08022   return Qnil;
08023 fail:
08024   return Qnil;
08025 }
08026 
08027 
08028 SWIGINTERN VALUE
08029 _wrap_UMenuItem_enter(int argc, VALUE *argv, VALUE self) {
08030   uMenuItem *arg1 = (uMenuItem *) 0 ;
08031   void *argp1 = 0 ;
08032   int res1 = 0 ;
08033   
08034   if ((argc < 0) || (argc > 0)) {
08035     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
08036   }
08037   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItem, 0 |  0 );
08038   if (!SWIG_IsOK(res1)) {
08039     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enter" "', argument " "1"" of type '" "uMenuItem *""'"); 
08040   }
08041   arg1 = reinterpret_cast< uMenuItem * >(argp1);
08042   (arg1)->Enter();
08043   return Qnil;
08044 fail:
08045   return Qnil;
08046 }
08047 
08048 
08049 SWIGINTERN VALUE
08050 _wrap_UMenuItem_event(int argc, VALUE *argv, VALUE self) {
08051   uMenuItem *arg1 = (uMenuItem *) 0 ;
08052   SDL_Event *arg2 = 0 ;
08053   bool result;
08054   void *argp1 = 0 ;
08055   int res1 = 0 ;
08056   void *argp2 = 0 ;
08057   int res2 = 0 ;
08058   VALUE vresult = Qnil;
08059   
08060   if ((argc < 1) || (argc > 1)) {
08061     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
08062   }
08063   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItem, 0 |  0 );
08064   if (!SWIG_IsOK(res1)) {
08065     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event" "', argument " "1"" of type '" "uMenuItem *""'"); 
08066   }
08067   arg1 = reinterpret_cast< uMenuItem * >(argp1);
08068   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_SDL_Event,  0 );
08069   if (!SWIG_IsOK(res2)) {
08070     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event" "', argument " "2"" of type '" "SDL_Event &""'"); 
08071   }
08072   if (!argp2) {
08073     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event" "', argument " "2"" of type '" "SDL_Event &""'"); 
08074   }
08075   arg2 = reinterpret_cast< SDL_Event * >(argp2);
08076   result = (bool)(arg1)->Event(*arg2);
08077   vresult = SWIG_From_bool(static_cast< bool >(result));
08078   return vresult;
08079 fail:
08080   return Qnil;
08081 }
08082 
08083 
08084 SWIGINTERN VALUE
08085 _wrap_UMenuItem_space_right(int argc, VALUE *argv, VALUE self) {
08086   uMenuItem *arg1 = (uMenuItem *) 0 ;
08087   REAL result;
08088   void *argp1 = 0 ;
08089   int res1 = 0 ;
08090   VALUE vresult = Qnil;
08091   
08092   if ((argc < 0) || (argc > 0)) {
08093     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
08094   }
08095   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItem, 0 |  0 );
08096   if (!SWIG_IsOK(res1)) {
08097     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpaceRight" "', argument " "1"" of type '" "uMenuItem *""'"); 
08098   }
08099   arg1 = reinterpret_cast< uMenuItem * >(argp1);
08100   result = (REAL)(arg1)->SpaceRight();
08101   vresult = SWIG_From_float(static_cast< float >(result));
08102   return vresult;
08103 fail:
08104   return Qnil;
08105 }
08106 
08107 
08108 SWIGINTERN VALUE
08109 _wrap_UMenuItem_get_id(int argc, VALUE *argv, VALUE self) {
08110   uMenuItem *arg1 = (uMenuItem *) 0 ;
08111   int result;
08112   void *argp1 = 0 ;
08113   int res1 = 0 ;
08114   VALUE vresult = Qnil;
08115   
08116   if ((argc < 0) || (argc > 0)) {
08117     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
08118   }
08119   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItem, 0 |  0 );
08120   if (!SWIG_IsOK(res1)) {
08121     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetID" "', argument " "1"" of type '" "uMenuItem *""'"); 
08122   }
08123   arg1 = reinterpret_cast< uMenuItem * >(argp1);
08124   result = (int)(arg1)->GetID();
08125   vresult = SWIG_From_int(static_cast< int >(result));
08126   return vresult;
08127 fail:
08128   return Qnil;
08129 }
08130 
08131 
08132 SWIGINTERN VALUE
08133 _wrap_UMenuItem_is_selectable(int argc, VALUE *argv, VALUE self) {
08134   uMenuItem *arg1 = (uMenuItem *) 0 ;
08135   bool result;
08136   void *argp1 = 0 ;
08137   int res1 = 0 ;
08138   VALUE vresult = Qnil;
08139   
08140   if ((argc < 0) || (argc > 0)) {
08141     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
08142   }
08143   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItem, 0 |  0 );
08144   if (!SWIG_IsOK(res1)) {
08145     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsSelectable" "', argument " "1"" of type '" "uMenuItem *""'"); 
08146   }
08147   arg1 = reinterpret_cast< uMenuItem * >(argp1);
08148   result = (bool)(arg1)->IsSelectable();
08149   vresult = SWIG_From_bool(static_cast< bool >(result));
08150   return vresult;
08151 fail:
08152   return Qnil;
08153 }
08154 
08155 
08156 swig_class cUMenuItemExit;
08157 
08158 SWIGINTERN VALUE
08159 _wrap_new_UMenuItemExit__SWIG_0(int argc, VALUE *argv, VALUE self) {
08160   uMenu *arg1 = (uMenu *) 0 ;
08161   tOutput *arg2 = 0 ;
08162   tOutput *arg3 = 0 ;
08163   uMenuItemExit *result = 0 ;
08164   void *argp1 = 0 ;
08165   int res1 = 0 ;
08166   void *argp2 ;
08167   int res2 = 0 ;
08168   void *argp3 ;
08169   int res3 = 0 ;
08170   const char *classname SWIGUNUSED = "Armagetronad::UMenuItemExit";
08171   
08172   if ((argc < 3) || (argc > 3)) {
08173     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
08174   }
08175   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
08176   if (!SWIG_IsOK(res1)) {
08177     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uMenuItemExit" "', argument " "1"" of type '" "uMenu *""'"); 
08178   }
08179   arg1 = reinterpret_cast< uMenu * >(argp1);
08180   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_tOutput,  0 );
08181   if (!SWIG_IsOK(res2)) {
08182     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "uMenuItemExit" "', argument " "2"" of type '" "tOutput const &""'"); 
08183   }
08184   if (!argp2) {
08185     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemExit" "', argument " "2"" of type '" "tOutput const &""'"); 
08186   }
08187   arg2 = reinterpret_cast< tOutput * >(argp2);
08188   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_tOutput,  0 );
08189   if (!SWIG_IsOK(res3)) {
08190     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "uMenuItemExit" "', argument " "3"" of type '" "tOutput const &""'"); 
08191   }
08192   if (!argp3) {
08193     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemExit" "', argument " "3"" of type '" "tOutput const &""'"); 
08194   }
08195   arg3 = reinterpret_cast< tOutput * >(argp3);
08196   result = (uMenuItemExit *)new uMenuItemExit(arg1,(tOutput const &)*arg2,(tOutput const &)*arg3);DATA_PTR(self) = result;
08197   
08198   return self;
08199 fail:
08200   return Qnil;
08201 }
08202 
08203 
08204 SWIGINTERN VALUE
08205 _wrap_new_UMenuItemExit__SWIG_1(int argc, VALUE *argv, VALUE self) {
08206   uMenu *arg1 = (uMenu *) 0 ;
08207   tOutput *arg2 = 0 ;
08208   uMenuItemExit *result = 0 ;
08209   void *argp1 = 0 ;
08210   int res1 = 0 ;
08211   void *argp2 ;
08212   int res2 = 0 ;
08213   const char *classname SWIGUNUSED = "Armagetronad::UMenuItemExit";
08214   
08215   if ((argc < 2) || (argc > 2)) {
08216     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
08217   }
08218   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
08219   if (!SWIG_IsOK(res1)) {
08220     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uMenuItemExit" "', argument " "1"" of type '" "uMenu *""'"); 
08221   }
08222   arg1 = reinterpret_cast< uMenu * >(argp1);
08223   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_tOutput,  0 );
08224   if (!SWIG_IsOK(res2)) {
08225     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "uMenuItemExit" "', argument " "2"" of type '" "tOutput const &""'"); 
08226   }
08227   if (!argp2) {
08228     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemExit" "', argument " "2"" of type '" "tOutput const &""'"); 
08229   }
08230   arg2 = reinterpret_cast< tOutput * >(argp2);
08231   result = (uMenuItemExit *)new uMenuItemExit(arg1,(tOutput const &)*arg2);DATA_PTR(self) = result;
08232   
08233   return self;
08234 fail:
08235   return Qnil;
08236 }
08237 
08238 
08239 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
08240 SWIGINTERN VALUE
08241 _wrap_UMenuItemExit_allocate(VALUE self) {
08242 #else
08243   SWIGINTERN VALUE
08244   _wrap_UMenuItemExit_allocate(int argc, VALUE *argv, VALUE self) {
08245 #endif
08246     
08247     
08248     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_uMenuItemExit);
08249 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
08250     rb_obj_call_init(vresult, argc, argv);
08251 #endif
08252     return vresult;
08253   }
08254   
08255 
08256 SWIGINTERN VALUE
08257 _wrap_new_UMenuItemExit__SWIG_2(int argc, VALUE *argv, VALUE self) {
08258   uMenu *arg1 = (uMenu *) 0 ;
08259   uMenuItemExit *result = 0 ;
08260   void *argp1 = 0 ;
08261   int res1 = 0 ;
08262   const char *classname SWIGUNUSED = "Armagetronad::UMenuItemExit";
08263   
08264   if ((argc < 1) || (argc > 1)) {
08265     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
08266   }
08267   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
08268   if (!SWIG_IsOK(res1)) {
08269     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uMenuItemExit" "', argument " "1"" of type '" "uMenu *""'"); 
08270   }
08271   arg1 = reinterpret_cast< uMenu * >(argp1);
08272   result = (uMenuItemExit *)new uMenuItemExit(arg1);DATA_PTR(self) = result;
08273   
08274   return self;
08275 fail:
08276   return Qnil;
08277 }
08278 
08279 
08280 SWIGINTERN VALUE _wrap_new_UMenuItemExit(int nargs, VALUE *args, VALUE self) {
08281   int argc;
08282   VALUE argv[3];
08283   int ii;
08284   
08285   argc = nargs;
08286   if (argc > 3) SWIG_fail;
08287   for (ii = 0; (ii < argc); ii++) {
08288     argv[ii] = args[ii];
08289   }
08290   if (argc == 1) {
08291     int _v;
08292     void *vptr = 0;
08293     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenu, 0);
08294     _v = SWIG_CheckState(res);
08295     if (_v) {
08296       return _wrap_new_UMenuItemExit__SWIG_2(nargs, args, self);
08297     }
08298   }
08299   if (argc == 2) {
08300     int _v;
08301     void *vptr = 0;
08302     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenu, 0);
08303     _v = SWIG_CheckState(res);
08304     if (_v) {
08305       void *vptr = 0;
08306       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_tOutput, 0);
08307       _v = SWIG_CheckState(res);
08308       if (_v) {
08309         return _wrap_new_UMenuItemExit__SWIG_1(nargs, args, self);
08310       }
08311     }
08312   }
08313   if (argc == 3) {
08314     int _v;
08315     void *vptr = 0;
08316     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenu, 0);
08317     _v = SWIG_CheckState(res);
08318     if (_v) {
08319       void *vptr = 0;
08320       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_tOutput, 0);
08321       _v = SWIG_CheckState(res);
08322       if (_v) {
08323         void *vptr = 0;
08324         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_tOutput, 0);
08325         _v = SWIG_CheckState(res);
08326         if (_v) {
08327           return _wrap_new_UMenuItemExit__SWIG_0(nargs, args, self);
08328         }
08329       }
08330     }
08331   }
08332   
08333 fail:
08334   rb_raise(rb_eArgError, "No matching function for overloaded 'new_UMenuItemExit'");
08335   return Qnil;
08336 }
08337 
08338 
08339 SWIGINTERN VALUE
08340 _wrap_UMenuItemExit_render__SWIG_0(int argc, VALUE *argv, VALUE self) {
08341   uMenuItemExit *arg1 = (uMenuItemExit *) 0 ;
08342   REAL arg2 ;
08343   REAL arg3 ;
08344   REAL arg4 ;
08345   bool arg5 ;
08346   void *argp1 = 0 ;
08347   int res1 = 0 ;
08348   float val2 ;
08349   int ecode2 = 0 ;
08350   float val3 ;
08351   int ecode3 = 0 ;
08352   float val4 ;
08353   int ecode4 = 0 ;
08354   bool val5 ;
08355   int ecode5 = 0 ;
08356   
08357   if ((argc < 4) || (argc > 4)) {
08358     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
08359   }
08360   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemExit, 0 |  0 );
08361   if (!SWIG_IsOK(res1)) {
08362     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItemExit *""'"); 
08363   }
08364   arg1 = reinterpret_cast< uMenuItemExit * >(argp1);
08365   ecode2 = SWIG_AsVal_float(argv[0], &val2);
08366   if (!SWIG_IsOK(ecode2)) {
08367     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
08368   } 
08369   arg2 = static_cast< REAL >(val2);
08370   ecode3 = SWIG_AsVal_float(argv[1], &val3);
08371   if (!SWIG_IsOK(ecode3)) {
08372     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
08373   } 
08374   arg3 = static_cast< REAL >(val3);
08375   ecode4 = SWIG_AsVal_float(argv[2], &val4);
08376   if (!SWIG_IsOK(ecode4)) {
08377     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Render" "', argument " "4"" of type '" "REAL""'");
08378   } 
08379   arg4 = static_cast< REAL >(val4);
08380   ecode5 = SWIG_AsVal_bool(argv[3], &val5);
08381   if (!SWIG_IsOK(ecode5)) {
08382     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Render" "', argument " "5"" of type '" "bool""'");
08383   } 
08384   arg5 = static_cast< bool >(val5);
08385   (arg1)->Render(arg2,arg3,arg4,arg5);
08386   return Qnil;
08387 fail:
08388   return Qnil;
08389 }
08390 
08391 
08392 SWIGINTERN VALUE
08393 _wrap_UMenuItemExit_render__SWIG_1(int argc, VALUE *argv, VALUE self) {
08394   uMenuItemExit *arg1 = (uMenuItemExit *) 0 ;
08395   REAL arg2 ;
08396   REAL arg3 ;
08397   REAL arg4 ;
08398   void *argp1 = 0 ;
08399   int res1 = 0 ;
08400   float val2 ;
08401   int ecode2 = 0 ;
08402   float val3 ;
08403   int ecode3 = 0 ;
08404   float val4 ;
08405   int ecode4 = 0 ;
08406   
08407   if ((argc < 3) || (argc > 3)) {
08408     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
08409   }
08410   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemExit, 0 |  0 );
08411   if (!SWIG_IsOK(res1)) {
08412     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItemExit *""'"); 
08413   }
08414   arg1 = reinterpret_cast< uMenuItemExit * >(argp1);
08415   ecode2 = SWIG_AsVal_float(argv[0], &val2);
08416   if (!SWIG_IsOK(ecode2)) {
08417     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
08418   } 
08419   arg2 = static_cast< REAL >(val2);
08420   ecode3 = SWIG_AsVal_float(argv[1], &val3);
08421   if (!SWIG_IsOK(ecode3)) {
08422     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
08423   } 
08424   arg3 = static_cast< REAL >(val3);
08425   ecode4 = SWIG_AsVal_float(argv[2], &val4);
08426   if (!SWIG_IsOK(ecode4)) {
08427     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Render" "', argument " "4"" of type '" "REAL""'");
08428   } 
08429   arg4 = static_cast< REAL >(val4);
08430   (arg1)->Render(arg2,arg3,arg4);
08431   return Qnil;
08432 fail:
08433   return Qnil;
08434 }
08435 
08436 
08437 SWIGINTERN VALUE
08438 _wrap_UMenuItemExit_render__SWIG_2(int argc, VALUE *argv, VALUE self) {
08439   uMenuItemExit *arg1 = (uMenuItemExit *) 0 ;
08440   REAL arg2 ;
08441   REAL arg3 ;
08442   void *argp1 = 0 ;
08443   int res1 = 0 ;
08444   float val2 ;
08445   int ecode2 = 0 ;
08446   float val3 ;
08447   int ecode3 = 0 ;
08448   
08449   if ((argc < 2) || (argc > 2)) {
08450     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
08451   }
08452   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemExit, 0 |  0 );
08453   if (!SWIG_IsOK(res1)) {
08454     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItemExit *""'"); 
08455   }
08456   arg1 = reinterpret_cast< uMenuItemExit * >(argp1);
08457   ecode2 = SWIG_AsVal_float(argv[0], &val2);
08458   if (!SWIG_IsOK(ecode2)) {
08459     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
08460   } 
08461   arg2 = static_cast< REAL >(val2);
08462   ecode3 = SWIG_AsVal_float(argv[1], &val3);
08463   if (!SWIG_IsOK(ecode3)) {
08464     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
08465   } 
08466   arg3 = static_cast< REAL >(val3);
08467   (arg1)->Render(arg2,arg3);
08468   return Qnil;
08469 fail:
08470   return Qnil;
08471 }
08472 
08473 
08474 SWIGINTERN VALUE _wrap_UMenuItemExit_render(int nargs, VALUE *args, VALUE self) {
08475   int argc;
08476   VALUE argv[6];
08477   int ii;
08478   
08479   argc = nargs + 1;
08480   argv[0] = self;
08481   if (argc > 6) SWIG_fail;
08482   for (ii = 1; (ii < argc); ii++) {
08483     argv[ii] = args[ii-1];
08484   }
08485   if (argc == 3) {
08486     int _v;
08487     void *vptr = 0;
08488     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItemExit, 0);
08489     _v = SWIG_CheckState(res);
08490     if (_v) {
08491       {
08492         int res = SWIG_AsVal_float(argv[1], NULL);
08493         _v = SWIG_CheckState(res);
08494       }
08495       if (_v) {
08496         {
08497           int res = SWIG_AsVal_float(argv[2], NULL);
08498           _v = SWIG_CheckState(res);
08499         }
08500         if (_v) {
08501           return _wrap_UMenuItemExit_render__SWIG_2(nargs, args, self);
08502         }
08503       }
08504     }
08505   }
08506   if (argc == 4) {
08507     int _v;
08508     void *vptr = 0;
08509     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItemExit, 0);
08510     _v = SWIG_CheckState(res);
08511     if (_v) {
08512       {
08513         int res = SWIG_AsVal_float(argv[1], NULL);
08514         _v = SWIG_CheckState(res);
08515       }
08516       if (_v) {
08517         {
08518           int res = SWIG_AsVal_float(argv[2], NULL);
08519           _v = SWIG_CheckState(res);
08520         }
08521         if (_v) {
08522           {
08523             int res = SWIG_AsVal_float(argv[3], NULL);
08524             _v = SWIG_CheckState(res);
08525           }
08526           if (_v) {
08527             return _wrap_UMenuItemExit_render__SWIG_1(nargs, args, self);
08528           }
08529         }
08530       }
08531     }
08532   }
08533   if (argc == 5) {
08534     int _v;
08535     void *vptr = 0;
08536     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItemExit, 0);
08537     _v = SWIG_CheckState(res);
08538     if (_v) {
08539       {
08540         int res = SWIG_AsVal_float(argv[1], NULL);
08541         _v = SWIG_CheckState(res);
08542       }
08543       if (_v) {
08544         {
08545           int res = SWIG_AsVal_float(argv[2], NULL);
08546           _v = SWIG_CheckState(res);
08547         }
08548         if (_v) {
08549           {
08550             int res = SWIG_AsVal_float(argv[3], NULL);
08551             _v = SWIG_CheckState(res);
08552           }
08553           if (_v) {
08554             {
08555               int res = SWIG_AsVal_bool(argv[4], NULL);
08556               _v = SWIG_CheckState(res);
08557             }
08558             if (_v) {
08559               return _wrap_UMenuItemExit_render__SWIG_0(nargs, args, self);
08560             }
08561           }
08562         }
08563       }
08564     }
08565   }
08566   
08567 fail:
08568   rb_raise(rb_eArgError, "No matching function for overloaded 'UMenuItemExit_render'");
08569   return Qnil;
08570 }
08571 
08572 
08573 SWIGINTERN VALUE
08574 _wrap_UMenuItemExit_enter(int argc, VALUE *argv, VALUE self) {
08575   uMenuItemExit *arg1 = (uMenuItemExit *) 0 ;
08576   void *argp1 = 0 ;
08577   int res1 = 0 ;
08578   
08579   if ((argc < 0) || (argc > 0)) {
08580     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
08581   }
08582   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemExit, 0 |  0 );
08583   if (!SWIG_IsOK(res1)) {
08584     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enter" "', argument " "1"" of type '" "uMenuItemExit *""'"); 
08585   }
08586   arg1 = reinterpret_cast< uMenuItemExit * >(argp1);
08587   (arg1)->Enter();
08588   return Qnil;
08589 fail:
08590   return Qnil;
08591 }
08592 
08593 
08594 SWIGINTERN void
08595 free_uMenuItemExit(uMenuItemExit *arg1) {
08596     delete arg1;
08597 }
08598 
08599 swig_class cUMenuItemToggle;
08600 
08601 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
08602 SWIGINTERN VALUE
08603 _wrap_UMenuItemToggle_allocate(VALUE self) {
08604 #else
08605   SWIGINTERN VALUE
08606   _wrap_UMenuItemToggle_allocate(int argc, VALUE *argv, VALUE self) {
08607 #endif
08608     
08609     
08610     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_uMenuItemToggle);
08611 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
08612     rb_obj_call_init(vresult, argc, argv);
08613 #endif
08614     return vresult;
08615   }
08616   
08617 
08618 SWIGINTERN VALUE
08619 _wrap_new_UMenuItemToggle(int argc, VALUE *argv, VALUE self) {
08620   uMenu *arg1 = (uMenu *) 0 ;
08621   tOutput *arg2 = 0 ;
08622   tOutput *arg3 = 0 ;
08623   bool *arg4 = 0 ;
08624   uMenuItemToggle *result = 0 ;
08625   void *argp1 = 0 ;
08626   int res1 = 0 ;
08627   void *argp2 ;
08628   int res2 = 0 ;
08629   void *argp3 ;
08630   int res3 = 0 ;
08631   void *argp4 = 0 ;
08632   int res4 = 0 ;
08633   const char *classname SWIGUNUSED = "Armagetronad::UMenuItemToggle";
08634   
08635   if ((argc < 4) || (argc > 4)) {
08636     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
08637   }
08638   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
08639   if (!SWIG_IsOK(res1)) {
08640     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uMenuItemToggle" "', argument " "1"" of type '" "uMenu *""'"); 
08641   }
08642   arg1 = reinterpret_cast< uMenu * >(argp1);
08643   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_tOutput,  0 );
08644   if (!SWIG_IsOK(res2)) {
08645     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "uMenuItemToggle" "', argument " "2"" of type '" "tOutput const &""'"); 
08646   }
08647   if (!argp2) {
08648     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemToggle" "', argument " "2"" of type '" "tOutput const &""'"); 
08649   }
08650   arg2 = reinterpret_cast< tOutput * >(argp2);
08651   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_tOutput,  0 );
08652   if (!SWIG_IsOK(res3)) {
08653     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "uMenuItemToggle" "', argument " "3"" of type '" "tOutput const &""'"); 
08654   }
08655   if (!argp3) {
08656     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemToggle" "', argument " "3"" of type '" "tOutput const &""'"); 
08657   }
08658   arg3 = reinterpret_cast< tOutput * >(argp3);
08659   res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_bool,  0 );
08660   if (!SWIG_IsOK(res4)) {
08661     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "uMenuItemToggle" "', argument " "4"" of type '" "bool &""'"); 
08662   }
08663   if (!argp4) {
08664     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemToggle" "', argument " "4"" of type '" "bool &""'"); 
08665   }
08666   arg4 = reinterpret_cast< bool * >(argp4);
08667   result = (uMenuItemToggle *)new uMenuItemToggle(arg1,(tOutput const &)*arg2,(tOutput const &)*arg3,*arg4);DATA_PTR(self) = result;
08668   
08669   return self;
08670 fail:
08671   return Qnil;
08672 }
08673 
08674 
08675 SWIGINTERN void
08676 free_uMenuItemToggle(uMenuItemToggle *arg1) {
08677     delete arg1;
08678 }
08679 
08680 SWIGINTERN VALUE
08681 _wrap_UMenuItemToggle_left_right(int argc, VALUE *argv, VALUE self) {
08682   uMenuItemToggle *arg1 = (uMenuItemToggle *) 0 ;
08683   int arg2 ;
08684   void *argp1 = 0 ;
08685   int res1 = 0 ;
08686   int val2 ;
08687   int ecode2 = 0 ;
08688   
08689   if ((argc < 1) || (argc > 1)) {
08690     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
08691   }
08692   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemToggle, 0 |  0 );
08693   if (!SWIG_IsOK(res1)) {
08694     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeftRight" "', argument " "1"" of type '" "uMenuItemToggle *""'"); 
08695   }
08696   arg1 = reinterpret_cast< uMenuItemToggle * >(argp1);
08697   ecode2 = SWIG_AsVal_int(argv[0], &val2);
08698   if (!SWIG_IsOK(ecode2)) {
08699     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LeftRight" "', argument " "2"" of type '" "int""'");
08700   } 
08701   arg2 = static_cast< int >(val2);
08702   (arg1)->LeftRight(arg2);
08703   return Qnil;
08704 fail:
08705   return Qnil;
08706 }
08707 
08708 
08709 SWIGINTERN VALUE
08710 _wrap_UMenuItemToggle_enter(int argc, VALUE *argv, VALUE self) {
08711   uMenuItemToggle *arg1 = (uMenuItemToggle *) 0 ;
08712   void *argp1 = 0 ;
08713   int res1 = 0 ;
08714   
08715   if ((argc < 0) || (argc > 0)) {
08716     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
08717   }
08718   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemToggle, 0 |  0 );
08719   if (!SWIG_IsOK(res1)) {
08720     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enter" "', argument " "1"" of type '" "uMenuItemToggle *""'"); 
08721   }
08722   arg1 = reinterpret_cast< uMenuItemToggle * >(argp1);
08723   (arg1)->Enter();
08724   return Qnil;
08725 fail:
08726   return Qnil;
08727 }
08728 
08729 
08730 swig_class cUMenuItemInt;
08731 
08732 SWIGINTERN VALUE
08733 _wrap_new_UMenuItemInt__SWIG_0(int argc, VALUE *argv, VALUE self) {
08734   uMenu *arg1 = (uMenu *) 0 ;
08735   tOutput *arg2 = 0 ;
08736   tOutput *arg3 = 0 ;
08737   int *arg4 = 0 ;
08738   int arg5 ;
08739   int arg6 ;
08740   int arg7 ;
08741   uMenuItemInt *result = 0 ;
08742   void *argp1 = 0 ;
08743   int res1 = 0 ;
08744   void *argp2 ;
08745   int res2 = 0 ;
08746   void *argp3 ;
08747   int res3 = 0 ;
08748   void *argp4 = 0 ;
08749   int res4 = 0 ;
08750   int val5 ;
08751   int ecode5 = 0 ;
08752   int val6 ;
08753   int ecode6 = 0 ;
08754   int val7 ;
08755   int ecode7 = 0 ;
08756   const char *classname SWIGUNUSED = "Armagetronad::UMenuItemInt";
08757   
08758   if ((argc < 7) || (argc > 7)) {
08759     rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
08760   }
08761   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
08762   if (!SWIG_IsOK(res1)) {
08763     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uMenuItemInt" "', argument " "1"" of type '" "uMenu *""'"); 
08764   }
08765   arg1 = reinterpret_cast< uMenu * >(argp1);
08766   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_tOutput,  0 );
08767   if (!SWIG_IsOK(res2)) {
08768     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "uMenuItemInt" "', argument " "2"" of type '" "tOutput const &""'"); 
08769   }
08770   if (!argp2) {
08771     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemInt" "', argument " "2"" of type '" "tOutput const &""'"); 
08772   }
08773   arg2 = reinterpret_cast< tOutput * >(argp2);
08774   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_tOutput,  0 );
08775   if (!SWIG_IsOK(res3)) {
08776     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "uMenuItemInt" "', argument " "3"" of type '" "tOutput const &""'"); 
08777   }
08778   if (!argp3) {
08779     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemInt" "', argument " "3"" of type '" "tOutput const &""'"); 
08780   }
08781   arg3 = reinterpret_cast< tOutput * >(argp3);
08782   res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_int,  0 );
08783   if (!SWIG_IsOK(res4)) {
08784     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "uMenuItemInt" "', argument " "4"" of type '" "int &""'"); 
08785   }
08786   if (!argp4) {
08787     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemInt" "', argument " "4"" of type '" "int &""'"); 
08788   }
08789   arg4 = reinterpret_cast< int * >(argp4);
08790   ecode5 = SWIG_AsVal_int(argv[4], &val5);
08791   if (!SWIG_IsOK(ecode5)) {
08792     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "uMenuItemInt" "', argument " "5"" of type '" "int""'");
08793   } 
08794   arg5 = static_cast< int >(val5);
08795   ecode6 = SWIG_AsVal_int(argv[5], &val6);
08796   if (!SWIG_IsOK(ecode6)) {
08797     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "uMenuItemInt" "', argument " "6"" of type '" "int""'");
08798   } 
08799   arg6 = static_cast< int >(val6);
08800   ecode7 = SWIG_AsVal_int(argv[6], &val7);
08801   if (!SWIG_IsOK(ecode7)) {
08802     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "uMenuItemInt" "', argument " "7"" of type '" "int""'");
08803   } 
08804   arg7 = static_cast< int >(val7);
08805   result = (uMenuItemInt *)new uMenuItemInt(arg1,(tOutput const &)*arg2,(tOutput const &)*arg3,*arg4,arg5,arg6,arg7);DATA_PTR(self) = result;
08806   
08807   return self;
08808 fail:
08809   return Qnil;
08810 }
08811 
08812 
08813 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
08814 SWIGINTERN VALUE
08815 _wrap_UMenuItemInt_allocate(VALUE self) {
08816 #else
08817   SWIGINTERN VALUE
08818   _wrap_UMenuItemInt_allocate(int argc, VALUE *argv, VALUE self) {
08819 #endif
08820     
08821     
08822     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_uMenuItemInt);
08823 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
08824     rb_obj_call_init(vresult, argc, argv);
08825 #endif
08826     return vresult;
08827   }
08828   
08829 
08830 SWIGINTERN VALUE
08831 _wrap_new_UMenuItemInt__SWIG_1(int argc, VALUE *argv, VALUE self) {
08832   uMenu *arg1 = (uMenu *) 0 ;
08833   tOutput *arg2 = 0 ;
08834   tOutput *arg3 = 0 ;
08835   int *arg4 = 0 ;
08836   int arg5 ;
08837   int arg6 ;
08838   uMenuItemInt *result = 0 ;
08839   void *argp1 = 0 ;
08840   int res1 = 0 ;
08841   void *argp2 ;
08842   int res2 = 0 ;
08843   void *argp3 ;
08844   int res3 = 0 ;
08845   void *argp4 = 0 ;
08846   int res4 = 0 ;
08847   int val5 ;
08848   int ecode5 = 0 ;
08849   int val6 ;
08850   int ecode6 = 0 ;
08851   const char *classname SWIGUNUSED = "Armagetronad::UMenuItemInt";
08852   
08853   if ((argc < 6) || (argc > 6)) {
08854     rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
08855   }
08856   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
08857   if (!SWIG_IsOK(res1)) {
08858     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uMenuItemInt" "', argument " "1"" of type '" "uMenu *""'"); 
08859   }
08860   arg1 = reinterpret_cast< uMenu * >(argp1);
08861   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_tOutput,  0 );
08862   if (!SWIG_IsOK(res2)) {
08863     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "uMenuItemInt" "', argument " "2"" of type '" "tOutput const &""'"); 
08864   }
08865   if (!argp2) {
08866     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemInt" "', argument " "2"" of type '" "tOutput const &""'"); 
08867   }
08868   arg2 = reinterpret_cast< tOutput * >(argp2);
08869   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_tOutput,  0 );
08870   if (!SWIG_IsOK(res3)) {
08871     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "uMenuItemInt" "', argument " "3"" of type '" "tOutput const &""'"); 
08872   }
08873   if (!argp3) {
08874     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemInt" "', argument " "3"" of type '" "tOutput const &""'"); 
08875   }
08876   arg3 = reinterpret_cast< tOutput * >(argp3);
08877   res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_int,  0 );
08878   if (!SWIG_IsOK(res4)) {
08879     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "uMenuItemInt" "', argument " "4"" of type '" "int &""'"); 
08880   }
08881   if (!argp4) {
08882     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemInt" "', argument " "4"" of type '" "int &""'"); 
08883   }
08884   arg4 = reinterpret_cast< int * >(argp4);
08885   ecode5 = SWIG_AsVal_int(argv[4], &val5);
08886   if (!SWIG_IsOK(ecode5)) {
08887     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "uMenuItemInt" "', argument " "5"" of type '" "int""'");
08888   } 
08889   arg5 = static_cast< int >(val5);
08890   ecode6 = SWIG_AsVal_int(argv[5], &val6);
08891   if (!SWIG_IsOK(ecode6)) {
08892     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "uMenuItemInt" "', argument " "6"" of type '" "int""'");
08893   } 
08894   arg6 = static_cast< int >(val6);
08895   result = (uMenuItemInt *)new uMenuItemInt(arg1,(tOutput const &)*arg2,(tOutput const &)*arg3,*arg4,arg5,arg6);DATA_PTR(self) = result;
08896   
08897   return self;
08898 fail:
08899   return Qnil;
08900 }
08901 
08902 
08903 SWIGINTERN VALUE _wrap_new_UMenuItemInt(int nargs, VALUE *args, VALUE self) {
08904   int argc;
08905   VALUE argv[7];
08906   int ii;
08907   
08908   argc = nargs;
08909   if (argc > 7) SWIG_fail;
08910   for (ii = 0; (ii < argc); ii++) {
08911     argv[ii] = args[ii];
08912   }
08913   if (argc == 6) {
08914     int _v;
08915     void *vptr = 0;
08916     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenu, 0);
08917     _v = SWIG_CheckState(res);
08918     if (_v) {
08919       void *vptr = 0;
08920       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_tOutput, 0);
08921       _v = SWIG_CheckState(res);
08922       if (_v) {
08923         void *vptr = 0;
08924         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_tOutput, 0);
08925         _v = SWIG_CheckState(res);
08926         if (_v) {
08927           void *vptr = 0;
08928           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0);
08929           _v = SWIG_CheckState(res);
08930           if (_v) {
08931             {
08932               int res = SWIG_AsVal_int(argv[4], NULL);
08933               _v = SWIG_CheckState(res);
08934             }
08935             if (_v) {
08936               {
08937                 int res = SWIG_AsVal_int(argv[5], NULL);
08938                 _v = SWIG_CheckState(res);
08939               }
08940               if (_v) {
08941                 return _wrap_new_UMenuItemInt__SWIG_1(nargs, args, self);
08942               }
08943             }
08944           }
08945         }
08946       }
08947     }
08948   }
08949   if (argc == 7) {
08950     int _v;
08951     void *vptr = 0;
08952     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenu, 0);
08953     _v = SWIG_CheckState(res);
08954     if (_v) {
08955       void *vptr = 0;
08956       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_tOutput, 0);
08957       _v = SWIG_CheckState(res);
08958       if (_v) {
08959         void *vptr = 0;
08960         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_tOutput, 0);
08961         _v = SWIG_CheckState(res);
08962         if (_v) {
08963           void *vptr = 0;
08964           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0);
08965           _v = SWIG_CheckState(res);
08966           if (_v) {
08967             {
08968               int res = SWIG_AsVal_int(argv[4], NULL);
08969               _v = SWIG_CheckState(res);
08970             }
08971             if (_v) {
08972               {
08973                 int res = SWIG_AsVal_int(argv[5], NULL);
08974                 _v = SWIG_CheckState(res);
08975               }
08976               if (_v) {
08977                 {
08978                   int res = SWIG_AsVal_int(argv[6], NULL);
08979                   _v = SWIG_CheckState(res);
08980                 }
08981                 if (_v) {
08982                   return _wrap_new_UMenuItemInt__SWIG_0(nargs, args, self);
08983                 }
08984               }
08985             }
08986           }
08987         }
08988       }
08989     }
08990   }
08991   
08992 fail:
08993   rb_raise(rb_eArgError, "No matching function for overloaded 'new_UMenuItemInt'");
08994   return Qnil;
08995 }
08996 
08997 
08998 SWIGINTERN void
08999 free_uMenuItemInt(uMenuItemInt *arg1) {
09000     delete arg1;
09001 }
09002 
09003 SWIGINTERN VALUE
09004 _wrap_UMenuItemInt_left_right(int argc, VALUE *argv, VALUE self) {
09005   uMenuItemInt *arg1 = (uMenuItemInt *) 0 ;
09006   int arg2 ;
09007   void *argp1 = 0 ;
09008   int res1 = 0 ;
09009   int val2 ;
09010   int ecode2 = 0 ;
09011   
09012   if ((argc < 1) || (argc > 1)) {
09013     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
09014   }
09015   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemInt, 0 |  0 );
09016   if (!SWIG_IsOK(res1)) {
09017     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LeftRight" "', argument " "1"" of type '" "uMenuItemInt *""'"); 
09018   }
09019   arg1 = reinterpret_cast< uMenuItemInt * >(argp1);
09020   ecode2 = SWIG_AsVal_int(argv[0], &val2);
09021   if (!SWIG_IsOK(ecode2)) {
09022     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LeftRight" "', argument " "2"" of type '" "int""'");
09023   } 
09024   arg2 = static_cast< int >(val2);
09025   (arg1)->LeftRight(arg2);
09026   return Qnil;
09027 fail:
09028   return Qnil;
09029 }
09030 
09031 
09032 SWIGINTERN VALUE
09033 _wrap_UMenuItemInt_render__SWIG_0(int argc, VALUE *argv, VALUE self) {
09034   uMenuItemInt *arg1 = (uMenuItemInt *) 0 ;
09035   REAL arg2 ;
09036   REAL arg3 ;
09037   REAL arg4 ;
09038   bool arg5 ;
09039   void *argp1 = 0 ;
09040   int res1 = 0 ;
09041   float val2 ;
09042   int ecode2 = 0 ;
09043   float val3 ;
09044   int ecode3 = 0 ;
09045   float val4 ;
09046   int ecode4 = 0 ;
09047   bool val5 ;
09048   int ecode5 = 0 ;
09049   
09050   if ((argc < 4) || (argc > 4)) {
09051     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
09052   }
09053   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemInt, 0 |  0 );
09054   if (!SWIG_IsOK(res1)) {
09055     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItemInt *""'"); 
09056   }
09057   arg1 = reinterpret_cast< uMenuItemInt * >(argp1);
09058   ecode2 = SWIG_AsVal_float(argv[0], &val2);
09059   if (!SWIG_IsOK(ecode2)) {
09060     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
09061   } 
09062   arg2 = static_cast< REAL >(val2);
09063   ecode3 = SWIG_AsVal_float(argv[1], &val3);
09064   if (!SWIG_IsOK(ecode3)) {
09065     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
09066   } 
09067   arg3 = static_cast< REAL >(val3);
09068   ecode4 = SWIG_AsVal_float(argv[2], &val4);
09069   if (!SWIG_IsOK(ecode4)) {
09070     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Render" "', argument " "4"" of type '" "REAL""'");
09071   } 
09072   arg4 = static_cast< REAL >(val4);
09073   ecode5 = SWIG_AsVal_bool(argv[3], &val5);
09074   if (!SWIG_IsOK(ecode5)) {
09075     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Render" "', argument " "5"" of type '" "bool""'");
09076   } 
09077   arg5 = static_cast< bool >(val5);
09078   (arg1)->Render(arg2,arg3,arg4,arg5);
09079   return Qnil;
09080 fail:
09081   return Qnil;
09082 }
09083 
09084 
09085 SWIGINTERN VALUE
09086 _wrap_UMenuItemInt_render__SWIG_1(int argc, VALUE *argv, VALUE self) {
09087   uMenuItemInt *arg1 = (uMenuItemInt *) 0 ;
09088   REAL arg2 ;
09089   REAL arg3 ;
09090   REAL arg4 ;
09091   void *argp1 = 0 ;
09092   int res1 = 0 ;
09093   float val2 ;
09094   int ecode2 = 0 ;
09095   float val3 ;
09096   int ecode3 = 0 ;
09097   float val4 ;
09098   int ecode4 = 0 ;
09099   
09100   if ((argc < 3) || (argc > 3)) {
09101     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
09102   }
09103   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemInt, 0 |  0 );
09104   if (!SWIG_IsOK(res1)) {
09105     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItemInt *""'"); 
09106   }
09107   arg1 = reinterpret_cast< uMenuItemInt * >(argp1);
09108   ecode2 = SWIG_AsVal_float(argv[0], &val2);
09109   if (!SWIG_IsOK(ecode2)) {
09110     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
09111   } 
09112   arg2 = static_cast< REAL >(val2);
09113   ecode3 = SWIG_AsVal_float(argv[1], &val3);
09114   if (!SWIG_IsOK(ecode3)) {
09115     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
09116   } 
09117   arg3 = static_cast< REAL >(val3);
09118   ecode4 = SWIG_AsVal_float(argv[2], &val4);
09119   if (!SWIG_IsOK(ecode4)) {
09120     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Render" "', argument " "4"" of type '" "REAL""'");
09121   } 
09122   arg4 = static_cast< REAL >(val4);
09123   (arg1)->Render(arg2,arg3,arg4);
09124   return Qnil;
09125 fail:
09126   return Qnil;
09127 }
09128 
09129 
09130 SWIGINTERN VALUE
09131 _wrap_UMenuItemInt_render__SWIG_2(int argc, VALUE *argv, VALUE self) {
09132   uMenuItemInt *arg1 = (uMenuItemInt *) 0 ;
09133   REAL arg2 ;
09134   REAL arg3 ;
09135   void *argp1 = 0 ;
09136   int res1 = 0 ;
09137   float val2 ;
09138   int ecode2 = 0 ;
09139   float val3 ;
09140   int ecode3 = 0 ;
09141   
09142   if ((argc < 2) || (argc > 2)) {
09143     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
09144   }
09145   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemInt, 0 |  0 );
09146   if (!SWIG_IsOK(res1)) {
09147     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItemInt *""'"); 
09148   }
09149   arg1 = reinterpret_cast< uMenuItemInt * >(argp1);
09150   ecode2 = SWIG_AsVal_float(argv[0], &val2);
09151   if (!SWIG_IsOK(ecode2)) {
09152     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
09153   } 
09154   arg2 = static_cast< REAL >(val2);
09155   ecode3 = SWIG_AsVal_float(argv[1], &val3);
09156   if (!SWIG_IsOK(ecode3)) {
09157     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
09158   } 
09159   arg3 = static_cast< REAL >(val3);
09160   (arg1)->Render(arg2,arg3);
09161   return Qnil;
09162 fail:
09163   return Qnil;
09164 }
09165 
09166 
09167 SWIGINTERN VALUE _wrap_UMenuItemInt_render(int nargs, VALUE *args, VALUE self) {
09168   int argc;
09169   VALUE argv[6];
09170   int ii;
09171   
09172   argc = nargs + 1;
09173   argv[0] = self;
09174   if (argc > 6) SWIG_fail;
09175   for (ii = 1; (ii < argc); ii++) {
09176     argv[ii] = args[ii-1];
09177   }
09178   if (argc == 3) {
09179     int _v;
09180     void *vptr = 0;
09181     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItemInt, 0);
09182     _v = SWIG_CheckState(res);
09183     if (_v) {
09184       {
09185         int res = SWIG_AsVal_float(argv[1], NULL);
09186         _v = SWIG_CheckState(res);
09187       }
09188       if (_v) {
09189         {
09190           int res = SWIG_AsVal_float(argv[2], NULL);
09191           _v = SWIG_CheckState(res);
09192         }
09193         if (_v) {
09194           return _wrap_UMenuItemInt_render__SWIG_2(nargs, args, self);
09195         }
09196       }
09197     }
09198   }
09199   if (argc == 4) {
09200     int _v;
09201     void *vptr = 0;
09202     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItemInt, 0);
09203     _v = SWIG_CheckState(res);
09204     if (_v) {
09205       {
09206         int res = SWIG_AsVal_float(argv[1], NULL);
09207         _v = SWIG_CheckState(res);
09208       }
09209       if (_v) {
09210         {
09211           int res = SWIG_AsVal_float(argv[2], NULL);
09212           _v = SWIG_CheckState(res);
09213         }
09214         if (_v) {
09215           {
09216             int res = SWIG_AsVal_float(argv[3], NULL);
09217             _v = SWIG_CheckState(res);
09218           }
09219           if (_v) {
09220             return _wrap_UMenuItemInt_render__SWIG_1(nargs, args, self);
09221           }
09222         }
09223       }
09224     }
09225   }
09226   if (argc == 5) {
09227     int _v;
09228     void *vptr = 0;
09229     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItemInt, 0);
09230     _v = SWIG_CheckState(res);
09231     if (_v) {
09232       {
09233         int res = SWIG_AsVal_float(argv[1], NULL);
09234         _v = SWIG_CheckState(res);
09235       }
09236       if (_v) {
09237         {
09238           int res = SWIG_AsVal_float(argv[2], NULL);
09239           _v = SWIG_CheckState(res);
09240         }
09241         if (_v) {
09242           {
09243             int res = SWIG_AsVal_float(argv[3], NULL);
09244             _v = SWIG_CheckState(res);
09245           }
09246           if (_v) {
09247             {
09248               int res = SWIG_AsVal_bool(argv[4], NULL);
09249               _v = SWIG_CheckState(res);
09250             }
09251             if (_v) {
09252               return _wrap_UMenuItemInt_render__SWIG_0(nargs, args, self);
09253             }
09254           }
09255         }
09256       }
09257     }
09258   }
09259   
09260 fail:
09261   rb_raise(rb_eArgError, "No matching function for overloaded 'UMenuItemInt_render'");
09262   return Qnil;
09263 }
09264 
09265 
09266 swig_class cUMenuItemString;
09267 
09268 SWIGINTERN VALUE
09269 _wrap_new_UMenuItemString__SWIG_0(int argc, VALUE *argv, VALUE self) {
09270   uMenu *arg1 = (uMenu *) 0 ;
09271   tOutput *arg2 = 0 ;
09272   tOutput *arg3 = 0 ;
09273   tString *arg4 = 0 ;
09274   int arg5 ;
09275   uMenuItemString *result = 0 ;
09276   void *argp1 = 0 ;
09277   int res1 = 0 ;
09278   void *argp2 ;
09279   int res2 = 0 ;
09280   void *argp3 ;
09281   int res3 = 0 ;
09282   void *argp4 = 0 ;
09283   int res4 = 0 ;
09284   int val5 ;
09285   int ecode5 = 0 ;
09286   const char *classname SWIGUNUSED = "Armagetronad::UMenuItemString";
09287   
09288   if ((argc < 5) || (argc > 5)) {
09289     rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
09290   }
09291   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
09292   if (!SWIG_IsOK(res1)) {
09293     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uMenuItemString" "', argument " "1"" of type '" "uMenu *""'"); 
09294   }
09295   arg1 = reinterpret_cast< uMenu * >(argp1);
09296   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_tOutput,  0 );
09297   if (!SWIG_IsOK(res2)) {
09298     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "uMenuItemString" "', argument " "2"" of type '" "tOutput const &""'"); 
09299   }
09300   if (!argp2) {
09301     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemString" "', argument " "2"" of type '" "tOutput const &""'"); 
09302   }
09303   arg2 = reinterpret_cast< tOutput * >(argp2);
09304   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_tOutput,  0 );
09305   if (!SWIG_IsOK(res3)) {
09306     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "uMenuItemString" "', argument " "3"" of type '" "tOutput const &""'"); 
09307   }
09308   if (!argp3) {
09309     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemString" "', argument " "3"" of type '" "tOutput const &""'"); 
09310   }
09311   arg3 = reinterpret_cast< tOutput * >(argp3);
09312   res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_tString,  0 );
09313   if (!SWIG_IsOK(res4)) {
09314     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "uMenuItemString" "', argument " "4"" of type '" "tString &""'"); 
09315   }
09316   if (!argp4) {
09317     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemString" "', argument " "4"" of type '" "tString &""'"); 
09318   }
09319   arg4 = reinterpret_cast< tString * >(argp4);
09320   ecode5 = SWIG_AsVal_int(argv[4], &val5);
09321   if (!SWIG_IsOK(ecode5)) {
09322     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "uMenuItemString" "', argument " "5"" of type '" "int""'");
09323   } 
09324   arg5 = static_cast< int >(val5);
09325   result = (uMenuItemString *)new uMenuItemString(arg1,(tOutput const &)*arg2,(tOutput const &)*arg3,*arg4,arg5);DATA_PTR(self) = result;
09326   
09327   return self;
09328 fail:
09329   return Qnil;
09330 }
09331 
09332 
09333 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
09334 SWIGINTERN VALUE
09335 _wrap_UMenuItemString_allocate(VALUE self) {
09336 #else
09337   SWIGINTERN VALUE
09338   _wrap_UMenuItemString_allocate(int argc, VALUE *argv, VALUE self) {
09339 #endif
09340     
09341     
09342     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_uMenuItemString);
09343 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
09344     rb_obj_call_init(vresult, argc, argv);
09345 #endif
09346     return vresult;
09347   }
09348   
09349 
09350 SWIGINTERN VALUE
09351 _wrap_new_UMenuItemString__SWIG_1(int argc, VALUE *argv, VALUE self) {
09352   uMenu *arg1 = (uMenu *) 0 ;
09353   tOutput *arg2 = 0 ;
09354   tOutput *arg3 = 0 ;
09355   tString *arg4 = 0 ;
09356   uMenuItemString *result = 0 ;
09357   void *argp1 = 0 ;
09358   int res1 = 0 ;
09359   void *argp2 ;
09360   int res2 = 0 ;
09361   void *argp3 ;
09362   int res3 = 0 ;
09363   void *argp4 = 0 ;
09364   int res4 = 0 ;
09365   const char *classname SWIGUNUSED = "Armagetronad::UMenuItemString";
09366   
09367   if ((argc < 4) || (argc > 4)) {
09368     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
09369   }
09370   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
09371   if (!SWIG_IsOK(res1)) {
09372     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uMenuItemString" "', argument " "1"" of type '" "uMenu *""'"); 
09373   }
09374   arg1 = reinterpret_cast< uMenu * >(argp1);
09375   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_tOutput,  0 );
09376   if (!SWIG_IsOK(res2)) {
09377     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "uMenuItemString" "', argument " "2"" of type '" "tOutput const &""'"); 
09378   }
09379   if (!argp2) {
09380     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemString" "', argument " "2"" of type '" "tOutput const &""'"); 
09381   }
09382   arg2 = reinterpret_cast< tOutput * >(argp2);
09383   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_tOutput,  0 );
09384   if (!SWIG_IsOK(res3)) {
09385     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "uMenuItemString" "', argument " "3"" of type '" "tOutput const &""'"); 
09386   }
09387   if (!argp3) {
09388     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemString" "', argument " "3"" of type '" "tOutput const &""'"); 
09389   }
09390   arg3 = reinterpret_cast< tOutput * >(argp3);
09391   res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_tString,  0 );
09392   if (!SWIG_IsOK(res4)) {
09393     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "uMenuItemString" "', argument " "4"" of type '" "tString &""'"); 
09394   }
09395   if (!argp4) {
09396     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemString" "', argument " "4"" of type '" "tString &""'"); 
09397   }
09398   arg4 = reinterpret_cast< tString * >(argp4);
09399   result = (uMenuItemString *)new uMenuItemString(arg1,(tOutput const &)*arg2,(tOutput const &)*arg3,*arg4);DATA_PTR(self) = result;
09400   
09401   return self;
09402 fail:
09403   return Qnil;
09404 }
09405 
09406 
09407 SWIGINTERN VALUE _wrap_new_UMenuItemString(int nargs, VALUE *args, VALUE self) {
09408   int argc;
09409   VALUE argv[5];
09410   int ii;
09411   
09412   argc = nargs;
09413   if (argc > 5) SWIG_fail;
09414   for (ii = 0; (ii < argc); ii++) {
09415     argv[ii] = args[ii];
09416   }
09417   if (argc == 4) {
09418     int _v;
09419     void *vptr = 0;
09420     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenu, 0);
09421     _v = SWIG_CheckState(res);
09422     if (_v) {
09423       void *vptr = 0;
09424       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_tOutput, 0);
09425       _v = SWIG_CheckState(res);
09426       if (_v) {
09427         void *vptr = 0;
09428         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_tOutput, 0);
09429         _v = SWIG_CheckState(res);
09430         if (_v) {
09431           void *vptr = 0;
09432           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_tString, 0);
09433           _v = SWIG_CheckState(res);
09434           if (_v) {
09435             return _wrap_new_UMenuItemString__SWIG_1(nargs, args, self);
09436           }
09437         }
09438       }
09439     }
09440   }
09441   if (argc == 5) {
09442     int _v;
09443     void *vptr = 0;
09444     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenu, 0);
09445     _v = SWIG_CheckState(res);
09446     if (_v) {
09447       void *vptr = 0;
09448       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_tOutput, 0);
09449       _v = SWIG_CheckState(res);
09450       if (_v) {
09451         void *vptr = 0;
09452         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_tOutput, 0);
09453         _v = SWIG_CheckState(res);
09454         if (_v) {
09455           void *vptr = 0;
09456           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_tString, 0);
09457           _v = SWIG_CheckState(res);
09458           if (_v) {
09459             {
09460               int res = SWIG_AsVal_int(argv[4], NULL);
09461               _v = SWIG_CheckState(res);
09462             }
09463             if (_v) {
09464               return _wrap_new_UMenuItemString__SWIG_0(nargs, args, self);
09465             }
09466           }
09467         }
09468       }
09469     }
09470   }
09471   
09472 fail:
09473   rb_raise(rb_eArgError, "No matching function for overloaded 'new_UMenuItemString'");
09474   return Qnil;
09475 }
09476 
09477 
09478 SWIGINTERN void
09479 free_uMenuItemString(uMenuItemString *arg1) {
09480     delete arg1;
09481 }
09482 
09483 SWIGINTERN VALUE
09484 _wrap_UMenuItemString_render__SWIG_0(int argc, VALUE *argv, VALUE self) {
09485   uMenuItemString *arg1 = (uMenuItemString *) 0 ;
09486   REAL arg2 ;
09487   REAL arg3 ;
09488   REAL arg4 ;
09489   bool arg5 ;
09490   void *argp1 = 0 ;
09491   int res1 = 0 ;
09492   float val2 ;
09493   int ecode2 = 0 ;
09494   float val3 ;
09495   int ecode3 = 0 ;
09496   float val4 ;
09497   int ecode4 = 0 ;
09498   bool val5 ;
09499   int ecode5 = 0 ;
09500   
09501   if ((argc < 4) || (argc > 4)) {
09502     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
09503   }
09504   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemString, 0 |  0 );
09505   if (!SWIG_IsOK(res1)) {
09506     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItemString *""'"); 
09507   }
09508   arg1 = reinterpret_cast< uMenuItemString * >(argp1);
09509   ecode2 = SWIG_AsVal_float(argv[0], &val2);
09510   if (!SWIG_IsOK(ecode2)) {
09511     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
09512   } 
09513   arg2 = static_cast< REAL >(val2);
09514   ecode3 = SWIG_AsVal_float(argv[1], &val3);
09515   if (!SWIG_IsOK(ecode3)) {
09516     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
09517   } 
09518   arg3 = static_cast< REAL >(val3);
09519   ecode4 = SWIG_AsVal_float(argv[2], &val4);
09520   if (!SWIG_IsOK(ecode4)) {
09521     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Render" "', argument " "4"" of type '" "REAL""'");
09522   } 
09523   arg4 = static_cast< REAL >(val4);
09524   ecode5 = SWIG_AsVal_bool(argv[3], &val5);
09525   if (!SWIG_IsOK(ecode5)) {
09526     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Render" "', argument " "5"" of type '" "bool""'");
09527   } 
09528   arg5 = static_cast< bool >(val5);
09529   (arg1)->Render(arg2,arg3,arg4,arg5);
09530   return Qnil;
09531 fail:
09532   return Qnil;
09533 }
09534 
09535 
09536 SWIGINTERN VALUE
09537 _wrap_UMenuItemString_render__SWIG_1(int argc, VALUE *argv, VALUE self) {
09538   uMenuItemString *arg1 = (uMenuItemString *) 0 ;
09539   REAL arg2 ;
09540   REAL arg3 ;
09541   REAL arg4 ;
09542   void *argp1 = 0 ;
09543   int res1 = 0 ;
09544   float val2 ;
09545   int ecode2 = 0 ;
09546   float val3 ;
09547   int ecode3 = 0 ;
09548   float val4 ;
09549   int ecode4 = 0 ;
09550   
09551   if ((argc < 3) || (argc > 3)) {
09552     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
09553   }
09554   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemString, 0 |  0 );
09555   if (!SWIG_IsOK(res1)) {
09556     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItemString *""'"); 
09557   }
09558   arg1 = reinterpret_cast< uMenuItemString * >(argp1);
09559   ecode2 = SWIG_AsVal_float(argv[0], &val2);
09560   if (!SWIG_IsOK(ecode2)) {
09561     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
09562   } 
09563   arg2 = static_cast< REAL >(val2);
09564   ecode3 = SWIG_AsVal_float(argv[1], &val3);
09565   if (!SWIG_IsOK(ecode3)) {
09566     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
09567   } 
09568   arg3 = static_cast< REAL >(val3);
09569   ecode4 = SWIG_AsVal_float(argv[2], &val4);
09570   if (!SWIG_IsOK(ecode4)) {
09571     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Render" "', argument " "4"" of type '" "REAL""'");
09572   } 
09573   arg4 = static_cast< REAL >(val4);
09574   (arg1)->Render(arg2,arg3,arg4);
09575   return Qnil;
09576 fail:
09577   return Qnil;
09578 }
09579 
09580 
09581 SWIGINTERN VALUE
09582 _wrap_UMenuItemString_render__SWIG_2(int argc, VALUE *argv, VALUE self) {
09583   uMenuItemString *arg1 = (uMenuItemString *) 0 ;
09584   REAL arg2 ;
09585   REAL arg3 ;
09586   void *argp1 = 0 ;
09587   int res1 = 0 ;
09588   float val2 ;
09589   int ecode2 = 0 ;
09590   float val3 ;
09591   int ecode3 = 0 ;
09592   
09593   if ((argc < 2) || (argc > 2)) {
09594     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
09595   }
09596   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemString, 0 |  0 );
09597   if (!SWIG_IsOK(res1)) {
09598     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItemString *""'"); 
09599   }
09600   arg1 = reinterpret_cast< uMenuItemString * >(argp1);
09601   ecode2 = SWIG_AsVal_float(argv[0], &val2);
09602   if (!SWIG_IsOK(ecode2)) {
09603     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
09604   } 
09605   arg2 = static_cast< REAL >(val2);
09606   ecode3 = SWIG_AsVal_float(argv[1], &val3);
09607   if (!SWIG_IsOK(ecode3)) {
09608     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
09609   } 
09610   arg3 = static_cast< REAL >(val3);
09611   (arg1)->Render(arg2,arg3);
09612   return Qnil;
09613 fail:
09614   return Qnil;
09615 }
09616 
09617 
09618 SWIGINTERN VALUE _wrap_UMenuItemString_render(int nargs, VALUE *args, VALUE self) {
09619   int argc;
09620   VALUE argv[6];
09621   int ii;
09622   
09623   argc = nargs + 1;
09624   argv[0] = self;
09625   if (argc > 6) SWIG_fail;
09626   for (ii = 1; (ii < argc); ii++) {
09627     argv[ii] = args[ii-1];
09628   }
09629   if (argc == 3) {
09630     int _v;
09631     void *vptr = 0;
09632     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItemString, 0);
09633     _v = SWIG_CheckState(res);
09634     if (_v) {
09635       {
09636         int res = SWIG_AsVal_float(argv[1], NULL);
09637         _v = SWIG_CheckState(res);
09638       }
09639       if (_v) {
09640         {
09641           int res = SWIG_AsVal_float(argv[2], NULL);
09642           _v = SWIG_CheckState(res);
09643         }
09644         if (_v) {
09645           return _wrap_UMenuItemString_render__SWIG_2(nargs, args, self);
09646         }
09647       }
09648     }
09649   }
09650   if (argc == 4) {
09651     int _v;
09652     void *vptr = 0;
09653     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItemString, 0);
09654     _v = SWIG_CheckState(res);
09655     if (_v) {
09656       {
09657         int res = SWIG_AsVal_float(argv[1], NULL);
09658         _v = SWIG_CheckState(res);
09659       }
09660       if (_v) {
09661         {
09662           int res = SWIG_AsVal_float(argv[2], NULL);
09663           _v = SWIG_CheckState(res);
09664         }
09665         if (_v) {
09666           {
09667             int res = SWIG_AsVal_float(argv[3], NULL);
09668             _v = SWIG_CheckState(res);
09669           }
09670           if (_v) {
09671             return _wrap_UMenuItemString_render__SWIG_1(nargs, args, self);
09672           }
09673         }
09674       }
09675     }
09676   }
09677   if (argc == 5) {
09678     int _v;
09679     void *vptr = 0;
09680     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItemString, 0);
09681     _v = SWIG_CheckState(res);
09682     if (_v) {
09683       {
09684         int res = SWIG_AsVal_float(argv[1], NULL);
09685         _v = SWIG_CheckState(res);
09686       }
09687       if (_v) {
09688         {
09689           int res = SWIG_AsVal_float(argv[2], NULL);
09690           _v = SWIG_CheckState(res);
09691         }
09692         if (_v) {
09693           {
09694             int res = SWIG_AsVal_float(argv[3], NULL);
09695             _v = SWIG_CheckState(res);
09696           }
09697           if (_v) {
09698             {
09699               int res = SWIG_AsVal_bool(argv[4], NULL);
09700               _v = SWIG_CheckState(res);
09701             }
09702             if (_v) {
09703               return _wrap_UMenuItemString_render__SWIG_0(nargs, args, self);
09704             }
09705           }
09706         }
09707       }
09708     }
09709   }
09710   
09711 fail:
09712   rb_raise(rb_eArgError, "No matching function for overloaded 'UMenuItemString_render'");
09713   return Qnil;
09714 }
09715 
09716 
09717 SWIGINTERN VALUE
09718 _wrap_UMenuItemString_event(int argc, VALUE *argv, VALUE self) {
09719   uMenuItemString *arg1 = (uMenuItemString *) 0 ;
09720   SDL_Event *arg2 = 0 ;
09721   bool result;
09722   void *argp1 = 0 ;
09723   int res1 = 0 ;
09724   void *argp2 = 0 ;
09725   int res2 = 0 ;
09726   VALUE vresult = Qnil;
09727   
09728   if ((argc < 1) || (argc > 1)) {
09729     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
09730   }
09731   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemString, 0 |  0 );
09732   if (!SWIG_IsOK(res1)) {
09733     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event" "', argument " "1"" of type '" "uMenuItemString *""'"); 
09734   }
09735   arg1 = reinterpret_cast< uMenuItemString * >(argp1);
09736   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_SDL_Event,  0 );
09737   if (!SWIG_IsOK(res2)) {
09738     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event" "', argument " "2"" of type '" "SDL_Event &""'"); 
09739   }
09740   if (!argp2) {
09741     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Event" "', argument " "2"" of type '" "SDL_Event &""'"); 
09742   }
09743   arg2 = reinterpret_cast< SDL_Event * >(argp2);
09744   result = (bool)(arg1)->Event(*arg2);
09745   vresult = SWIG_From_bool(static_cast< bool >(result));
09746   return vresult;
09747 fail:
09748   return Qnil;
09749 }
09750 
09751 
09752 SWIGINTERN VALUE
09753 _wrap_UMenuItemString_my_menu(int argc, VALUE *argv, VALUE self) {
09754   uMenuItemString *arg1 = (uMenuItemString *) 0 ;
09755   uMenu *result = 0 ;
09756   void *argp1 = 0 ;
09757   int res1 = 0 ;
09758   VALUE vresult = Qnil;
09759   
09760   if ((argc < 0) || (argc > 0)) {
09761     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
09762   }
09763   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemString, 0 |  0 );
09764   if (!SWIG_IsOK(res1)) {
09765     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MyMenu" "', argument " "1"" of type '" "uMenuItemString *""'"); 
09766   }
09767   arg1 = reinterpret_cast< uMenuItemString * >(argp1);
09768   result = (uMenu *)(arg1)->MyMenu();
09769   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_uMenu, 0 |  0 );
09770   return vresult;
09771 fail:
09772   return Qnil;
09773 }
09774 
09775 
09776 swig_class cUAutoCompleter;
09777 
09778 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
09779 SWIGINTERN VALUE
09780 _wrap_UAutoCompleter_allocate(VALUE self) {
09781 #else
09782   SWIGINTERN VALUE
09783   _wrap_UAutoCompleter_allocate(int argc, VALUE *argv, VALUE self) {
09784 #endif
09785     
09786     
09787     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_uAutoCompleter);
09788 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
09789     rb_obj_call_init(vresult, argc, argv);
09790 #endif
09791     return vresult;
09792   }
09793   
09794 
09795 SWIGINTERN VALUE
09796 _wrap_new_UAutoCompleter(int argc, VALUE *argv, VALUE self) {
09797   std::deque<tString > *arg1 = 0 ;
09798   uAutoCompleter *result = 0 ;
09799   void *argp1 = 0 ;
09800   int res1 = 0 ;
09801   const char *classname SWIGUNUSED = "Armagetronad::UAutoCompleter";
09802   
09803   if ((argc < 1) || (argc > 1)) {
09804     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
09805   }
09806   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_std__dequeTtString_t,  0 );
09807   if (!SWIG_IsOK(res1)) {
09808     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uAutoCompleter" "', argument " "1"" of type '" "std::deque<tString > &""'"); 
09809   }
09810   if (!argp1) {
09811     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uAutoCompleter" "', argument " "1"" of type '" "std::deque<tString > &""'"); 
09812   }
09813   arg1 = reinterpret_cast< std::deque<tString > * >(argp1);
09814   result = (uAutoCompleter *)new uAutoCompleter(*arg1);DATA_PTR(self) = result;
09815   
09816   return self;
09817 fail:
09818   return Qnil;
09819 }
09820 
09821 
09822 SWIGINTERN VALUE
09823 _wrap_UAutoCompleter_complete(int argc, VALUE *argv, VALUE self) {
09824   uAutoCompleter *arg1 = (uAutoCompleter *) 0 ;
09825   tString *arg2 = 0 ;
09826   unsigned int arg3 ;
09827   int result;
09828   void *argp1 = 0 ;
09829   int res1 = 0 ;
09830   void *argp2 = 0 ;
09831   int res2 = 0 ;
09832   unsigned int val3 ;
09833   int ecode3 = 0 ;
09834   VALUE vresult = Qnil;
09835   
09836   if ((argc < 2) || (argc > 2)) {
09837     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
09838   }
09839   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uAutoCompleter, 0 |  0 );
09840   if (!SWIG_IsOK(res1)) {
09841     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Complete" "', argument " "1"" of type '" "uAutoCompleter *""'"); 
09842   }
09843   arg1 = reinterpret_cast< uAutoCompleter * >(argp1);
09844   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_tString,  0 );
09845   if (!SWIG_IsOK(res2)) {
09846     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Complete" "', argument " "2"" of type '" "tString &""'"); 
09847   }
09848   if (!argp2) {
09849     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Complete" "', argument " "2"" of type '" "tString &""'"); 
09850   }
09851   arg2 = reinterpret_cast< tString * >(argp2);
09852   ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
09853   if (!SWIG_IsOK(ecode3)) {
09854     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Complete" "', argument " "3"" of type '" "unsigned int""'");
09855   } 
09856   arg3 = static_cast< unsigned int >(val3);
09857   result = (int)(arg1)->Complete(*arg2,arg3);
09858   vresult = SWIG_From_int(static_cast< int >(result));
09859   return vresult;
09860 fail:
09861   return Qnil;
09862 }
09863 
09864 
09865 SWIGINTERN void
09866 free_uAutoCompleter(uAutoCompleter *arg1) {
09867     delete arg1;
09868 }
09869 
09870 SWIGINTERN VALUE
09871 _wrap_UAutoCompleter_set_ignorecase(int argc, VALUE *argv, VALUE self) {
09872   uAutoCompleter *arg1 = (uAutoCompleter *) 0 ;
09873   bool arg2 ;
09874   void *argp1 = 0 ;
09875   int res1 = 0 ;
09876   bool val2 ;
09877   int ecode2 = 0 ;
09878   
09879   if ((argc < 1) || (argc > 1)) {
09880     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
09881   }
09882   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uAutoCompleter, 0 |  0 );
09883   if (!SWIG_IsOK(res1)) {
09884     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetIgnorecase" "', argument " "1"" of type '" "uAutoCompleter *""'"); 
09885   }
09886   arg1 = reinterpret_cast< uAutoCompleter * >(argp1);
09887   ecode2 = SWIG_AsVal_bool(argv[0], &val2);
09888   if (!SWIG_IsOK(ecode2)) {
09889     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetIgnorecase" "', argument " "2"" of type '" "bool""'");
09890   } 
09891   arg2 = static_cast< bool >(val2);
09892   (arg1)->SetIgnorecase(arg2);
09893   return Qnil;
09894 fail:
09895   return Qnil;
09896 }
09897 
09898 
09899 swig_class cUMenuItemSubmenu;
09900 
09901 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
09902 SWIGINTERN VALUE
09903 _wrap_UMenuItemSubmenu_allocate(VALUE self) {
09904 #else
09905   SWIGINTERN VALUE
09906   _wrap_UMenuItemSubmenu_allocate(int argc, VALUE *argv, VALUE self) {
09907 #endif
09908     
09909     
09910     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_uMenuItemSubmenu);
09911 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
09912     rb_obj_call_init(vresult, argc, argv);
09913 #endif
09914     return vresult;
09915   }
09916   
09917 
09918 SWIGINTERN VALUE
09919 _wrap_new_UMenuItemSubmenu(int argc, VALUE *argv, VALUE self) {
09920   uMenu *arg1 = (uMenu *) 0 ;
09921   uMenu *arg2 = (uMenu *) 0 ;
09922   tOutput *arg3 = 0 ;
09923   uMenuItemSubmenu *result = 0 ;
09924   void *argp1 = 0 ;
09925   int res1 = 0 ;
09926   void *argp2 = 0 ;
09927   int res2 = 0 ;
09928   void *argp3 ;
09929   int res3 = 0 ;
09930   const char *classname SWIGUNUSED = "Armagetronad::UMenuItemSubmenu";
09931   
09932   if ((argc < 3) || (argc > 3)) {
09933     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
09934   }
09935   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_uMenu, 0 |  0 );
09936   if (!SWIG_IsOK(res1)) {
09937     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uMenuItemSubmenu" "', argument " "1"" of type '" "uMenu *""'"); 
09938   }
09939   arg1 = reinterpret_cast< uMenu * >(argp1);
09940   res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_uMenu, 0 |  0 );
09941   if (!SWIG_IsOK(res2)) {
09942     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "uMenuItemSubmenu" "', argument " "2"" of type '" "uMenu *""'"); 
09943   }
09944   arg2 = reinterpret_cast< uMenu * >(argp2);
09945   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_tOutput,  0 );
09946   if (!SWIG_IsOK(res3)) {
09947     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "uMenuItemSubmenu" "', argument " "3"" of type '" "tOutput const &""'"); 
09948   }
09949   if (!argp3) {
09950     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemSubmenu" "', argument " "3"" of type '" "tOutput const &""'"); 
09951   }
09952   arg3 = reinterpret_cast< tOutput * >(argp3);
09953   result = (uMenuItemSubmenu *)new uMenuItemSubmenu(arg1,arg2,(tOutput const &)*arg3);DATA_PTR(self) = result;
09954   
09955   return self;
09956 fail:
09957   return Qnil;
09958 }
09959 
09960 
09961 SWIGINTERN void
09962 free_uMenuItemSubmenu(uMenuItemSubmenu *arg1) {
09963     delete arg1;
09964 }
09965 
09966 SWIGINTERN VALUE
09967 _wrap_UMenuItemSubmenu_render__SWIG_0(int argc, VALUE *argv, VALUE self) {
09968   uMenuItemSubmenu *arg1 = (uMenuItemSubmenu *) 0 ;
09969   REAL arg2 ;
09970   REAL arg3 ;
09971   REAL arg4 ;
09972   bool arg5 ;
09973   void *argp1 = 0 ;
09974   int res1 = 0 ;
09975   float val2 ;
09976   int ecode2 = 0 ;
09977   float val3 ;
09978   int ecode3 = 0 ;
09979   float val4 ;
09980   int ecode4 = 0 ;
09981   bool val5 ;
09982   int ecode5 = 0 ;
09983   
09984   if ((argc < 4) || (argc > 4)) {
09985     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
09986   }
09987   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemSubmenu, 0 |  0 );
09988   if (!SWIG_IsOK(res1)) {
09989     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItemSubmenu *""'"); 
09990   }
09991   arg1 = reinterpret_cast< uMenuItemSubmenu * >(argp1);
09992   ecode2 = SWIG_AsVal_float(argv[0], &val2);
09993   if (!SWIG_IsOK(ecode2)) {
09994     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
09995   } 
09996   arg2 = static_cast< REAL >(val2);
09997   ecode3 = SWIG_AsVal_float(argv[1], &val3);
09998   if (!SWIG_IsOK(ecode3)) {
09999     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
10000   } 
10001   arg3 = static_cast< REAL >(val3);
10002   ecode4 = SWIG_AsVal_float(argv[2], &val4);
10003   if (!SWIG_IsOK(ecode4)) {
10004     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Render" "', argument " "4"" of type '" "REAL""'");
10005   } 
10006   arg4 = static_cast< REAL >(val4);
10007   ecode5 = SWIG_AsVal_bool(argv[3], &val5);
10008   if (!SWIG_IsOK(ecode5)) {
10009     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Render" "', argument " "5"" of type '" "bool""'");
10010   } 
10011   arg5 = static_cast< bool >(val5);
10012   (arg1)->Render(arg2,arg3,arg4,arg5);
10013   return Qnil;
10014 fail:
10015   return Qnil;
10016 }
10017 
10018 
10019 SWIGINTERN VALUE
10020 _wrap_UMenuItemSubmenu_render__SWIG_1(int argc, VALUE *argv, VALUE self) {
10021   uMenuItemSubmenu *arg1 = (uMenuItemSubmenu *) 0 ;
10022   REAL arg2 ;
10023   REAL arg3 ;
10024   REAL arg4 ;
10025   void *argp1 = 0 ;
10026   int res1 = 0 ;
10027   float val2 ;
10028   int ecode2 = 0 ;
10029   float val3 ;
10030   int ecode3 = 0 ;
10031   float val4 ;
10032   int ecode4 = 0 ;
10033   
10034   if ((argc < 3) || (argc > 3)) {
10035     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
10036   }
10037   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemSubmenu, 0 |  0 );
10038   if (!SWIG_IsOK(res1)) {
10039     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItemSubmenu *""'"); 
10040   }
10041   arg1 = reinterpret_cast< uMenuItemSubmenu * >(argp1);
10042   ecode2 = SWIG_AsVal_float(argv[0], &val2);
10043   if (!SWIG_IsOK(ecode2)) {
10044     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
10045   } 
10046   arg2 = static_cast< REAL >(val2);
10047   ecode3 = SWIG_AsVal_float(argv[1], &val3);
10048   if (!SWIG_IsOK(ecode3)) {
10049     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
10050   } 
10051   arg3 = static_cast< REAL >(val3);
10052   ecode4 = SWIG_AsVal_float(argv[2], &val4);
10053   if (!SWIG_IsOK(ecode4)) {
10054     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Render" "', argument " "4"" of type '" "REAL""'");
10055   } 
10056   arg4 = static_cast< REAL >(val4);
10057   (arg1)->Render(arg2,arg3,arg4);
10058   return Qnil;
10059 fail:
10060   return Qnil;
10061 }
10062 
10063 
10064 SWIGINTERN VALUE
10065 _wrap_UMenuItemSubmenu_render__SWIG_2(int argc, VALUE *argv, VALUE self) {
10066   uMenuItemSubmenu *arg1 = (uMenuItemSubmenu *) 0 ;
10067   REAL arg2 ;
10068   REAL arg3 ;
10069   void *argp1 = 0 ;
10070   int res1 = 0 ;
10071   float val2 ;
10072   int ecode2 = 0 ;
10073   float val3 ;
10074   int ecode3 = 0 ;
10075   
10076   if ((argc < 2) || (argc > 2)) {
10077     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
10078   }
10079   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemSubmenu, 0 |  0 );
10080   if (!SWIG_IsOK(res1)) {
10081     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItemSubmenu *""'"); 
10082   }
10083   arg1 = reinterpret_cast< uMenuItemSubmenu * >(argp1);
10084   ecode2 = SWIG_AsVal_float(argv[0], &val2);
10085   if (!SWIG_IsOK(ecode2)) {
10086     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
10087   } 
10088   arg2 = static_cast< REAL >(val2);
10089   ecode3 = SWIG_AsVal_float(argv[1], &val3);
10090   if (!SWIG_IsOK(ecode3)) {
10091     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
10092   } 
10093   arg3 = static_cast< REAL >(val3);
10094   (arg1)->Render(arg2,arg3);
10095   return Qnil;
10096 fail:
10097   return Qnil;
10098 }
10099 
10100 
10101 SWIGINTERN VALUE _wrap_UMenuItemSubmenu_render(int nargs, VALUE *args, VALUE self) {
10102   int argc;
10103   VALUE argv[6];
10104   int ii;
10105   
10106   argc = nargs + 1;
10107   argv[0] = self;
10108   if (argc > 6) SWIG_fail;
10109   for (ii = 1; (ii < argc); ii++) {
10110     argv[ii] = args[ii-1];
10111   }
10112   if (argc == 3) {
10113     int _v;
10114     void *vptr = 0;
10115     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItemSubmenu, 0);
10116     _v = SWIG_CheckState(res);
10117     if (_v) {
10118       {
10119         int res = SWIG_AsVal_float(argv[1], NULL);
10120         _v = SWIG_CheckState(res);
10121       }
10122       if (_v) {
10123         {
10124           int res = SWIG_AsVal_float(argv[2], NULL);
10125           _v = SWIG_CheckState(res);
10126         }
10127         if (_v) {
10128           return _wrap_UMenuItemSubmenu_render__SWIG_2(nargs, args, self);
10129         }
10130       }
10131     }
10132   }
10133   if (argc == 4) {
10134     int _v;
10135     void *vptr = 0;
10136     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItemSubmenu, 0);
10137     _v = SWIG_CheckState(res);
10138     if (_v) {
10139       {
10140         int res = SWIG_AsVal_float(argv[1], NULL);
10141         _v = SWIG_CheckState(res);
10142       }
10143       if (_v) {
10144         {
10145           int res = SWIG_AsVal_float(argv[2], NULL);
10146           _v = SWIG_CheckState(res);
10147         }
10148         if (_v) {
10149           {
10150             int res = SWIG_AsVal_float(argv[3], NULL);
10151             _v = SWIG_CheckState(res);
10152           }
10153           if (_v) {
10154             return _wrap_UMenuItemSubmenu_render__SWIG_1(nargs, args, self);
10155           }
10156         }
10157       }
10158     }
10159   }
10160   if (argc == 5) {
10161     int _v;
10162     void *vptr = 0;
10163     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItemSubmenu, 0);
10164     _v = SWIG_CheckState(res);
10165     if (_v) {
10166       {
10167         int res = SWIG_AsVal_float(argv[1], NULL);
10168         _v = SWIG_CheckState(res);
10169       }
10170       if (_v) {
10171         {
10172           int res = SWIG_AsVal_float(argv[2], NULL);
10173           _v = SWIG_CheckState(res);
10174         }
10175         if (_v) {
10176           {
10177             int res = SWIG_AsVal_float(argv[3], NULL);
10178             _v = SWIG_CheckState(res);
10179           }
10180           if (_v) {
10181             {
10182               int res = SWIG_AsVal_bool(argv[4], NULL);
10183               _v = SWIG_CheckState(res);
10184             }
10185             if (_v) {
10186               return _wrap_UMenuItemSubmenu_render__SWIG_0(nargs, args, self);
10187             }
10188           }
10189         }
10190       }
10191     }
10192   }
10193   
10194 fail:
10195   rb_raise(rb_eArgError, "No matching function for overloaded 'UMenuItemSubmenu_render'");
10196   return Qnil;
10197 }
10198 
10199 
10200 SWIGINTERN VALUE
10201 _wrap_UMenuItemSubmenu_enter(int argc, VALUE *argv, VALUE self) {
10202   uMenuItemSubmenu *arg1 = (uMenuItemSubmenu *) 0 ;
10203   void *argp1 = 0 ;
10204   int res1 = 0 ;
10205   
10206   if ((argc < 0) || (argc > 0)) {
10207     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10208   }
10209   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemSubmenu, 0 |  0 );
10210   if (!SWIG_IsOK(res1)) {
10211     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enter" "', argument " "1"" of type '" "uMenuItemSubmenu *""'"); 
10212   }
10213   arg1 = reinterpret_cast< uMenuItemSubmenu * >(argp1);
10214   (arg1)->Enter();
10215   return Qnil;
10216 fail:
10217   return Qnil;
10218 }
10219 
10220 
10221 swig_class cUMenuItemAction;
10222 
10223 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
10224 SWIGINTERN VALUE
10225 _wrap_UMenuItemAction_allocate(VALUE self) {
10226 #else
10227   SWIGINTERN VALUE
10228   _wrap_UMenuItemAction_allocate(int argc, VALUE *argv, VALUE self) {
10229 #endif
10230     
10231     
10232     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_uMenuItemAction);
10233 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
10234     rb_obj_call_init(vresult, argc, argv);
10235 #endif
10236     return vresult;
10237   }
10238   
10239 
10240 SWIGINTERN VALUE
10241 _wrap_new_UMenuItemAction(int argc, VALUE *argv, VALUE self) {
10242   VALUE arg1 = (VALUE) 0 ;
10243   uMenu *arg2 = (uMenu *) 0 ;
10244   tOutput *arg3 = 0 ;
10245   tOutput *arg4 = 0 ;
10246   uMenuItemAction *result = 0 ;
10247   void *argp2 = 0 ;
10248   int res2 = 0 ;
10249   void *argp3 ;
10250   int res3 = 0 ;
10251   void *argp4 ;
10252   int res4 = 0 ;
10253   const char *classname SWIGUNUSED = "Armagetronad::UMenuItemAction";
10254   
10255   if ((argc < 3) || (argc > 3)) {
10256     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
10257   }
10258   arg1 = self;
10259   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_uMenu, 0 |  0 );
10260   if (!SWIG_IsOK(res2)) {
10261     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "uMenuItemAction" "', argument " "2"" of type '" "uMenu *""'"); 
10262   }
10263   arg2 = reinterpret_cast< uMenu * >(argp2);
10264   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_tOutput,  0 );
10265   if (!SWIG_IsOK(res3)) {
10266     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "uMenuItemAction" "', argument " "3"" of type '" "tOutput const &""'"); 
10267   }
10268   if (!argp3) {
10269     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemAction" "', argument " "3"" of type '" "tOutput const &""'"); 
10270   }
10271   arg3 = reinterpret_cast< tOutput * >(argp3);
10272   res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_tOutput,  0 );
10273   if (!SWIG_IsOK(res4)) {
10274     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "uMenuItemAction" "', argument " "4"" of type '" "tOutput const &""'"); 
10275   }
10276   if (!argp4) {
10277     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uMenuItemAction" "', argument " "4"" of type '" "tOutput const &""'"); 
10278   }
10279   arg4 = reinterpret_cast< tOutput * >(argp4);
10280   if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
10281     /* subclassed */
10282     result = (uMenuItemAction *)new SwigDirector_UMenuItemAction(arg1,arg2,(tOutput const &)*arg3,(tOutput const &)*arg4); 
10283   } else {
10284     rb_raise(rb_eNameError,"accessing abstract class or protected constructor"); 
10285     return Qnil;
10286   }
10287   DATA_PTR(self) = result;
10288   
10289   return self;
10290 fail:
10291   return Qnil;
10292 }
10293 
10294 
10295 SWIGINTERN void
10296 free_uMenuItemAction(uMenuItemAction *arg1) {
10297     delete arg1;
10298 }
10299 
10300 SWIGINTERN VALUE
10301 _wrap_UMenuItemAction_render__SWIG_0(int argc, VALUE *argv, VALUE self) {
10302   uMenuItemAction *arg1 = (uMenuItemAction *) 0 ;
10303   REAL arg2 ;
10304   REAL arg3 ;
10305   REAL arg4 ;
10306   bool arg5 ;
10307   void *argp1 = 0 ;
10308   int res1 = 0 ;
10309   float val2 ;
10310   int ecode2 = 0 ;
10311   float val3 ;
10312   int ecode3 = 0 ;
10313   float val4 ;
10314   int ecode4 = 0 ;
10315   bool val5 ;
10316   int ecode5 = 0 ;
10317   Swig::Director *director = 0;
10318   bool upcall = false;
10319   
10320   if ((argc < 4) || (argc > 4)) {
10321     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
10322   }
10323   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemAction, 0 |  0 );
10324   if (!SWIG_IsOK(res1)) {
10325     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItemAction *""'"); 
10326   }
10327   arg1 = reinterpret_cast< uMenuItemAction * >(argp1);
10328   ecode2 = SWIG_AsVal_float(argv[0], &val2);
10329   if (!SWIG_IsOK(ecode2)) {
10330     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
10331   } 
10332   arg2 = static_cast< REAL >(val2);
10333   ecode3 = SWIG_AsVal_float(argv[1], &val3);
10334   if (!SWIG_IsOK(ecode3)) {
10335     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
10336   } 
10337   arg3 = static_cast< REAL >(val3);
10338   ecode4 = SWIG_AsVal_float(argv[2], &val4);
10339   if (!SWIG_IsOK(ecode4)) {
10340     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Render" "', argument " "4"" of type '" "REAL""'");
10341   } 
10342   arg4 = static_cast< REAL >(val4);
10343   ecode5 = SWIG_AsVal_bool(argv[3], &val5);
10344   if (!SWIG_IsOK(ecode5)) {
10345     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Render" "', argument " "5"" of type '" "bool""'");
10346   } 
10347   arg5 = static_cast< bool >(val5);
10348   director = dynamic_cast<Swig::Director *>(arg1);
10349   upcall = (director && (director->swig_get_self() == self));
10350   try {
10351     if (upcall) {
10352       (arg1)->uMenuItemAction::Render(arg2,arg3,arg4,arg5);
10353     } else {
10354       (arg1)->Render(arg2,arg3,arg4,arg5);
10355     }
10356   } catch (Swig::DirectorException& e) {
10357     rb_exc_raise(e.getError());
10358     SWIG_fail;
10359   }
10360   return Qnil;
10361 fail:
10362   return Qnil;
10363 }
10364 
10365 
10366 SWIGINTERN VALUE
10367 _wrap_UMenuItemAction_render__SWIG_1(int argc, VALUE *argv, VALUE self) {
10368   uMenuItemAction *arg1 = (uMenuItemAction *) 0 ;
10369   REAL arg2 ;
10370   REAL arg3 ;
10371   REAL arg4 ;
10372   void *argp1 = 0 ;
10373   int res1 = 0 ;
10374   float val2 ;
10375   int ecode2 = 0 ;
10376   float val3 ;
10377   int ecode3 = 0 ;
10378   float val4 ;
10379   int ecode4 = 0 ;
10380   Swig::Director *director = 0;
10381   bool upcall = false;
10382   
10383   if ((argc < 3) || (argc > 3)) {
10384     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
10385   }
10386   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemAction, 0 |  0 );
10387   if (!SWIG_IsOK(res1)) {
10388     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItemAction *""'"); 
10389   }
10390   arg1 = reinterpret_cast< uMenuItemAction * >(argp1);
10391   ecode2 = SWIG_AsVal_float(argv[0], &val2);
10392   if (!SWIG_IsOK(ecode2)) {
10393     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
10394   } 
10395   arg2 = static_cast< REAL >(val2);
10396   ecode3 = SWIG_AsVal_float(argv[1], &val3);
10397   if (!SWIG_IsOK(ecode3)) {
10398     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
10399   } 
10400   arg3 = static_cast< REAL >(val3);
10401   ecode4 = SWIG_AsVal_float(argv[2], &val4);
10402   if (!SWIG_IsOK(ecode4)) {
10403     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Render" "', argument " "4"" of type '" "REAL""'");
10404   } 
10405   arg4 = static_cast< REAL >(val4);
10406   director = dynamic_cast<Swig::Director *>(arg1);
10407   upcall = (director && (director->swig_get_self() == self));
10408   try {
10409     if (upcall) {
10410       (arg1)->uMenuItemAction::Render(arg2,arg3,arg4);
10411     } else {
10412       (arg1)->Render(arg2,arg3,arg4);
10413     }
10414   } catch (Swig::DirectorException& e) {
10415     rb_exc_raise(e.getError());
10416     SWIG_fail;
10417   }
10418   return Qnil;
10419 fail:
10420   return Qnil;
10421 }
10422 
10423 
10424 SWIGINTERN VALUE
10425 _wrap_UMenuItemAction_render__SWIG_2(int argc, VALUE *argv, VALUE self) {
10426   uMenuItemAction *arg1 = (uMenuItemAction *) 0 ;
10427   REAL arg2 ;
10428   REAL arg3 ;
10429   void *argp1 = 0 ;
10430   int res1 = 0 ;
10431   float val2 ;
10432   int ecode2 = 0 ;
10433   float val3 ;
10434   int ecode3 = 0 ;
10435   Swig::Director *director = 0;
10436   bool upcall = false;
10437   
10438   if ((argc < 2) || (argc > 2)) {
10439     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
10440   }
10441   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemAction, 0 |  0 );
10442   if (!SWIG_IsOK(res1)) {
10443     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "uMenuItemAction *""'"); 
10444   }
10445   arg1 = reinterpret_cast< uMenuItemAction * >(argp1);
10446   ecode2 = SWIG_AsVal_float(argv[0], &val2);
10447   if (!SWIG_IsOK(ecode2)) {
10448     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Render" "', argument " "2"" of type '" "REAL""'");
10449   } 
10450   arg2 = static_cast< REAL >(val2);
10451   ecode3 = SWIG_AsVal_float(argv[1], &val3);
10452   if (!SWIG_IsOK(ecode3)) {
10453     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Render" "', argument " "3"" of type '" "REAL""'");
10454   } 
10455   arg3 = static_cast< REAL >(val3);
10456   director = dynamic_cast<Swig::Director *>(arg1);
10457   upcall = (director && (director->swig_get_self() == self));
10458   try {
10459     if (upcall) {
10460       (arg1)->uMenuItemAction::Render(arg2,arg3);
10461     } else {
10462       (arg1)->Render(arg2,arg3);
10463     }
10464   } catch (Swig::DirectorException& e) {
10465     rb_exc_raise(e.getError());
10466     SWIG_fail;
10467   }
10468   return Qnil;
10469 fail:
10470   return Qnil;
10471 }
10472 
10473 
10474 SWIGINTERN VALUE _wrap_UMenuItemAction_render(int nargs, VALUE *args, VALUE self) {
10475   int argc;
10476   VALUE argv[6];
10477   int ii;
10478   
10479   argc = nargs + 1;
10480   argv[0] = self;
10481   if (argc > 6) SWIG_fail;
10482   for (ii = 1; (ii < argc); ii++) {
10483     argv[ii] = args[ii-1];
10484   }
10485   if (argc == 3) {
10486     int _v;
10487     void *vptr = 0;
10488     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItemAction, 0);
10489     _v = SWIG_CheckState(res);
10490     if (_v) {
10491       {
10492         int res = SWIG_AsVal_float(argv[1], NULL);
10493         _v = SWIG_CheckState(res);
10494       }
10495       if (_v) {
10496         {
10497           int res = SWIG_AsVal_float(argv[2], NULL);
10498           _v = SWIG_CheckState(res);
10499         }
10500         if (_v) {
10501           return _wrap_UMenuItemAction_render__SWIG_2(nargs, args, self);
10502         }
10503       }
10504     }
10505   }
10506   if (argc == 4) {
10507     int _v;
10508     void *vptr = 0;
10509     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItemAction, 0);
10510     _v = SWIG_CheckState(res);
10511     if (_v) {
10512       {
10513         int res = SWIG_AsVal_float(argv[1], NULL);
10514         _v = SWIG_CheckState(res);
10515       }
10516       if (_v) {
10517         {
10518           int res = SWIG_AsVal_float(argv[2], NULL);
10519           _v = SWIG_CheckState(res);
10520         }
10521         if (_v) {
10522           {
10523             int res = SWIG_AsVal_float(argv[3], NULL);
10524             _v = SWIG_CheckState(res);
10525           }
10526           if (_v) {
10527             return _wrap_UMenuItemAction_render__SWIG_1(nargs, args, self);
10528           }
10529         }
10530       }
10531     }
10532   }
10533   if (argc == 5) {
10534     int _v;
10535     void *vptr = 0;
10536     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_uMenuItemAction, 0);
10537     _v = SWIG_CheckState(res);
10538     if (_v) {
10539       {
10540         int res = SWIG_AsVal_float(argv[1], NULL);
10541         _v = SWIG_CheckState(res);
10542       }
10543       if (_v) {
10544         {
10545           int res = SWIG_AsVal_float(argv[2], NULL);
10546           _v = SWIG_CheckState(res);
10547         }
10548         if (_v) {
10549           {
10550             int res = SWIG_AsVal_float(argv[3], NULL);
10551             _v = SWIG_CheckState(res);
10552           }
10553           if (_v) {
10554             {
10555               int res = SWIG_AsVal_bool(argv[4], NULL);
10556               _v = SWIG_CheckState(res);
10557             }
10558             if (_v) {
10559               return _wrap_UMenuItemAction_render__SWIG_0(nargs, args, self);
10560             }
10561           }
10562         }
10563       }
10564     }
10565   }
10566   
10567 fail:
10568   rb_raise(rb_eArgError, "No matching function for overloaded 'UMenuItemAction_render'");
10569   return Qnil;
10570 }
10571 
10572 
10573 SWIGINTERN VALUE
10574 _wrap_UMenuItemAction_enter(int argc, VALUE *argv, VALUE self) {
10575   uMenuItemAction *arg1 = (uMenuItemAction *) 0 ;
10576   void *argp1 = 0 ;
10577   int res1 = 0 ;
10578   Swig::Director *director = 0;
10579   bool upcall = false;
10580   
10581   if ((argc < 0) || (argc > 0)) {
10582     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10583   }
10584   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_uMenuItemAction, 0 |  0 );
10585   if (!SWIG_IsOK(res1)) {
10586     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Enter" "', argument " "1"" of type '" "uMenuItemAction *""'"); 
10587   }
10588   arg1 = reinterpret_cast< uMenuItemAction * >(argp1);
10589   director = dynamic_cast<Swig::Director *>(arg1);
10590   upcall = (director && (director->swig_get_self() == self));
10591   try {
10592     if (upcall) {
10593       Swig::DirectorPureVirtualException::raise("uMenuItemAction::Enter");
10594     } else {
10595       (arg1)->Enter();
10596     }
10597   } catch (Swig::DirectorException& e) {
10598     rb_exc_raise(e.getError());
10599     SWIG_fail;
10600   }
10601   return Qnil;
10602 fail:
10603   return Qnil;
10604 }
10605 
10606 
10607 SWIGINTERN VALUE
10608 _wrap_disown_UMenuItemAction(int argc, VALUE *argv, VALUE self) {
10609   uMenuItemAction *arg1 = (uMenuItemAction *) 0 ;
10610   void *argp1 = 0 ;
10611   int res1 = 0 ;
10612   
10613   if ((argc < 1) || (argc > 1)) {
10614     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10615   }
10616   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_uMenuItemAction, 0 |  0 );
10617   if (!SWIG_IsOK(res1)) {
10618     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_UMenuItemAction" "', argument " "1"" of type '" "uMenuItemAction *""'"); 
10619   }
10620   arg1 = reinterpret_cast< uMenuItemAction * >(argp1);
10621   {
10622     Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
10623     if (director) director->swig_disown();
10624   }
10625   
10626   return Qnil;
10627 fail:
10628   return Qnil;
10629 }
10630 
10631 
10632 swig_class cEGameObject;
10633 
10634 SWIGINTERN VALUE
10635 _wrap_EGameObject_get_max_lazy_lag(int argc, VALUE *argv, VALUE self) {
10636   REAL result;
10637   VALUE vresult = Qnil;
10638   
10639   if ((argc < 0) || (argc > 0)) {
10640     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10641   }
10642   result = (REAL)eGameObject::GetMaxLazyLag();
10643   vresult = SWIG_From_float(static_cast< float >(result));
10644   return vresult;
10645 fail:
10646   return Qnil;
10647 }
10648 
10649 
10650 SWIGINTERN VALUE
10651 _wrap_EGameObject_set_max_lazy_lag(int argc, VALUE *argv, VALUE self) {
10652   REAL arg1 ;
10653   float val1 ;
10654   int ecode1 = 0 ;
10655   
10656   if ((argc < 1) || (argc > 1)) {
10657     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10658   }
10659   ecode1 = SWIG_AsVal_float(argv[0], &val1);
10660   if (!SWIG_IsOK(ecode1)) {
10661     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "eGameObject::SetMaxLazyLag" "', argument " "1"" of type '" "REAL""'");
10662   } 
10663   arg1 = static_cast< REAL >(val1);
10664   eGameObject::SetMaxLazyLag(arg1);
10665   return Qnil;
10666 fail:
10667   return Qnil;
10668 }
10669 
10670 
10671 SWIGINTERN VALUE
10672 _wrap_EGameObject_team(int argc, VALUE *argv, VALUE self) {
10673   eGameObject *arg1 = (eGameObject *) 0 ;
10674   eTeam *result = 0 ;
10675   void *argp1 = 0 ;
10676   int res1 = 0 ;
10677   VALUE vresult = Qnil;
10678   
10679   if ((argc < 0) || (argc > 0)) {
10680     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10681   }
10682   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
10683   if (!SWIG_IsOK(res1)) {
10684     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Team" "', argument " "1"" of type '" "eGameObject const *""'"); 
10685   }
10686   arg1 = reinterpret_cast< eGameObject * >(argp1);
10687   result = (eTeam *)((eGameObject const *)arg1)->Team();
10688   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eTeam, 0 |  0 );
10689   return vresult;
10690 fail:
10691   return Qnil;
10692 }
10693 
10694 
10695 SWIGINTERN VALUE
10696 _wrap_EGameObject_grid(int argc, VALUE *argv, VALUE self) {
10697   eGameObject *arg1 = (eGameObject *) 0 ;
10698   eGrid *result = 0 ;
10699   void *argp1 = 0 ;
10700   int res1 = 0 ;
10701   VALUE vresult = Qnil;
10702   
10703   if ((argc < 0) || (argc > 0)) {
10704     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10705   }
10706   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
10707   if (!SWIG_IsOK(res1)) {
10708     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Grid" "', argument " "1"" of type '" "eGameObject const *""'"); 
10709   }
10710   arg1 = reinterpret_cast< eGameObject * >(argp1);
10711   result = (eGrid *)((eGameObject const *)arg1)->Grid();
10712   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eGrid, 0 |  0 );
10713   return vresult;
10714 fail:
10715   return Qnil;
10716 }
10717 
10718 
10719 SWIGINTERN VALUE
10720 _wrap_EGameObject_current_face(int argc, VALUE *argv, VALUE self) {
10721   eGameObject *arg1 = (eGameObject *) 0 ;
10722   eFace *result = 0 ;
10723   void *argp1 = 0 ;
10724   int res1 = 0 ;
10725   VALUE vresult = Qnil;
10726   
10727   if ((argc < 0) || (argc > 0)) {
10728     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10729   }
10730   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
10731   if (!SWIG_IsOK(res1)) {
10732     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurrentFace" "', argument " "1"" of type '" "eGameObject const *""'"); 
10733   }
10734   arg1 = reinterpret_cast< eGameObject * >(argp1);
10735   result = (eFace *)((eGameObject const *)arg1)->CurrentFace();
10736   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eFace, 0 |  0 );
10737   return vresult;
10738 fail:
10739   return Qnil;
10740 }
10741 
10742 
10743 SWIGINTERN VALUE
10744 _wrap_EGameObject_add_ref(int argc, VALUE *argv, VALUE self) {
10745   eGameObject *arg1 = (eGameObject *) 0 ;
10746   void *argp1 = 0 ;
10747   int res1 = 0 ;
10748   
10749   if ((argc < 0) || (argc > 0)) {
10750     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10751   }
10752   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
10753   if (!SWIG_IsOK(res1)) {
10754     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddRef" "', argument " "1"" of type '" "eGameObject *""'"); 
10755   }
10756   arg1 = reinterpret_cast< eGameObject * >(argp1);
10757   (arg1)->AddRef();
10758   return Qnil;
10759 fail:
10760   return Qnil;
10761 }
10762 
10763 
10764 SWIGINTERN VALUE
10765 _wrap_EGameObject_release(int argc, VALUE *argv, VALUE self) {
10766   eGameObject *arg1 = (eGameObject *) 0 ;
10767   void *argp1 = 0 ;
10768   int res1 = 0 ;
10769   
10770   if ((argc < 0) || (argc > 0)) {
10771     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10772   }
10773   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
10774   if (!SWIG_IsOK(res1)) {
10775     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Release" "', argument " "1"" of type '" "eGameObject *""'"); 
10776   }
10777   arg1 = reinterpret_cast< eGameObject * >(argp1);
10778   (arg1)->Release();
10779   return Qnil;
10780 fail:
10781   return Qnil;
10782 }
10783 
10784 
10785 SWIGINTERN VALUE
10786 _wrap_EGameObject_add_to_list(int argc, VALUE *argv, VALUE self) {
10787   eGameObject *arg1 = (eGameObject *) 0 ;
10788   void *argp1 = 0 ;
10789   int res1 = 0 ;
10790   
10791   if ((argc < 0) || (argc > 0)) {
10792     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10793   }
10794   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
10795   if (!SWIG_IsOK(res1)) {
10796     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddToList" "', argument " "1"" of type '" "eGameObject *""'"); 
10797   }
10798   arg1 = reinterpret_cast< eGameObject * >(argp1);
10799   (arg1)->AddToList();
10800   return Qnil;
10801 fail:
10802   return Qnil;
10803 }
10804 
10805 
10806 SWIGINTERN VALUE
10807 _wrap_EGameObject_remove_from_list(int argc, VALUE *argv, VALUE self) {
10808   eGameObject *arg1 = (eGameObject *) 0 ;
10809   void *argp1 = 0 ;
10810   int res1 = 0 ;
10811   
10812   if ((argc < 0) || (argc > 0)) {
10813     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10814   }
10815   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
10816   if (!SWIG_IsOK(res1)) {
10817     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoveFromList" "', argument " "1"" of type '" "eGameObject *""'"); 
10818   }
10819   arg1 = reinterpret_cast< eGameObject * >(argp1);
10820   (arg1)->RemoveFromList();
10821   return Qnil;
10822 fail:
10823   return Qnil;
10824 }
10825 
10826 
10827 SWIGINTERN VALUE
10828 _wrap_EGameObject_remove_from_lists_all(int argc, VALUE *argv, VALUE self) {
10829   eGameObject *arg1 = (eGameObject *) 0 ;
10830   void *argp1 = 0 ;
10831   int res1 = 0 ;
10832   
10833   if ((argc < 0) || (argc > 0)) {
10834     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10835   }
10836   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
10837   if (!SWIG_IsOK(res1)) {
10838     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoveFromListsAll" "', argument " "1"" of type '" "eGameObject *""'"); 
10839   }
10840   arg1 = reinterpret_cast< eGameObject * >(argp1);
10841   (arg1)->RemoveFromListsAll();
10842   return Qnil;
10843 fail:
10844   return Qnil;
10845 }
10846 
10847 
10848 SWIGINTERN VALUE
10849 _wrap_EGameObject_remove_from_game(int argc, VALUE *argv, VALUE self) {
10850   eGameObject *arg1 = (eGameObject *) 0 ;
10851   void *argp1 = 0 ;
10852   int res1 = 0 ;
10853   
10854   if ((argc < 0) || (argc > 0)) {
10855     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10856   }
10857   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
10858   if (!SWIG_IsOK(res1)) {
10859     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoveFromGame" "', argument " "1"" of type '" "eGameObject *""'"); 
10860   }
10861   arg1 = reinterpret_cast< eGameObject * >(argp1);
10862   (arg1)->RemoveFromGame();
10863   return Qnil;
10864 fail:
10865   return Qnil;
10866 }
10867 
10868 
10869 SWIGINTERN VALUE
10870 _wrap_EGameObject_goid(int argc, VALUE *argv, VALUE self) {
10871   eGameObject *arg1 = (eGameObject *) 0 ;
10872   int result;
10873   void *argp1 = 0 ;
10874   int res1 = 0 ;
10875   VALUE vresult = Qnil;
10876   
10877   if ((argc < 0) || (argc > 0)) {
10878     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10879   }
10880   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
10881   if (!SWIG_IsOK(res1)) {
10882     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GOID" "', argument " "1"" of type '" "eGameObject const *""'"); 
10883   }
10884   arg1 = reinterpret_cast< eGameObject * >(argp1);
10885   result = (int)((eGameObject const *)arg1)->GOID();
10886   vresult = SWIG_From_int(static_cast< int >(result));
10887   return vresult;
10888 fail:
10889   return Qnil;
10890 }
10891 
10892 
10893 SWIGINTERN VALUE
10894 _wrap_EGameObject_last_time(int argc, VALUE *argv, VALUE self) {
10895   eGameObject *arg1 = (eGameObject *) 0 ;
10896   REAL result;
10897   void *argp1 = 0 ;
10898   int res1 = 0 ;
10899   VALUE vresult = Qnil;
10900   
10901   if ((argc < 0) || (argc > 0)) {
10902     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10903   }
10904   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
10905   if (!SWIG_IsOK(res1)) {
10906     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LastTime" "', argument " "1"" of type '" "eGameObject const *""'"); 
10907   }
10908   arg1 = reinterpret_cast< eGameObject * >(argp1);
10909   result = (REAL)((eGameObject const *)arg1)->LastTime();
10910   vresult = SWIG_From_float(static_cast< float >(result));
10911   return vresult;
10912 fail:
10913   return Qnil;
10914 }
10915 
10916 
10917 SWIGINTERN VALUE
10918 _wrap_EGameObject_next_interesting_time(int argc, VALUE *argv, VALUE self) {
10919   eGameObject *arg1 = (eGameObject *) 0 ;
10920   REAL result;
10921   void *argp1 = 0 ;
10922   int res1 = 0 ;
10923   VALUE vresult = Qnil;
10924   
10925   if ((argc < 0) || (argc > 0)) {
10926     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10927   }
10928   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
10929   if (!SWIG_IsOK(res1)) {
10930     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NextInterestingTime" "', argument " "1"" of type '" "eGameObject const *""'"); 
10931   }
10932   arg1 = reinterpret_cast< eGameObject * >(argp1);
10933   result = (REAL)((eGameObject const *)arg1)->NextInterestingTime();
10934   vresult = SWIG_From_float(static_cast< float >(result));
10935   return vresult;
10936 fail:
10937   return Qnil;
10938 }
10939 
10940 
10941 SWIGINTERN VALUE
10942 _wrap_new_EGameObject__SWIG_0(int argc, VALUE *argv, VALUE self) {
10943   eGrid *arg1 = (eGrid *) 0 ;
10944   eCoord *arg2 = 0 ;
10945   eCoord *arg3 = 0 ;
10946   eFace *arg4 = (eFace *) 0 ;
10947   bool arg5 ;
10948   eGameObject *result = 0 ;
10949   void *argp1 = 0 ;
10950   int res1 = 0 ;
10951   void *argp2 ;
10952   int res2 = 0 ;
10953   void *argp3 ;
10954   int res3 = 0 ;
10955   void *argp4 = 0 ;
10956   int res4 = 0 ;
10957   bool val5 ;
10958   int ecode5 = 0 ;
10959   const char *classname SWIGUNUSED = "Armagetronad::EGameObject";
10960   
10961   if ((argc < 5) || (argc > 5)) {
10962     rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
10963   }
10964   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_eGrid, 0 |  0 );
10965   if (!SWIG_IsOK(res1)) {
10966     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eGameObject" "', argument " "1"" of type '" "eGrid *""'"); 
10967   }
10968   arg1 = reinterpret_cast< eGrid * >(argp1);
10969   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_eCoord,  0 );
10970   if (!SWIG_IsOK(res2)) {
10971     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "eGameObject" "', argument " "2"" of type '" "eCoord const &""'"); 
10972   }
10973   if (!argp2) {
10974     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "eGameObject" "', argument " "2"" of type '" "eCoord const &""'"); 
10975   }
10976   arg2 = reinterpret_cast< eCoord * >(argp2);
10977   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_eCoord,  0 );
10978   if (!SWIG_IsOK(res3)) {
10979     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "eGameObject" "', argument " "3"" of type '" "eCoord const &""'"); 
10980   }
10981   if (!argp3) {
10982     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "eGameObject" "', argument " "3"" of type '" "eCoord const &""'"); 
10983   }
10984   arg3 = reinterpret_cast< eCoord * >(argp3);
10985   res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_eFace, 0 |  0 );
10986   if (!SWIG_IsOK(res4)) {
10987     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "eGameObject" "', argument " "4"" of type '" "eFace *""'"); 
10988   }
10989   arg4 = reinterpret_cast< eFace * >(argp4);
10990   ecode5 = SWIG_AsVal_bool(argv[4], &val5);
10991   if (!SWIG_IsOK(ecode5)) {
10992     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "eGameObject" "', argument " "5"" of type '" "bool""'");
10993   } 
10994   arg5 = static_cast< bool >(val5);
10995   result = (eGameObject *)new eGameObject(arg1,(eCoord const &)*arg2,(eCoord const &)*arg3,arg4,arg5);DATA_PTR(self) = result;
10996   
10997   return self;
10998 fail:
10999   return Qnil;
11000 }
11001 
11002 
11003 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
11004 SWIGINTERN VALUE
11005 _wrap_EGameObject_allocate(VALUE self) {
11006 #else
11007   SWIGINTERN VALUE
11008   _wrap_EGameObject_allocate(int argc, VALUE *argv, VALUE self) {
11009 #endif
11010     
11011     
11012     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_eGameObject);
11013 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
11014     rb_obj_call_init(vresult, argc, argv);
11015 #endif
11016     return vresult;
11017   }
11018   
11019 
11020 SWIGINTERN VALUE
11021 _wrap_new_EGameObject__SWIG_1(int argc, VALUE *argv, VALUE self) {
11022   eGrid *arg1 = (eGrid *) 0 ;
11023   eCoord *arg2 = 0 ;
11024   eCoord *arg3 = 0 ;
11025   eFace *arg4 = (eFace *) 0 ;
11026   eGameObject *result = 0 ;
11027   void *argp1 = 0 ;
11028   int res1 = 0 ;
11029   void *argp2 ;
11030   int res2 = 0 ;
11031   void *argp3 ;
11032   int res3 = 0 ;
11033   void *argp4 = 0 ;
11034   int res4 = 0 ;
11035   const char *classname SWIGUNUSED = "Armagetronad::EGameObject";
11036   
11037   if ((argc < 4) || (argc > 4)) {
11038     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
11039   }
11040   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_eGrid, 0 |  0 );
11041   if (!SWIG_IsOK(res1)) {
11042     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eGameObject" "', argument " "1"" of type '" "eGrid *""'"); 
11043   }
11044   arg1 = reinterpret_cast< eGrid * >(argp1);
11045   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_eCoord,  0 );
11046   if (!SWIG_IsOK(res2)) {
11047     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "eGameObject" "', argument " "2"" of type '" "eCoord const &""'"); 
11048   }
11049   if (!argp2) {
11050     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "eGameObject" "', argument " "2"" of type '" "eCoord const &""'"); 
11051   }
11052   arg2 = reinterpret_cast< eCoord * >(argp2);
11053   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_eCoord,  0 );
11054   if (!SWIG_IsOK(res3)) {
11055     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "eGameObject" "', argument " "3"" of type '" "eCoord const &""'"); 
11056   }
11057   if (!argp3) {
11058     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "eGameObject" "', argument " "3"" of type '" "eCoord const &""'"); 
11059   }
11060   arg3 = reinterpret_cast< eCoord * >(argp3);
11061   res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_eFace, 0 |  0 );
11062   if (!SWIG_IsOK(res4)) {
11063     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "eGameObject" "', argument " "4"" of type '" "eFace *""'"); 
11064   }
11065   arg4 = reinterpret_cast< eFace * >(argp4);
11066   result = (eGameObject *)new eGameObject(arg1,(eCoord const &)*arg2,(eCoord const &)*arg3,arg4);DATA_PTR(self) = result;
11067   
11068   return self;
11069 fail:
11070   return Qnil;
11071 }
11072 
11073 
11074 SWIGINTERN VALUE _wrap_new_EGameObject(int nargs, VALUE *args, VALUE self) {
11075   int argc;
11076   VALUE argv[5];
11077   int ii;
11078   
11079   argc = nargs;
11080   if (argc > 5) SWIG_fail;
11081   for (ii = 0; (ii < argc); ii++) {
11082     argv[ii] = args[ii];
11083   }
11084   if (argc == 4) {
11085     int _v;
11086     void *vptr = 0;
11087     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGrid, 0);
11088     _v = SWIG_CheckState(res);
11089     if (_v) {
11090       void *vptr = 0;
11091       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eCoord, 0);
11092       _v = SWIG_CheckState(res);
11093       if (_v) {
11094         void *vptr = 0;
11095         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_eCoord, 0);
11096         _v = SWIG_CheckState(res);
11097         if (_v) {
11098           void *vptr = 0;
11099           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_eFace, 0);
11100           _v = SWIG_CheckState(res);
11101           if (_v) {
11102             return _wrap_new_EGameObject__SWIG_1(nargs, args, self);
11103           }
11104         }
11105       }
11106     }
11107   }
11108   if (argc == 5) {
11109     int _v;
11110     void *vptr = 0;
11111     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGrid, 0);
11112     _v = SWIG_CheckState(res);
11113     if (_v) {
11114       void *vptr = 0;
11115       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eCoord, 0);
11116       _v = SWIG_CheckState(res);
11117       if (_v) {
11118         void *vptr = 0;
11119         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_eCoord, 0);
11120         _v = SWIG_CheckState(res);
11121         if (_v) {
11122           void *vptr = 0;
11123           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_eFace, 0);
11124           _v = SWIG_CheckState(res);
11125           if (_v) {
11126             {
11127               int res = SWIG_AsVal_bool(argv[4], NULL);
11128               _v = SWIG_CheckState(res);
11129             }
11130             if (_v) {
11131               return _wrap_new_EGameObject__SWIG_0(nargs, args, self);
11132             }
11133           }
11134         }
11135       }
11136     }
11137   }
11138   
11139 fail:
11140   rb_raise(rb_eArgError, "No matching function for overloaded 'new_EGameObject'");
11141   return Qnil;
11142 }
11143 
11144 
11145 SWIGINTERN void
11146 free_eGameObject(eGameObject *arg1) {
11147     delete arg1;
11148 }
11149 
11150 SWIGINTERN VALUE
11151 _wrap_EGameObject_position(int argc, VALUE *argv, VALUE self) {
11152   eGameObject *arg1 = (eGameObject *) 0 ;
11153   eCoord result;
11154   void *argp1 = 0 ;
11155   int res1 = 0 ;
11156   VALUE vresult = Qnil;
11157   
11158   if ((argc < 0) || (argc > 0)) {
11159     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11160   }
11161   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11162   if (!SWIG_IsOK(res1)) {
11163     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position" "', argument " "1"" of type '" "eGameObject const *""'"); 
11164   }
11165   arg1 = reinterpret_cast< eGameObject * >(argp1);
11166   result = ((eGameObject const *)arg1)->Position();
11167   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
11168   return vresult;
11169 fail:
11170   return Qnil;
11171 }
11172 
11173 
11174 SWIGINTERN VALUE
11175 _wrap_EGameObject_direction(int argc, VALUE *argv, VALUE self) {
11176   eGameObject *arg1 = (eGameObject *) 0 ;
11177   eCoord result;
11178   void *argp1 = 0 ;
11179   int res1 = 0 ;
11180   VALUE vresult = Qnil;
11181   
11182   if ((argc < 0) || (argc > 0)) {
11183     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11184   }
11185   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11186   if (!SWIG_IsOK(res1)) {
11187     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Direction" "', argument " "1"" of type '" "eGameObject const *""'"); 
11188   }
11189   arg1 = reinterpret_cast< eGameObject * >(argp1);
11190   result = ((eGameObject const *)arg1)->Direction();
11191   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
11192   return vresult;
11193 fail:
11194   return Qnil;
11195 }
11196 
11197 
11198 SWIGINTERN VALUE
11199 _wrap_EGameObject_last_direction(int argc, VALUE *argv, VALUE self) {
11200   eGameObject *arg1 = (eGameObject *) 0 ;
11201   eCoord result;
11202   void *argp1 = 0 ;
11203   int res1 = 0 ;
11204   VALUE vresult = Qnil;
11205   
11206   if ((argc < 0) || (argc > 0)) {
11207     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11208   }
11209   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11210   if (!SWIG_IsOK(res1)) {
11211     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LastDirection" "', argument " "1"" of type '" "eGameObject const *""'"); 
11212   }
11213   arg1 = reinterpret_cast< eGameObject * >(argp1);
11214   result = ((eGameObject const *)arg1)->LastDirection();
11215   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
11216   return vresult;
11217 fail:
11218   return Qnil;
11219 }
11220 
11221 
11222 SWIGINTERN VALUE
11223 _wrap_EGameObject_death_time(int argc, VALUE *argv, VALUE self) {
11224   eGameObject *arg1 = (eGameObject *) 0 ;
11225   REAL result;
11226   void *argp1 = 0 ;
11227   int res1 = 0 ;
11228   VALUE vresult = Qnil;
11229   
11230   if ((argc < 0) || (argc > 0)) {
11231     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11232   }
11233   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11234   if (!SWIG_IsOK(res1)) {
11235     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeathTime" "', argument " "1"" of type '" "eGameObject const *""'"); 
11236   }
11237   arg1 = reinterpret_cast< eGameObject * >(argp1);
11238   result = (REAL)((eGameObject const *)arg1)->DeathTime();
11239   vresult = SWIG_From_float(static_cast< float >(result));
11240   return vresult;
11241 fail:
11242   return Qnil;
11243 }
11244 
11245 
11246 SWIGINTERN VALUE
11247 _wrap_EGameObject_speed(int argc, VALUE *argv, VALUE self) {
11248   eGameObject *arg1 = (eGameObject *) 0 ;
11249   REAL result;
11250   void *argp1 = 0 ;
11251   int res1 = 0 ;
11252   VALUE vresult = Qnil;
11253   
11254   if ((argc < 0) || (argc > 0)) {
11255     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11256   }
11257   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11258   if (!SWIG_IsOK(res1)) {
11259     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Speed" "', argument " "1"" of type '" "eGameObject const *""'"); 
11260   }
11261   arg1 = reinterpret_cast< eGameObject * >(argp1);
11262   result = (REAL)((eGameObject const *)arg1)->Speed();
11263   vresult = SWIG_From_float(static_cast< float >(result));
11264   return vresult;
11265 fail:
11266   return Qnil;
11267 }
11268 
11269 
11270 SWIGINTERN VALUE
11271 _wrap_EGameObject_predict_position(int argc, VALUE *argv, VALUE self) {
11272   eGameObject *arg1 = (eGameObject *) 0 ;
11273   eCoord result;
11274   void *argp1 = 0 ;
11275   int res1 = 0 ;
11276   VALUE vresult = Qnil;
11277   
11278   if ((argc < 0) || (argc > 0)) {
11279     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11280   }
11281   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11282   if (!SWIG_IsOK(res1)) {
11283     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PredictPosition" "', argument " "1"" of type '" "eGameObject *""'"); 
11284   }
11285   arg1 = reinterpret_cast< eGameObject * >(argp1);
11286   result = (arg1)->PredictPosition();
11287   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
11288   return vresult;
11289 fail:
11290   return Qnil;
11291 }
11292 
11293 
11294 SWIGINTERN VALUE
11295 _wrap_EGameObject_interact_with__SWIG_0(int argc, VALUE *argv, VALUE self) {
11296   eGameObject *arg1 = (eGameObject *) 0 ;
11297   eGameObject *arg2 = (eGameObject *) 0 ;
11298   REAL arg3 ;
11299   int arg4 ;
11300   void *argp1 = 0 ;
11301   int res1 = 0 ;
11302   void *argp2 = 0 ;
11303   int res2 = 0 ;
11304   float val3 ;
11305   int ecode3 = 0 ;
11306   int val4 ;
11307   int ecode4 = 0 ;
11308   
11309   if ((argc < 3) || (argc > 3)) {
11310     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
11311   }
11312   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11313   if (!SWIG_IsOK(res1)) {
11314     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InteractWith" "', argument " "1"" of type '" "eGameObject *""'"); 
11315   }
11316   arg1 = reinterpret_cast< eGameObject * >(argp1);
11317   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eGameObject, 0 |  0 );
11318   if (!SWIG_IsOK(res2)) {
11319     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InteractWith" "', argument " "2"" of type '" "eGameObject *""'"); 
11320   }
11321   arg2 = reinterpret_cast< eGameObject * >(argp2);
11322   ecode3 = SWIG_AsVal_float(argv[1], &val3);
11323   if (!SWIG_IsOK(ecode3)) {
11324     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InteractWith" "', argument " "3"" of type '" "REAL""'");
11325   } 
11326   arg3 = static_cast< REAL >(val3);
11327   ecode4 = SWIG_AsVal_int(argv[2], &val4);
11328   if (!SWIG_IsOK(ecode4)) {
11329     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InteractWith" "', argument " "4"" of type '" "int""'");
11330   } 
11331   arg4 = static_cast< int >(val4);
11332   (arg1)->InteractWith(arg2,arg3,arg4);
11333   return Qnil;
11334 fail:
11335   return Qnil;
11336 }
11337 
11338 
11339 SWIGINTERN VALUE
11340 _wrap_EGameObject_interact_with__SWIG_1(int argc, VALUE *argv, VALUE self) {
11341   eGameObject *arg1 = (eGameObject *) 0 ;
11342   eGameObject *arg2 = (eGameObject *) 0 ;
11343   REAL arg3 ;
11344   void *argp1 = 0 ;
11345   int res1 = 0 ;
11346   void *argp2 = 0 ;
11347   int res2 = 0 ;
11348   float val3 ;
11349   int ecode3 = 0 ;
11350   
11351   if ((argc < 2) || (argc > 2)) {
11352     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
11353   }
11354   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11355   if (!SWIG_IsOK(res1)) {
11356     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InteractWith" "', argument " "1"" of type '" "eGameObject *""'"); 
11357   }
11358   arg1 = reinterpret_cast< eGameObject * >(argp1);
11359   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eGameObject, 0 |  0 );
11360   if (!SWIG_IsOK(res2)) {
11361     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InteractWith" "', argument " "2"" of type '" "eGameObject *""'"); 
11362   }
11363   arg2 = reinterpret_cast< eGameObject * >(argp2);
11364   ecode3 = SWIG_AsVal_float(argv[1], &val3);
11365   if (!SWIG_IsOK(ecode3)) {
11366     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InteractWith" "', argument " "3"" of type '" "REAL""'");
11367   } 
11368   arg3 = static_cast< REAL >(val3);
11369   (arg1)->InteractWith(arg2,arg3);
11370   return Qnil;
11371 fail:
11372   return Qnil;
11373 }
11374 
11375 
11376 SWIGINTERN VALUE _wrap_EGameObject_interact_with(int nargs, VALUE *args, VALUE self) {
11377   int argc;
11378   VALUE argv[5];
11379   int ii;
11380   
11381   argc = nargs + 1;
11382   argv[0] = self;
11383   if (argc > 5) SWIG_fail;
11384   for (ii = 1; (ii < argc); ii++) {
11385     argv[ii] = args[ii-1];
11386   }
11387   if (argc == 3) {
11388     int _v;
11389     void *vptr = 0;
11390     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGameObject, 0);
11391     _v = SWIG_CheckState(res);
11392     if (_v) {
11393       void *vptr = 0;
11394       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eGameObject, 0);
11395       _v = SWIG_CheckState(res);
11396       if (_v) {
11397         {
11398           int res = SWIG_AsVal_float(argv[2], NULL);
11399           _v = SWIG_CheckState(res);
11400         }
11401         if (_v) {
11402           return _wrap_EGameObject_interact_with__SWIG_1(nargs, args, self);
11403         }
11404       }
11405     }
11406   }
11407   if (argc == 4) {
11408     int _v;
11409     void *vptr = 0;
11410     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGameObject, 0);
11411     _v = SWIG_CheckState(res);
11412     if (_v) {
11413       void *vptr = 0;
11414       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eGameObject, 0);
11415       _v = SWIG_CheckState(res);
11416       if (_v) {
11417         {
11418           int res = SWIG_AsVal_float(argv[2], NULL);
11419           _v = SWIG_CheckState(res);
11420         }
11421         if (_v) {
11422           {
11423             int res = SWIG_AsVal_int(argv[3], NULL);
11424             _v = SWIG_CheckState(res);
11425           }
11426           if (_v) {
11427             return _wrap_EGameObject_interact_with__SWIG_0(nargs, args, self);
11428           }
11429         }
11430       }
11431     }
11432   }
11433   
11434 fail:
11435   rb_raise(rb_eArgError, "No matching function for overloaded 'EGameObject_interact_with'");
11436   return Qnil;
11437 }
11438 
11439 
11440 SWIGINTERN VALUE
11441 _wrap_EGameObject_pass_edge__SWIG_0(int argc, VALUE *argv, VALUE self) {
11442   eGameObject *arg1 = (eGameObject *) 0 ;
11443   eWall *arg2 = (eWall *) 0 ;
11444   REAL arg3 ;
11445   REAL arg4 ;
11446   int arg5 ;
11447   void *argp1 = 0 ;
11448   int res1 = 0 ;
11449   void *argp2 = 0 ;
11450   int res2 = 0 ;
11451   float val3 ;
11452   int ecode3 = 0 ;
11453   float val4 ;
11454   int ecode4 = 0 ;
11455   int val5 ;
11456   int ecode5 = 0 ;
11457   
11458   if ((argc < 4) || (argc > 4)) {
11459     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
11460   }
11461   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11462   if (!SWIG_IsOK(res1)) {
11463     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PassEdge" "', argument " "1"" of type '" "eGameObject *""'"); 
11464   }
11465   arg1 = reinterpret_cast< eGameObject * >(argp1);
11466   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eWall, 0 |  0 );
11467   if (!SWIG_IsOK(res2)) {
11468     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PassEdge" "', argument " "2"" of type '" "eWall const *""'"); 
11469   }
11470   arg2 = reinterpret_cast< eWall * >(argp2);
11471   ecode3 = SWIG_AsVal_float(argv[1], &val3);
11472   if (!SWIG_IsOK(ecode3)) {
11473     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PassEdge" "', argument " "3"" of type '" "REAL""'");
11474   } 
11475   arg3 = static_cast< REAL >(val3);
11476   ecode4 = SWIG_AsVal_float(argv[2], &val4);
11477   if (!SWIG_IsOK(ecode4)) {
11478     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PassEdge" "', argument " "4"" of type '" "REAL""'");
11479   } 
11480   arg4 = static_cast< REAL >(val4);
11481   ecode5 = SWIG_AsVal_int(argv[3], &val5);
11482   if (!SWIG_IsOK(ecode5)) {
11483     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PassEdge" "', argument " "5"" of type '" "int""'");
11484   } 
11485   arg5 = static_cast< int >(val5);
11486   (arg1)->PassEdge((eWall const *)arg2,arg3,arg4,arg5);
11487   return Qnil;
11488 fail:
11489   return Qnil;
11490 }
11491 
11492 
11493 SWIGINTERN VALUE
11494 _wrap_EGameObject_pass_edge__SWIG_1(int argc, VALUE *argv, VALUE self) {
11495   eGameObject *arg1 = (eGameObject *) 0 ;
11496   eWall *arg2 = (eWall *) 0 ;
11497   REAL arg3 ;
11498   REAL arg4 ;
11499   void *argp1 = 0 ;
11500   int res1 = 0 ;
11501   void *argp2 = 0 ;
11502   int res2 = 0 ;
11503   float val3 ;
11504   int ecode3 = 0 ;
11505   float val4 ;
11506   int ecode4 = 0 ;
11507   
11508   if ((argc < 3) || (argc > 3)) {
11509     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
11510   }
11511   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11512   if (!SWIG_IsOK(res1)) {
11513     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PassEdge" "', argument " "1"" of type '" "eGameObject *""'"); 
11514   }
11515   arg1 = reinterpret_cast< eGameObject * >(argp1);
11516   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eWall, 0 |  0 );
11517   if (!SWIG_IsOK(res2)) {
11518     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PassEdge" "', argument " "2"" of type '" "eWall const *""'"); 
11519   }
11520   arg2 = reinterpret_cast< eWall * >(argp2);
11521   ecode3 = SWIG_AsVal_float(argv[1], &val3);
11522   if (!SWIG_IsOK(ecode3)) {
11523     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PassEdge" "', argument " "3"" of type '" "REAL""'");
11524   } 
11525   arg3 = static_cast< REAL >(val3);
11526   ecode4 = SWIG_AsVal_float(argv[2], &val4);
11527   if (!SWIG_IsOK(ecode4)) {
11528     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PassEdge" "', argument " "4"" of type '" "REAL""'");
11529   } 
11530   arg4 = static_cast< REAL >(val4);
11531   (arg1)->PassEdge((eWall const *)arg2,arg3,arg4);
11532   return Qnil;
11533 fail:
11534   return Qnil;
11535 }
11536 
11537 
11538 SWIGINTERN VALUE _wrap_EGameObject_pass_edge(int nargs, VALUE *args, VALUE self) {
11539   int argc;
11540   VALUE argv[6];
11541   int ii;
11542   
11543   argc = nargs + 1;
11544   argv[0] = self;
11545   if (argc > 6) SWIG_fail;
11546   for (ii = 1; (ii < argc); ii++) {
11547     argv[ii] = args[ii-1];
11548   }
11549   if (argc == 4) {
11550     int _v;
11551     void *vptr = 0;
11552     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGameObject, 0);
11553     _v = SWIG_CheckState(res);
11554     if (_v) {
11555       void *vptr = 0;
11556       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eWall, 0);
11557       _v = SWIG_CheckState(res);
11558       if (_v) {
11559         {
11560           int res = SWIG_AsVal_float(argv[2], NULL);
11561           _v = SWIG_CheckState(res);
11562         }
11563         if (_v) {
11564           {
11565             int res = SWIG_AsVal_float(argv[3], NULL);
11566             _v = SWIG_CheckState(res);
11567           }
11568           if (_v) {
11569             return _wrap_EGameObject_pass_edge__SWIG_1(nargs, args, self);
11570           }
11571         }
11572       }
11573     }
11574   }
11575   if (argc == 5) {
11576     int _v;
11577     void *vptr = 0;
11578     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGameObject, 0);
11579     _v = SWIG_CheckState(res);
11580     if (_v) {
11581       void *vptr = 0;
11582       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eWall, 0);
11583       _v = SWIG_CheckState(res);
11584       if (_v) {
11585         {
11586           int res = SWIG_AsVal_float(argv[2], NULL);
11587           _v = SWIG_CheckState(res);
11588         }
11589         if (_v) {
11590           {
11591             int res = SWIG_AsVal_float(argv[3], NULL);
11592             _v = SWIG_CheckState(res);
11593           }
11594           if (_v) {
11595             {
11596               int res = SWIG_AsVal_int(argv[4], NULL);
11597               _v = SWIG_CheckState(res);
11598             }
11599             if (_v) {
11600               return _wrap_EGameObject_pass_edge__SWIG_0(nargs, args, self);
11601             }
11602           }
11603         }
11604       }
11605     }
11606   }
11607   
11608 fail:
11609   rb_raise(rb_eArgError, "No matching function for overloaded 'EGameObject_pass_edge'");
11610   return Qnil;
11611 }
11612 
11613 
11614 SWIGINTERN VALUE
11615 _wrap_EGameObject_pathfinding_modifier(int argc, VALUE *argv, VALUE self) {
11616   eGameObject *arg1 = (eGameObject *) 0 ;
11617   eWall *arg2 = (eWall *) 0 ;
11618   REAL result;
11619   void *argp1 = 0 ;
11620   int res1 = 0 ;
11621   void *argp2 = 0 ;
11622   int res2 = 0 ;
11623   VALUE vresult = Qnil;
11624   
11625   if ((argc < 1) || (argc > 1)) {
11626     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11627   }
11628   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11629   if (!SWIG_IsOK(res1)) {
11630     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathfindingModifier" "', argument " "1"" of type '" "eGameObject const *""'"); 
11631   }
11632   arg1 = reinterpret_cast< eGameObject * >(argp1);
11633   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eWall, 0 |  0 );
11634   if (!SWIG_IsOK(res2)) {
11635     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PathfindingModifier" "', argument " "2"" of type '" "eWall const *""'"); 
11636   }
11637   arg2 = reinterpret_cast< eWall * >(argp2);
11638   result = (REAL)((eGameObject const *)arg1)->PathfindingModifier((eWall const *)arg2);
11639   vresult = SWIG_From_float(static_cast< float >(result));
11640   return vresult;
11641 fail:
11642   return Qnil;
11643 }
11644 
11645 
11646 SWIGINTERN VALUE
11647 _wrap_EGameObject_move__SWIG_0(int argc, VALUE *argv, VALUE self) {
11648   eGameObject *arg1 = (eGameObject *) 0 ;
11649   eCoord *arg2 = 0 ;
11650   REAL arg3 ;
11651   REAL arg4 ;
11652   bool arg5 ;
11653   void *argp1 = 0 ;
11654   int res1 = 0 ;
11655   void *argp2 ;
11656   int res2 = 0 ;
11657   float val3 ;
11658   int ecode3 = 0 ;
11659   float val4 ;
11660   int ecode4 = 0 ;
11661   bool val5 ;
11662   int ecode5 = 0 ;
11663   
11664   if ((argc < 4) || (argc > 4)) {
11665     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
11666   }
11667   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11668   if (!SWIG_IsOK(res1)) {
11669     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Move" "', argument " "1"" of type '" "eGameObject *""'"); 
11670   }
11671   arg1 = reinterpret_cast< eGameObject * >(argp1);
11672   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_eCoord,  0 );
11673   if (!SWIG_IsOK(res2)) {
11674     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Move" "', argument " "2"" of type '" "eCoord const &""'"); 
11675   }
11676   if (!argp2) {
11677     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Move" "', argument " "2"" of type '" "eCoord const &""'"); 
11678   }
11679   arg2 = reinterpret_cast< eCoord * >(argp2);
11680   ecode3 = SWIG_AsVal_float(argv[1], &val3);
11681   if (!SWIG_IsOK(ecode3)) {
11682     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Move" "', argument " "3"" of type '" "REAL""'");
11683   } 
11684   arg3 = static_cast< REAL >(val3);
11685   ecode4 = SWIG_AsVal_float(argv[2], &val4);
11686   if (!SWIG_IsOK(ecode4)) {
11687     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Move" "', argument " "4"" of type '" "REAL""'");
11688   } 
11689   arg4 = static_cast< REAL >(val4);
11690   ecode5 = SWIG_AsVal_bool(argv[3], &val5);
11691   if (!SWIG_IsOK(ecode5)) {
11692     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Move" "', argument " "5"" of type '" "bool""'");
11693   } 
11694   arg5 = static_cast< bool >(val5);
11695   (arg1)->Move((eCoord const &)*arg2,arg3,arg4,arg5);
11696   return Qnil;
11697 fail:
11698   return Qnil;
11699 }
11700 
11701 
11702 SWIGINTERN VALUE
11703 _wrap_EGameObject_move__SWIG_1(int argc, VALUE *argv, VALUE self) {
11704   eGameObject *arg1 = (eGameObject *) 0 ;
11705   eCoord *arg2 = 0 ;
11706   REAL arg3 ;
11707   REAL arg4 ;
11708   void *argp1 = 0 ;
11709   int res1 = 0 ;
11710   void *argp2 ;
11711   int res2 = 0 ;
11712   float val3 ;
11713   int ecode3 = 0 ;
11714   float val4 ;
11715   int ecode4 = 0 ;
11716   
11717   if ((argc < 3) || (argc > 3)) {
11718     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
11719   }
11720   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11721   if (!SWIG_IsOK(res1)) {
11722     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Move" "', argument " "1"" of type '" "eGameObject *""'"); 
11723   }
11724   arg1 = reinterpret_cast< eGameObject * >(argp1);
11725   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_eCoord,  0 );
11726   if (!SWIG_IsOK(res2)) {
11727     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Move" "', argument " "2"" of type '" "eCoord const &""'"); 
11728   }
11729   if (!argp2) {
11730     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Move" "', argument " "2"" of type '" "eCoord const &""'"); 
11731   }
11732   arg2 = reinterpret_cast< eCoord * >(argp2);
11733   ecode3 = SWIG_AsVal_float(argv[1], &val3);
11734   if (!SWIG_IsOK(ecode3)) {
11735     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Move" "', argument " "3"" of type '" "REAL""'");
11736   } 
11737   arg3 = static_cast< REAL >(val3);
11738   ecode4 = SWIG_AsVal_float(argv[2], &val4);
11739   if (!SWIG_IsOK(ecode4)) {
11740     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Move" "', argument " "4"" of type '" "REAL""'");
11741   } 
11742   arg4 = static_cast< REAL >(val4);
11743   (arg1)->Move((eCoord const &)*arg2,arg3,arg4);
11744   return Qnil;
11745 fail:
11746   return Qnil;
11747 }
11748 
11749 
11750 SWIGINTERN VALUE _wrap_EGameObject_move(int nargs, VALUE *args, VALUE self) {
11751   int argc;
11752   VALUE argv[6];
11753   int ii;
11754   
11755   argc = nargs + 1;
11756   argv[0] = self;
11757   if (argc > 6) SWIG_fail;
11758   for (ii = 1; (ii < argc); ii++) {
11759     argv[ii] = args[ii-1];
11760   }
11761   if (argc == 4) {
11762     int _v;
11763     void *vptr = 0;
11764     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGameObject, 0);
11765     _v = SWIG_CheckState(res);
11766     if (_v) {
11767       void *vptr = 0;
11768       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eCoord, 0);
11769       _v = SWIG_CheckState(res);
11770       if (_v) {
11771         {
11772           int res = SWIG_AsVal_float(argv[2], NULL);
11773           _v = SWIG_CheckState(res);
11774         }
11775         if (_v) {
11776           {
11777             int res = SWIG_AsVal_float(argv[3], NULL);
11778             _v = SWIG_CheckState(res);
11779           }
11780           if (_v) {
11781             return _wrap_EGameObject_move__SWIG_1(nargs, args, self);
11782           }
11783         }
11784       }
11785     }
11786   }
11787   if (argc == 5) {
11788     int _v;
11789     void *vptr = 0;
11790     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGameObject, 0);
11791     _v = SWIG_CheckState(res);
11792     if (_v) {
11793       void *vptr = 0;
11794       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eCoord, 0);
11795       _v = SWIG_CheckState(res);
11796       if (_v) {
11797         {
11798           int res = SWIG_AsVal_float(argv[2], NULL);
11799           _v = SWIG_CheckState(res);
11800         }
11801         if (_v) {
11802           {
11803             int res = SWIG_AsVal_float(argv[3], NULL);
11804             _v = SWIG_CheckState(res);
11805           }
11806           if (_v) {
11807             {
11808               int res = SWIG_AsVal_bool(argv[4], NULL);
11809               _v = SWIG_CheckState(res);
11810             }
11811             if (_v) {
11812               return _wrap_EGameObject_move__SWIG_0(nargs, args, self);
11813             }
11814           }
11815         }
11816       }
11817     }
11818   }
11819   
11820 fail:
11821   rb_raise(rb_eArgError, "No matching function for overloaded 'EGameObject_move'");
11822   return Qnil;
11823 }
11824 
11825 
11826 SWIGINTERN VALUE
11827 _wrap_EGameObject_find_current_face(int argc, VALUE *argv, VALUE self) {
11828   eGameObject *arg1 = (eGameObject *) 0 ;
11829   void *argp1 = 0 ;
11830   int res1 = 0 ;
11831   
11832   if ((argc < 0) || (argc > 0)) {
11833     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11834   }
11835   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11836   if (!SWIG_IsOK(res1)) {
11837     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FindCurrentFace" "', argument " "1"" of type '" "eGameObject *""'"); 
11838   }
11839   arg1 = reinterpret_cast< eGameObject * >(argp1);
11840   (arg1)->FindCurrentFace();
11841   return Qnil;
11842 fail:
11843   return Qnil;
11844 }
11845 
11846 
11847 SWIGINTERN VALUE
11848 _wrap_EGameObject_timestep(int argc, VALUE *argv, VALUE self) {
11849   eGameObject *arg1 = (eGameObject *) 0 ;
11850   REAL arg2 ;
11851   bool result;
11852   void *argp1 = 0 ;
11853   int res1 = 0 ;
11854   float val2 ;
11855   int ecode2 = 0 ;
11856   VALUE vresult = Qnil;
11857   
11858   if ((argc < 1) || (argc > 1)) {
11859     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11860   }
11861   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11862   if (!SWIG_IsOK(res1)) {
11863     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timestep" "', argument " "1"" of type '" "eGameObject *""'"); 
11864   }
11865   arg1 = reinterpret_cast< eGameObject * >(argp1);
11866   ecode2 = SWIG_AsVal_float(argv[0], &val2);
11867   if (!SWIG_IsOK(ecode2)) {
11868     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timestep" "', argument " "2"" of type '" "REAL""'");
11869   } 
11870   arg2 = static_cast< REAL >(val2);
11871   result = (bool)(arg1)->Timestep(arg2);
11872   vresult = SWIG_From_bool(static_cast< bool >(result));
11873   return vresult;
11874 fail:
11875   return Qnil;
11876 }
11877 
11878 
11879 SWIGINTERN VALUE
11880 _wrap_EGameObject_edge_is_dangerous(int argc, VALUE *argv, VALUE self) {
11881   eGameObject *arg1 = (eGameObject *) 0 ;
11882   eWall *arg2 = (eWall *) 0 ;
11883   REAL arg3 ;
11884   REAL arg4 ;
11885   bool result;
11886   void *argp1 = 0 ;
11887   int res1 = 0 ;
11888   void *argp2 = 0 ;
11889   int res2 = 0 ;
11890   float val3 ;
11891   int ecode3 = 0 ;
11892   float val4 ;
11893   int ecode4 = 0 ;
11894   VALUE vresult = Qnil;
11895   
11896   if ((argc < 3) || (argc > 3)) {
11897     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
11898   }
11899   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11900   if (!SWIG_IsOK(res1)) {
11901     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EdgeIsDangerous" "', argument " "1"" of type '" "eGameObject const *""'"); 
11902   }
11903   arg1 = reinterpret_cast< eGameObject * >(argp1);
11904   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eWall, 0 |  0 );
11905   if (!SWIG_IsOK(res2)) {
11906     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EdgeIsDangerous" "', argument " "2"" of type '" "eWall const *""'"); 
11907   }
11908   arg2 = reinterpret_cast< eWall * >(argp2);
11909   ecode3 = SWIG_AsVal_float(argv[1], &val3);
11910   if (!SWIG_IsOK(ecode3)) {
11911     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EdgeIsDangerous" "', argument " "3"" of type '" "REAL""'");
11912   } 
11913   arg3 = static_cast< REAL >(val3);
11914   ecode4 = SWIG_AsVal_float(argv[2], &val4);
11915   if (!SWIG_IsOK(ecode4)) {
11916     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EdgeIsDangerous" "', argument " "4"" of type '" "REAL""'");
11917   } 
11918   arg4 = static_cast< REAL >(val4);
11919   result = (bool)((eGameObject const *)arg1)->EdgeIsDangerous((eWall const *)arg2,arg3,arg4);
11920   vresult = SWIG_From_bool(static_cast< bool >(result));
11921   return vresult;
11922 fail:
11923   return Qnil;
11924 }
11925 
11926 
11927 SWIGINTERN VALUE
11928 _wrap_EGameObject_kill(int argc, VALUE *argv, VALUE self) {
11929   eGameObject *arg1 = (eGameObject *) 0 ;
11930   void *argp1 = 0 ;
11931   int res1 = 0 ;
11932   
11933   if ((argc < 0) || (argc > 0)) {
11934     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11935   }
11936   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11937   if (!SWIG_IsOK(res1)) {
11938     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Kill" "', argument " "1"" of type '" "eGameObject *""'"); 
11939   }
11940   arg1 = reinterpret_cast< eGameObject * >(argp1);
11941   (arg1)->Kill();
11942   return Qnil;
11943 fail:
11944   return Qnil;
11945 }
11946 
11947 
11948 SWIGINTERN VALUE
11949 _wrap_EGameObject_alive(int argc, VALUE *argv, VALUE self) {
11950   eGameObject *arg1 = (eGameObject *) 0 ;
11951   bool result;
11952   void *argp1 = 0 ;
11953   int res1 = 0 ;
11954   VALUE vresult = Qnil;
11955   
11956   if ((argc < 0) || (argc > 0)) {
11957     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11958   }
11959   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11960   if (!SWIG_IsOK(res1)) {
11961     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Alive" "', argument " "1"" of type '" "eGameObject const *""'"); 
11962   }
11963   arg1 = reinterpret_cast< eGameObject * >(argp1);
11964   result = (bool)((eGameObject const *)arg1)->Alive();
11965   vresult = SWIG_From_bool(static_cast< bool >(result));
11966   return vresult;
11967 fail:
11968   return Qnil;
11969 }
11970 
11971 
11972 SWIGINTERN VALUE
11973 _wrap_EGameObject_render(int argc, VALUE *argv, VALUE self) {
11974   eGameObject *arg1 = (eGameObject *) 0 ;
11975   eCamera *arg2 = (eCamera *) 0 ;
11976   void *argp1 = 0 ;
11977   int res1 = 0 ;
11978   void *argp2 = 0 ;
11979   int res2 = 0 ;
11980   
11981   if ((argc < 1) || (argc > 1)) {
11982     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11983   }
11984   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
11985   if (!SWIG_IsOK(res1)) {
11986     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Render" "', argument " "1"" of type '" "eGameObject *""'"); 
11987   }
11988   arg1 = reinterpret_cast< eGameObject * >(argp1);
11989   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eCamera, 0 |  0 );
11990   if (!SWIG_IsOK(res2)) {
11991     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Render" "', argument " "2"" of type '" "eCamera const *""'"); 
11992   }
11993   arg2 = reinterpret_cast< eCamera * >(argp2);
11994   (arg1)->Render((eCamera const *)arg2);
11995   return Qnil;
11996 fail:
11997   return Qnil;
11998 }
11999 
12000 
12001 SWIGINTERN VALUE
12002 _wrap_EGameObject_render_cockpit_fixed_before__SWIG_0(int argc, VALUE *argv, VALUE self) {
12003   eGameObject *arg1 = (eGameObject *) 0 ;
12004   bool arg2 ;
12005   bool result;
12006   void *argp1 = 0 ;
12007   int res1 = 0 ;
12008   bool val2 ;
12009   int ecode2 = 0 ;
12010   VALUE vresult = Qnil;
12011   
12012   if ((argc < 1) || (argc > 1)) {
12013     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12014   }
12015   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
12016   if (!SWIG_IsOK(res1)) {
12017     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RenderCockpitFixedBefore" "', argument " "1"" of type '" "eGameObject *""'"); 
12018   }
12019   arg1 = reinterpret_cast< eGameObject * >(argp1);
12020   ecode2 = SWIG_AsVal_bool(argv[0], &val2);
12021   if (!SWIG_IsOK(ecode2)) {
12022     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RenderCockpitFixedBefore" "', argument " "2"" of type '" "bool""'");
12023   } 
12024   arg2 = static_cast< bool >(val2);
12025   result = (bool)(arg1)->RenderCockpitFixedBefore(arg2);
12026   vresult = SWIG_From_bool(static_cast< bool >(result));
12027   return vresult;
12028 fail:
12029   return Qnil;
12030 }
12031 
12032 
12033 SWIGINTERN VALUE
12034 _wrap_EGameObject_render_cockpit_fixed_before__SWIG_1(int argc, VALUE *argv, VALUE self) {
12035   eGameObject *arg1 = (eGameObject *) 0 ;
12036   bool result;
12037   void *argp1 = 0 ;
12038   int res1 = 0 ;
12039   VALUE vresult = Qnil;
12040   
12041   if ((argc < 0) || (argc > 0)) {
12042     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12043   }
12044   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
12045   if (!SWIG_IsOK(res1)) {
12046     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RenderCockpitFixedBefore" "', argument " "1"" of type '" "eGameObject *""'"); 
12047   }
12048   arg1 = reinterpret_cast< eGameObject * >(argp1);
12049   result = (bool)(arg1)->RenderCockpitFixedBefore();
12050   vresult = SWIG_From_bool(static_cast< bool >(result));
12051   return vresult;
12052 fail:
12053   return Qnil;
12054 }
12055 
12056 
12057 SWIGINTERN VALUE _wrap_EGameObject_render_cockpit_fixed_before(int nargs, VALUE *args, VALUE self) {
12058   int argc;
12059   VALUE argv[3];
12060   int ii;
12061   
12062   argc = nargs + 1;
12063   argv[0] = self;
12064   if (argc > 3) SWIG_fail;
12065   for (ii = 1; (ii < argc); ii++) {
12066     argv[ii] = args[ii-1];
12067   }
12068   if (argc == 1) {
12069     int _v;
12070     void *vptr = 0;
12071     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGameObject, 0);
12072     _v = SWIG_CheckState(res);
12073     if (_v) {
12074       return _wrap_EGameObject_render_cockpit_fixed_before__SWIG_1(nargs, args, self);
12075     }
12076   }
12077   if (argc == 2) {
12078     int _v;
12079     void *vptr = 0;
12080     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGameObject, 0);
12081     _v = SWIG_CheckState(res);
12082     if (_v) {
12083       {
12084         int res = SWIG_AsVal_bool(argv[1], NULL);
12085         _v = SWIG_CheckState(res);
12086       }
12087       if (_v) {
12088         return _wrap_EGameObject_render_cockpit_fixed_before__SWIG_0(nargs, args, self);
12089       }
12090     }
12091   }
12092   
12093 fail:
12094   rb_raise(rb_eArgError, "No matching function for overloaded 'EGameObject_render_cockpit_fixed_before'");
12095   return Qnil;
12096 }
12097 
12098 
12099 SWIGINTERN VALUE
12100 _wrap_EGameObject_render_cockpit_fixed_after__SWIG_0(int argc, VALUE *argv, VALUE self) {
12101   eGameObject *arg1 = (eGameObject *) 0 ;
12102   bool arg2 ;
12103   void *argp1 = 0 ;
12104   int res1 = 0 ;
12105   bool val2 ;
12106   int ecode2 = 0 ;
12107   
12108   if ((argc < 1) || (argc > 1)) {
12109     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12110   }
12111   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
12112   if (!SWIG_IsOK(res1)) {
12113     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RenderCockpitFixedAfter" "', argument " "1"" of type '" "eGameObject *""'"); 
12114   }
12115   arg1 = reinterpret_cast< eGameObject * >(argp1);
12116   ecode2 = SWIG_AsVal_bool(argv[0], &val2);
12117   if (!SWIG_IsOK(ecode2)) {
12118     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RenderCockpitFixedAfter" "', argument " "2"" of type '" "bool""'");
12119   } 
12120   arg2 = static_cast< bool >(val2);
12121   (arg1)->RenderCockpitFixedAfter(arg2);
12122   return Qnil;
12123 fail:
12124   return Qnil;
12125 }
12126 
12127 
12128 SWIGINTERN VALUE
12129 _wrap_EGameObject_render_cockpit_fixed_after__SWIG_1(int argc, VALUE *argv, VALUE self) {
12130   eGameObject *arg1 = (eGameObject *) 0 ;
12131   void *argp1 = 0 ;
12132   int res1 = 0 ;
12133   
12134   if ((argc < 0) || (argc > 0)) {
12135     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12136   }
12137   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
12138   if (!SWIG_IsOK(res1)) {
12139     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RenderCockpitFixedAfter" "', argument " "1"" of type '" "eGameObject *""'"); 
12140   }
12141   arg1 = reinterpret_cast< eGameObject * >(argp1);
12142   (arg1)->RenderCockpitFixedAfter();
12143   return Qnil;
12144 fail:
12145   return Qnil;
12146 }
12147 
12148 
12149 SWIGINTERN VALUE _wrap_EGameObject_render_cockpit_fixed_after(int nargs, VALUE *args, VALUE self) {
12150   int argc;
12151   VALUE argv[3];
12152   int ii;
12153   
12154   argc = nargs + 1;
12155   argv[0] = self;
12156   if (argc > 3) SWIG_fail;
12157   for (ii = 1; (ii < argc); ii++) {
12158     argv[ii] = args[ii-1];
12159   }
12160   if (argc == 1) {
12161     int _v;
12162     void *vptr = 0;
12163     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGameObject, 0);
12164     _v = SWIG_CheckState(res);
12165     if (_v) {
12166       return _wrap_EGameObject_render_cockpit_fixed_after__SWIG_1(nargs, args, self);
12167     }
12168   }
12169   if (argc == 2) {
12170     int _v;
12171     void *vptr = 0;
12172     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGameObject, 0);
12173     _v = SWIG_CheckState(res);
12174     if (_v) {
12175       {
12176         int res = SWIG_AsVal_bool(argv[1], NULL);
12177         _v = SWIG_CheckState(res);
12178       }
12179       if (_v) {
12180         return _wrap_EGameObject_render_cockpit_fixed_after__SWIG_0(nargs, args, self);
12181       }
12182     }
12183   }
12184   
12185 fail:
12186   rb_raise(rb_eArgError, "No matching function for overloaded 'EGameObject_render_cockpit_fixed_after'");
12187   return Qnil;
12188 }
12189 
12190 
12191 SWIGINTERN VALUE
12192 _wrap_EGameObject_render_cockpit_virtual__SWIG_0(int argc, VALUE *argv, VALUE self) {
12193   eGameObject *arg1 = (eGameObject *) 0 ;
12194   bool arg2 ;
12195   void *argp1 = 0 ;
12196   int res1 = 0 ;
12197   bool val2 ;
12198   int ecode2 = 0 ;
12199   
12200   if ((argc < 1) || (argc > 1)) {
12201     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12202   }
12203   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
12204   if (!SWIG_IsOK(res1)) {
12205     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RenderCockpitVirtual" "', argument " "1"" of type '" "eGameObject *""'"); 
12206   }
12207   arg1 = reinterpret_cast< eGameObject * >(argp1);
12208   ecode2 = SWIG_AsVal_bool(argv[0], &val2);
12209   if (!SWIG_IsOK(ecode2)) {
12210     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RenderCockpitVirtual" "', argument " "2"" of type '" "bool""'");
12211   } 
12212   arg2 = static_cast< bool >(val2);
12213   (arg1)->RenderCockpitVirtual(arg2);
12214   return Qnil;
12215 fail:
12216   return Qnil;
12217 }
12218 
12219 
12220 SWIGINTERN VALUE
12221 _wrap_EGameObject_render_cockpit_virtual__SWIG_1(int argc, VALUE *argv, VALUE self) {
12222   eGameObject *arg1 = (eGameObject *) 0 ;
12223   void *argp1 = 0 ;
12224   int res1 = 0 ;
12225   
12226   if ((argc < 0) || (argc > 0)) {
12227     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12228   }
12229   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
12230   if (!SWIG_IsOK(res1)) {
12231     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RenderCockpitVirtual" "', argument " "1"" of type '" "eGameObject *""'"); 
12232   }
12233   arg1 = reinterpret_cast< eGameObject * >(argp1);
12234   (arg1)->RenderCockpitVirtual();
12235   return Qnil;
12236 fail:
12237   return Qnil;
12238 }
12239 
12240 
12241 SWIGINTERN VALUE _wrap_EGameObject_render_cockpit_virtual(int nargs, VALUE *args, VALUE self) {
12242   int argc;
12243   VALUE argv[3];
12244   int ii;
12245   
12246   argc = nargs + 1;
12247   argv[0] = self;
12248   if (argc > 3) SWIG_fail;
12249   for (ii = 1; (ii < argc); ii++) {
12250     argv[ii] = args[ii-1];
12251   }
12252   if (argc == 1) {
12253     int _v;
12254     void *vptr = 0;
12255     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGameObject, 0);
12256     _v = SWIG_CheckState(res);
12257     if (_v) {
12258       return _wrap_EGameObject_render_cockpit_virtual__SWIG_1(nargs, args, self);
12259     }
12260   }
12261   if (argc == 2) {
12262     int _v;
12263     void *vptr = 0;
12264     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGameObject, 0);
12265     _v = SWIG_CheckState(res);
12266     if (_v) {
12267       {
12268         int res = SWIG_AsVal_bool(argv[1], NULL);
12269         _v = SWIG_CheckState(res);
12270       }
12271       if (_v) {
12272         return _wrap_EGameObject_render_cockpit_virtual__SWIG_0(nargs, args, self);
12273       }
12274     }
12275   }
12276   
12277 fail:
12278   rb_raise(rb_eArgError, "No matching function for overloaded 'EGameObject_render_cockpit_virtual'");
12279   return Qnil;
12280 }
12281 
12282 
12283 SWIGINTERN VALUE
12284 _wrap_EGameObject_cam_dir(int argc, VALUE *argv, VALUE self) {
12285   eGameObject *arg1 = (eGameObject *) 0 ;
12286   eCoord result;
12287   void *argp1 = 0 ;
12288   int res1 = 0 ;
12289   VALUE vresult = Qnil;
12290   
12291   if ((argc < 0) || (argc > 0)) {
12292     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12293   }
12294   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
12295   if (!SWIG_IsOK(res1)) {
12296     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CamDir" "', argument " "1"" of type '" "eGameObject *""'"); 
12297   }
12298   arg1 = reinterpret_cast< eGameObject * >(argp1);
12299   result = (arg1)->CamDir();
12300   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
12301   return vresult;
12302 fail:
12303   return Qnil;
12304 }
12305 
12306 
12307 SWIGINTERN VALUE
12308 _wrap_EGameObject_cam_rise(int argc, VALUE *argv, VALUE self) {
12309   eGameObject *arg1 = (eGameObject *) 0 ;
12310   REAL result;
12311   void *argp1 = 0 ;
12312   int res1 = 0 ;
12313   VALUE vresult = Qnil;
12314   
12315   if ((argc < 0) || (argc > 0)) {
12316     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12317   }
12318   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
12319   if (!SWIG_IsOK(res1)) {
12320     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CamRise" "', argument " "1"" of type '" "eGameObject *""'"); 
12321   }
12322   arg1 = reinterpret_cast< eGameObject * >(argp1);
12323   result = (REAL)(arg1)->CamRise();
12324   vresult = SWIG_From_float(static_cast< float >(result));
12325   return vresult;
12326 fail:
12327   return Qnil;
12328 }
12329 
12330 
12331 SWIGINTERN VALUE
12332 _wrap_EGameObject_cam_pos(int argc, VALUE *argv, VALUE self) {
12333   eGameObject *arg1 = (eGameObject *) 0 ;
12334   eCoord result;
12335   void *argp1 = 0 ;
12336   int res1 = 0 ;
12337   VALUE vresult = Qnil;
12338   
12339   if ((argc < 0) || (argc > 0)) {
12340     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12341   }
12342   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
12343   if (!SWIG_IsOK(res1)) {
12344     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CamPos" "', argument " "1"" of type '" "eGameObject *""'"); 
12345   }
12346   arg1 = reinterpret_cast< eGameObject * >(argp1);
12347   result = (arg1)->CamPos();
12348   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
12349   return vresult;
12350 fail:
12351   return Qnil;
12352 }
12353 
12354 
12355 SWIGINTERN VALUE
12356 _wrap_EGameObject_cam_z(int argc, VALUE *argv, VALUE self) {
12357   eGameObject *arg1 = (eGameObject *) 0 ;
12358   REAL result;
12359   void *argp1 = 0 ;
12360   int res1 = 0 ;
12361   VALUE vresult = Qnil;
12362   
12363   if ((argc < 0) || (argc > 0)) {
12364     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12365   }
12366   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
12367   if (!SWIG_IsOK(res1)) {
12368     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CamZ" "', argument " "1"" of type '" "eGameObject *""'"); 
12369   }
12370   arg1 = reinterpret_cast< eGameObject * >(argp1);
12371   result = (REAL)(arg1)->CamZ();
12372   vresult = SWIG_From_float(static_cast< float >(result));
12373   return vresult;
12374 fail:
12375   return Qnil;
12376 }
12377 
12378 
12379 SWIGINTERN VALUE
12380 _wrap_EGameObject_cam_top(int argc, VALUE *argv, VALUE self) {
12381   eGameObject *arg1 = (eGameObject *) 0 ;
12382   eCoord result;
12383   void *argp1 = 0 ;
12384   int res1 = 0 ;
12385   VALUE vresult = Qnil;
12386   
12387   if ((argc < 0) || (argc > 0)) {
12388     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12389   }
12390   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
12391   if (!SWIG_IsOK(res1)) {
12392     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CamTop" "', argument " "1"" of type '" "eGameObject *""'"); 
12393   }
12394   arg1 = reinterpret_cast< eGameObject * >(argp1);
12395   result = (arg1)->CamTop();
12396   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
12397   return vresult;
12398 fail:
12399   return Qnil;
12400 }
12401 
12402 
12403 SWIGINTERN VALUE
12404 _wrap_EGameObject_lag(int argc, VALUE *argv, VALUE self) {
12405   eGameObject *arg1 = (eGameObject *) 0 ;
12406   REAL result;
12407   void *argp1 = 0 ;
12408   int res1 = 0 ;
12409   VALUE vresult = Qnil;
12410   
12411   if ((argc < 0) || (argc > 0)) {
12412     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12413   }
12414   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
12415   if (!SWIG_IsOK(res1)) {
12416     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lag" "', argument " "1"" of type '" "eGameObject const *""'"); 
12417   }
12418   arg1 = reinterpret_cast< eGameObject * >(argp1);
12419   result = (REAL)((eGameObject const *)arg1)->Lag();
12420   vresult = SWIG_From_float(static_cast< float >(result));
12421   return vresult;
12422 fail:
12423   return Qnil;
12424 }
12425 
12426 
12427 SWIGINTERN VALUE
12428 _wrap_EGameObject_lag_threshold(int argc, VALUE *argv, VALUE self) {
12429   eGameObject *arg1 = (eGameObject *) 0 ;
12430   REAL result;
12431   void *argp1 = 0 ;
12432   int res1 = 0 ;
12433   VALUE vresult = Qnil;
12434   
12435   if ((argc < 0) || (argc > 0)) {
12436     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12437   }
12438   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
12439   if (!SWIG_IsOK(res1)) {
12440     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LagThreshold" "', argument " "1"" of type '" "eGameObject const *""'"); 
12441   }
12442   arg1 = reinterpret_cast< eGameObject * >(argp1);
12443   result = (REAL)((eGameObject const *)arg1)->LagThreshold();
12444   vresult = SWIG_From_float(static_cast< float >(result));
12445   return vresult;
12446 fail:
12447   return Qnil;
12448 }
12449 
12450 
12451 SWIGINTERN VALUE
12452 _wrap_EGameObject_act(int argc, VALUE *argv, VALUE self) {
12453   eGameObject *arg1 = (eGameObject *) 0 ;
12454   uActionPlayer *arg2 = (uActionPlayer *) 0 ;
12455   REAL arg3 ;
12456   bool result;
12457   void *argp1 = 0 ;
12458   int res1 = 0 ;
12459   void *argp2 = 0 ;
12460   int res2 = 0 ;
12461   float val3 ;
12462   int ecode3 = 0 ;
12463   VALUE vresult = Qnil;
12464   
12465   if ((argc < 2) || (argc > 2)) {
12466     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
12467   }
12468   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
12469   if (!SWIG_IsOK(res1)) {
12470     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Act" "', argument " "1"" of type '" "eGameObject *""'"); 
12471   }
12472   arg1 = reinterpret_cast< eGameObject * >(argp1);
12473   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_uActionPlayer, 0 |  0 );
12474   if (!SWIG_IsOK(res2)) {
12475     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Act" "', argument " "2"" of type '" "uActionPlayer *""'"); 
12476   }
12477   arg2 = reinterpret_cast< uActionPlayer * >(argp2);
12478   ecode3 = SWIG_AsVal_float(argv[1], &val3);
12479   if (!SWIG_IsOK(ecode3)) {
12480     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Act" "', argument " "3"" of type '" "REAL""'");
12481   } 
12482   arg3 = static_cast< REAL >(val3);
12483   result = (bool)(arg1)->Act(arg2,arg3);
12484   vresult = SWIG_From_bool(static_cast< bool >(result));
12485   return vresult;
12486 fail:
12487   return Qnil;
12488 }
12489 
12490 
12491 SWIGINTERN VALUE
12492 _wrap_EGameObject_s_timestep(int argc, VALUE *argv, VALUE self) {
12493   eGrid *arg1 = (eGrid *) 0 ;
12494   REAL arg2 ;
12495   REAL arg3 ;
12496   void *argp1 = 0 ;
12497   int res1 = 0 ;
12498   float val2 ;
12499   int ecode2 = 0 ;
12500   float val3 ;
12501   int ecode3 = 0 ;
12502   
12503   if ((argc < 3) || (argc > 3)) {
12504     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
12505   }
12506   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_eGrid, 0 |  0 );
12507   if (!SWIG_IsOK(res1)) {
12508     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eGameObject::s_Timestep" "', argument " "1"" of type '" "eGrid *""'"); 
12509   }
12510   arg1 = reinterpret_cast< eGrid * >(argp1);
12511   ecode2 = SWIG_AsVal_float(argv[1], &val2);
12512   if (!SWIG_IsOK(ecode2)) {
12513     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eGameObject::s_Timestep" "', argument " "2"" of type '" "REAL""'");
12514   } 
12515   arg2 = static_cast< REAL >(val2);
12516   ecode3 = SWIG_AsVal_float(argv[2], &val3);
12517   if (!SWIG_IsOK(ecode3)) {
12518     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "eGameObject::s_Timestep" "', argument " "3"" of type '" "REAL""'");
12519   } 
12520   arg3 = static_cast< REAL >(val3);
12521   eGameObject::s_Timestep(arg1,arg2,arg3);
12522   return Qnil;
12523 fail:
12524   return Qnil;
12525 }
12526 
12527 
12528 SWIGINTERN VALUE
12529 _wrap_EGameObject_render_all(int argc, VALUE *argv, VALUE self) {
12530   eGrid *arg1 = (eGrid *) 0 ;
12531   eCamera *arg2 = (eCamera *) 0 ;
12532   void *argp1 = 0 ;
12533   int res1 = 0 ;
12534   void *argp2 = 0 ;
12535   int res2 = 0 ;
12536   
12537   if ((argc < 2) || (argc > 2)) {
12538     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
12539   }
12540   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_eGrid, 0 |  0 );
12541   if (!SWIG_IsOK(res1)) {
12542     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eGameObject::RenderAll" "', argument " "1"" of type '" "eGrid *""'"); 
12543   }
12544   arg1 = reinterpret_cast< eGrid * >(argp1);
12545   res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_eCamera, 0 |  0 );
12546   if (!SWIG_IsOK(res2)) {
12547     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "eGameObject::RenderAll" "', argument " "2"" of type '" "eCamera const *""'"); 
12548   }
12549   arg2 = reinterpret_cast< eCamera * >(argp2);
12550   eGameObject::RenderAll(arg1,(eCamera const *)arg2);
12551   return Qnil;
12552 fail:
12553   return Qnil;
12554 }
12555 
12556 
12557 SWIGINTERN VALUE
12558 _wrap_EGameObject_delete_all(int argc, VALUE *argv, VALUE self) {
12559   eGrid *arg1 = (eGrid *) 0 ;
12560   void *argp1 = 0 ;
12561   int res1 = 0 ;
12562   
12563   if ((argc < 1) || (argc > 1)) {
12564     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12565   }
12566   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_eGrid, 0 |  0 );
12567   if (!SWIG_IsOK(res1)) {
12568     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eGameObject::DeleteAll" "', argument " "1"" of type '" "eGrid *""'"); 
12569   }
12570   arg1 = reinterpret_cast< eGrid * >(argp1);
12571   eGameObject::DeleteAll(arg1);
12572   return Qnil;
12573 fail:
12574   return Qnil;
12575 }
12576 
12577 
12578 swig_class cENetGameObject;
12579 
12580 SWIGINTERN VALUE
12581 _wrap_ENetGameObject_action_on_quit(int argc, VALUE *argv, VALUE self) {
12582   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
12583   bool result;
12584   void *argp1 = 0 ;
12585   int res1 = 0 ;
12586   VALUE vresult = Qnil;
12587   
12588   if ((argc < 0) || (argc > 0)) {
12589     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12590   }
12591   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
12592   if (!SWIG_IsOK(res1)) {
12593     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionOnQuit" "', argument " "1"" of type '" "eNetGameObject *""'"); 
12594   }
12595   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
12596   result = (bool)(arg1)->ActionOnQuit();
12597   vresult = SWIG_From_bool(static_cast< bool >(result));
12598   return vresult;
12599 fail:
12600   return Qnil;
12601 }
12602 
12603 
12604 SWIGINTERN VALUE
12605 _wrap_ENetGameObject_action_on_delete(int argc, VALUE *argv, VALUE self) {
12606   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
12607   void *argp1 = 0 ;
12608   int res1 = 0 ;
12609   
12610   if ((argc < 0) || (argc > 0)) {
12611     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12612   }
12613   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
12614   if (!SWIG_IsOK(res1)) {
12615     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionOnDelete" "', argument " "1"" of type '" "eNetGameObject *""'"); 
12616   }
12617   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
12618   (arg1)->ActionOnDelete();
12619   return Qnil;
12620 fail:
12621   return Qnil;
12622 }
12623 
12624 
12625 SWIGINTERN VALUE
12626 _wrap_ENetGameObject_init_after_creation(int argc, VALUE *argv, VALUE self) {
12627   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
12628   void *argp1 = 0 ;
12629   int res1 = 0 ;
12630   
12631   if ((argc < 0) || (argc > 0)) {
12632     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12633   }
12634   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
12635   if (!SWIG_IsOK(res1)) {
12636     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitAfterCreation" "', argument " "1"" of type '" "eNetGameObject *""'"); 
12637   }
12638   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
12639   (arg1)->InitAfterCreation();
12640   return Qnil;
12641 fail:
12642   return Qnil;
12643 }
12644 
12645 
12646 SWIGINTERN VALUE
12647 _wrap_ENetGameObject_remove_from_game(int argc, VALUE *argv, VALUE self) {
12648   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
12649   void *argp1 = 0 ;
12650   int res1 = 0 ;
12651   
12652   if ((argc < 0) || (argc > 0)) {
12653     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12654   }
12655   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
12656   if (!SWIG_IsOK(res1)) {
12657     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoveFromGame" "', argument " "1"" of type '" "eNetGameObject *""'"); 
12658   }
12659   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
12660   (arg1)->RemoveFromGame();
12661   return Qnil;
12662 fail:
12663   return Qnil;
12664 }
12665 
12666 
12667 SWIGINTERN VALUE
12668 _wrap_ENetGameObject_write_create(int argc, VALUE *argv, VALUE self) {
12669   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
12670   nMessage *arg2 = 0 ;
12671   void *argp1 = 0 ;
12672   int res1 = 0 ;
12673   void *argp2 = 0 ;
12674   int res2 = 0 ;
12675   
12676   if ((argc < 1) || (argc > 1)) {
12677     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12678   }
12679   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
12680   if (!SWIG_IsOK(res1)) {
12681     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WriteCreate" "', argument " "1"" of type '" "eNetGameObject *""'"); 
12682   }
12683   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
12684   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_nMessage,  0 );
12685   if (!SWIG_IsOK(res2)) {
12686     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WriteCreate" "', argument " "2"" of type '" "nMessage &""'"); 
12687   }
12688   if (!argp2) {
12689     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WriteCreate" "', argument " "2"" of type '" "nMessage &""'"); 
12690   }
12691   arg2 = reinterpret_cast< nMessage * >(argp2);
12692   (arg1)->WriteCreate(*arg2);
12693   return Qnil;
12694 fail:
12695   return Qnil;
12696 }
12697 
12698 
12699 SWIGINTERN VALUE
12700 _wrap_ENetGameObject_write_sync(int argc, VALUE *argv, VALUE self) {
12701   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
12702   nMessage *arg2 = 0 ;
12703   void *argp1 = 0 ;
12704   int res1 = 0 ;
12705   void *argp2 = 0 ;
12706   int res2 = 0 ;
12707   
12708   if ((argc < 1) || (argc > 1)) {
12709     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12710   }
12711   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
12712   if (!SWIG_IsOK(res1)) {
12713     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WriteSync" "', argument " "1"" of type '" "eNetGameObject *""'"); 
12714   }
12715   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
12716   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_nMessage,  0 );
12717   if (!SWIG_IsOK(res2)) {
12718     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WriteSync" "', argument " "2"" of type '" "nMessage &""'"); 
12719   }
12720   if (!argp2) {
12721     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WriteSync" "', argument " "2"" of type '" "nMessage &""'"); 
12722   }
12723   arg2 = reinterpret_cast< nMessage * >(argp2);
12724   (arg1)->WriteSync(*arg2);
12725   return Qnil;
12726 fail:
12727   return Qnil;
12728 }
12729 
12730 
12731 SWIGINTERN VALUE
12732 _wrap_ENetGameObject_read_sync(int argc, VALUE *argv, VALUE self) {
12733   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
12734   nMessage *arg2 = 0 ;
12735   void *argp1 = 0 ;
12736   int res1 = 0 ;
12737   void *argp2 = 0 ;
12738   int res2 = 0 ;
12739   
12740   if ((argc < 1) || (argc > 1)) {
12741     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12742   }
12743   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
12744   if (!SWIG_IsOK(res1)) {
12745     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReadSync" "', argument " "1"" of type '" "eNetGameObject *""'"); 
12746   }
12747   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
12748   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_nMessage,  0 );
12749   if (!SWIG_IsOK(res2)) {
12750     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReadSync" "', argument " "2"" of type '" "nMessage &""'"); 
12751   }
12752   if (!argp2) {
12753     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReadSync" "', argument " "2"" of type '" "nMessage &""'"); 
12754   }
12755   arg2 = reinterpret_cast< nMessage * >(argp2);
12756   (arg1)->ReadSync(*arg2);
12757   return Qnil;
12758 fail:
12759   return Qnil;
12760 }
12761 
12762 
12763 SWIGINTERN VALUE
12764 _wrap_ENetGameObject_clear_to_transmit(int argc, VALUE *argv, VALUE self) {
12765   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
12766   int arg2 ;
12767   bool result;
12768   void *argp1 = 0 ;
12769   int res1 = 0 ;
12770   int val2 ;
12771   int ecode2 = 0 ;
12772   VALUE vresult = Qnil;
12773   
12774   if ((argc < 1) || (argc > 1)) {
12775     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12776   }
12777   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
12778   if (!SWIG_IsOK(res1)) {
12779     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ClearToTransmit" "', argument " "1"" of type '" "eNetGameObject const *""'"); 
12780   }
12781   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
12782   ecode2 = SWIG_AsVal_int(argv[0], &val2);
12783   if (!SWIG_IsOK(ecode2)) {
12784     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ClearToTransmit" "', argument " "2"" of type '" "int""'");
12785   } 
12786   arg2 = static_cast< int >(val2);
12787   result = (bool)((eNetGameObject const *)arg1)->ClearToTransmit(arg2);
12788   vresult = SWIG_From_bool(static_cast< bool >(result));
12789   return vresult;
12790 fail:
12791   return Qnil;
12792 }
12793 
12794 
12795 SWIGINTERN VALUE
12796 _wrap_ENetGameObject_sync_is_new(int argc, VALUE *argv, VALUE self) {
12797   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
12798   nMessage *arg2 = 0 ;
12799   bool result;
12800   void *argp1 = 0 ;
12801   int res1 = 0 ;
12802   void *argp2 = 0 ;
12803   int res2 = 0 ;
12804   VALUE vresult = Qnil;
12805   
12806   if ((argc < 1) || (argc > 1)) {
12807     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12808   }
12809   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
12810   if (!SWIG_IsOK(res1)) {
12811     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SyncIsNew" "', argument " "1"" of type '" "eNetGameObject *""'"); 
12812   }
12813   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
12814   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_nMessage,  0 );
12815   if (!SWIG_IsOK(res2)) {
12816     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SyncIsNew" "', argument " "2"" of type '" "nMessage &""'"); 
12817   }
12818   if (!argp2) {
12819     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SyncIsNew" "', argument " "2"" of type '" "nMessage &""'"); 
12820   }
12821   arg2 = reinterpret_cast< nMessage * >(argp2);
12822   result = (bool)(arg1)->SyncIsNew(*arg2);
12823   vresult = SWIG_From_bool(static_cast< bool >(result));
12824   return vresult;
12825 fail:
12826   return Qnil;
12827 }
12828 
12829 
12830 SWIGINTERN VALUE
12831 _wrap_ENetGameObject_add_ref(int argc, VALUE *argv, VALUE self) {
12832   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
12833   void *argp1 = 0 ;
12834   int res1 = 0 ;
12835   
12836   if ((argc < 0) || (argc > 0)) {
12837     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12838   }
12839   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
12840   if (!SWIG_IsOK(res1)) {
12841     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddRef" "', argument " "1"" of type '" "eNetGameObject *""'"); 
12842   }
12843   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
12844   (arg1)->AddRef();
12845   return Qnil;
12846 fail:
12847   return Qnil;
12848 }
12849 
12850 
12851 SWIGINTERN VALUE
12852 _wrap_ENetGameObject_release(int argc, VALUE *argv, VALUE self) {
12853   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
12854   void *argp1 = 0 ;
12855   int res1 = 0 ;
12856   
12857   if ((argc < 0) || (argc > 0)) {
12858     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12859   }
12860   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
12861   if (!SWIG_IsOK(res1)) {
12862     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Release" "', argument " "1"" of type '" "eNetGameObject *""'"); 
12863   }
12864   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
12865   (arg1)->Release();
12866   return Qnil;
12867 fail:
12868   return Qnil;
12869 }
12870 
12871 
12872 SWIGINTERN VALUE
12873 _wrap_ENetGameObject_send_control(int argc, VALUE *argv, VALUE self) {
12874   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
12875   REAL arg2 ;
12876   uActionPlayer *arg3 = (uActionPlayer *) 0 ;
12877   REAL arg4 ;
12878   void *argp1 = 0 ;
12879   int res1 = 0 ;
12880   float val2 ;
12881   int ecode2 = 0 ;
12882   void *argp3 = 0 ;
12883   int res3 = 0 ;
12884   float val4 ;
12885   int ecode4 = 0 ;
12886   
12887   if ((argc < 3) || (argc > 3)) {
12888     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
12889   }
12890   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
12891   if (!SWIG_IsOK(res1)) {
12892     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SendControl" "', argument " "1"" of type '" "eNetGameObject *""'"); 
12893   }
12894   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
12895   ecode2 = SWIG_AsVal_float(argv[0], &val2);
12896   if (!SWIG_IsOK(ecode2)) {
12897     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SendControl" "', argument " "2"" of type '" "REAL""'");
12898   } 
12899   arg2 = static_cast< REAL >(val2);
12900   res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_uActionPlayer, 0 |  0 );
12901   if (!SWIG_IsOK(res3)) {
12902     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SendControl" "', argument " "3"" of type '" "uActionPlayer *""'"); 
12903   }
12904   arg3 = reinterpret_cast< uActionPlayer * >(argp3);
12905   ecode4 = SWIG_AsVal_float(argv[2], &val4);
12906   if (!SWIG_IsOK(ecode4)) {
12907     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SendControl" "', argument " "4"" of type '" "REAL""'");
12908   } 
12909   arg4 = static_cast< REAL >(val4);
12910   (arg1)->SendControl(arg2,arg3,arg4);
12911   return Qnil;
12912 fail:
12913   return Qnil;
12914 }
12915 
12916 
12917 SWIGINTERN VALUE
12918 _wrap_ENetGameObject_receive_control(int argc, VALUE *argv, VALUE self) {
12919   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
12920   REAL arg2 ;
12921   uActionPlayer *arg3 = (uActionPlayer *) 0 ;
12922   REAL arg4 ;
12923   void *argp1 = 0 ;
12924   int res1 = 0 ;
12925   float val2 ;
12926   int ecode2 = 0 ;
12927   void *argp3 = 0 ;
12928   int res3 = 0 ;
12929   float val4 ;
12930   int ecode4 = 0 ;
12931   
12932   if ((argc < 3) || (argc > 3)) {
12933     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
12934   }
12935   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
12936   if (!SWIG_IsOK(res1)) {
12937     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReceiveControl" "', argument " "1"" of type '" "eNetGameObject *""'"); 
12938   }
12939   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
12940   ecode2 = SWIG_AsVal_float(argv[0], &val2);
12941   if (!SWIG_IsOK(ecode2)) {
12942     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReceiveControl" "', argument " "2"" of type '" "REAL""'");
12943   } 
12944   arg2 = static_cast< REAL >(val2);
12945   res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_uActionPlayer, 0 |  0 );
12946   if (!SWIG_IsOK(res3)) {
12947     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ReceiveControl" "', argument " "3"" of type '" "uActionPlayer *""'"); 
12948   }
12949   arg3 = reinterpret_cast< uActionPlayer * >(argp3);
12950   ecode4 = SWIG_AsVal_float(argv[2], &val4);
12951   if (!SWIG_IsOK(ecode4)) {
12952     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ReceiveControl" "', argument " "4"" of type '" "REAL""'");
12953   } 
12954   arg4 = static_cast< REAL >(val4);
12955   (arg1)->ReceiveControl(arg2,arg3,arg4);
12956   return Qnil;
12957 fail:
12958   return Qnil;
12959 }
12960 
12961 
12962 SWIGINTERN VALUE
12963 _wrap_ENetGameObject_timestep(int argc, VALUE *argv, VALUE self) {
12964   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
12965   REAL arg2 ;
12966   bool result;
12967   void *argp1 = 0 ;
12968   int res1 = 0 ;
12969   float val2 ;
12970   int ecode2 = 0 ;
12971   VALUE vresult = Qnil;
12972   
12973   if ((argc < 1) || (argc > 1)) {
12974     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12975   }
12976   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
12977   if (!SWIG_IsOK(res1)) {
12978     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timestep" "', argument " "1"" of type '" "eNetGameObject *""'"); 
12979   }
12980   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
12981   ecode2 = SWIG_AsVal_float(argv[0], &val2);
12982   if (!SWIG_IsOK(ecode2)) {
12983     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timestep" "', argument " "2"" of type '" "REAL""'");
12984   } 
12985   arg2 = static_cast< REAL >(val2);
12986   result = (bool)(arg1)->Timestep(arg2);
12987   vresult = SWIG_From_bool(static_cast< bool >(result));
12988   return vresult;
12989 fail:
12990   return Qnil;
12991 }
12992 
12993 
12994 SWIGINTERN VALUE
12995 _wrap_ENetGameObject_player(int argc, VALUE *argv, VALUE self) {
12996   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
12997   ePlayerNetID *result = 0 ;
12998   void *argp1 = 0 ;
12999   int res1 = 0 ;
13000   VALUE vresult = Qnil;
13001   
13002   if ((argc < 0) || (argc > 0)) {
13003     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13004   }
13005   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
13006   if (!SWIG_IsOK(res1)) {
13007     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Player" "', argument " "1"" of type '" "eNetGameObject const *""'"); 
13008   }
13009   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
13010   result = (ePlayerNetID *)((eNetGameObject const *)arg1)->Player();
13011   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ePlayerNetID, 0 |  0 );
13012   return vresult;
13013 fail:
13014   return Qnil;
13015 }
13016 
13017 
13018 SWIGINTERN VALUE
13019 _wrap_ENetGameObject_clientside_action(int argc, VALUE *argv, VALUE self) {
13020   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
13021   void *argp1 = 0 ;
13022   int res1 = 0 ;
13023   
13024   if ((argc < 0) || (argc > 0)) {
13025     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13026   }
13027   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
13028   if (!SWIG_IsOK(res1)) {
13029     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clientside_action" "', argument " "1"" of type '" "eNetGameObject *""'"); 
13030   }
13031   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
13032   (arg1)->clientside_action();
13033   return Qnil;
13034 fail:
13035   return Qnil;
13036 }
13037 
13038 
13039 SWIGINTERN VALUE
13040 _wrap_ENetGameObject_lag(int argc, VALUE *argv, VALUE self) {
13041   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
13042   REAL result;
13043   void *argp1 = 0 ;
13044   int res1 = 0 ;
13045   VALUE vresult = Qnil;
13046   
13047   if ((argc < 0) || (argc > 0)) {
13048     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13049   }
13050   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
13051   if (!SWIG_IsOK(res1)) {
13052     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lag" "', argument " "1"" of type '" "eNetGameObject const *""'"); 
13053   }
13054   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
13055   result = (REAL)((eNetGameObject const *)arg1)->Lag();
13056   vresult = SWIG_From_float(static_cast< float >(result));
13057   return vresult;
13058 fail:
13059   return Qnil;
13060 }
13061 
13062 
13063 SWIGINTERN VALUE
13064 _wrap_ENetGameObject_lag_threshold(int argc, VALUE *argv, VALUE self) {
13065   eNetGameObject *arg1 = (eNetGameObject *) 0 ;
13066   REAL result;
13067   void *argp1 = 0 ;
13068   int res1 = 0 ;
13069   VALUE vresult = Qnil;
13070   
13071   if ((argc < 0) || (argc > 0)) {
13072     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13073   }
13074   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eNetGameObject, 0 |  0 );
13075   if (!SWIG_IsOK(res1)) {
13076     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LagThreshold" "', argument " "1"" of type '" "eNetGameObject const *""'"); 
13077   }
13078   arg1 = reinterpret_cast< eNetGameObject * >(argp1);
13079   result = (REAL)((eNetGameObject const *)arg1)->LagThreshold();
13080   vresult = SWIG_From_float(static_cast< float >(result));
13081   return vresult;
13082 fail:
13083   return Qnil;
13084 }
13085 
13086 
13087 swig_class cESensor;
13088 
13089 SWIGINTERN VALUE
13090 _wrap_ESensor_hit_set(int argc, VALUE *argv, VALUE self) {
13091   eSensor *arg1 = (eSensor *) 0 ;
13092   REAL arg2 ;
13093   void *argp1 = 0 ;
13094   int res1 = 0 ;
13095   float val2 ;
13096   int ecode2 = 0 ;
13097   
13098   if ((argc < 1) || (argc > 1)) {
13099     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13100   }
13101   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eSensor, 0 |  0 );
13102   if (!SWIG_IsOK(res1)) {
13103     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hit" "', argument " "1"" of type '" "eSensor *""'"); 
13104   }
13105   arg1 = reinterpret_cast< eSensor * >(argp1);
13106   ecode2 = SWIG_AsVal_float(argv[0], &val2);
13107   if (!SWIG_IsOK(ecode2)) {
13108     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "hit" "', argument " "2"" of type '" "REAL""'");
13109   } 
13110   arg2 = static_cast< REAL >(val2);
13111   if (arg1) (arg1)->hit = arg2;
13112   
13113   return Qnil;
13114 fail:
13115   return Qnil;
13116 }
13117 
13118 
13119 SWIGINTERN VALUE
13120 _wrap_ESensor_hit_get(int argc, VALUE *argv, VALUE self) {
13121   eSensor *arg1 = (eSensor *) 0 ;
13122   REAL result;
13123   void *argp1 = 0 ;
13124   int res1 = 0 ;
13125   VALUE vresult = Qnil;
13126   
13127   if ((argc < 0) || (argc > 0)) {
13128     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13129   }
13130   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eSensor, 0 |  0 );
13131   if (!SWIG_IsOK(res1)) {
13132     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hit" "', argument " "1"" of type '" "eSensor *""'"); 
13133   }
13134   arg1 = reinterpret_cast< eSensor * >(argp1);
13135   result = (REAL) ((arg1)->hit);
13136   vresult = SWIG_From_float(static_cast< float >(result));
13137   return vresult;
13138 fail:
13139   return Qnil;
13140 }
13141 
13142 
13143 SWIGINTERN VALUE
13144 _wrap_ESensor_ehit_set(int argc, VALUE *argv, VALUE self) {
13145   eSensor *arg1 = (eSensor *) 0 ;
13146   eHalfEdge *arg2 = (eHalfEdge *) 0 ;
13147   void *argp1 = 0 ;
13148   int res1 = 0 ;
13149   void *argp2 = 0 ;
13150   int res2 = 0 ;
13151   
13152   if ((argc < 1) || (argc > 1)) {
13153     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13154   }
13155   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eSensor, 0 |  0 );
13156   if (!SWIG_IsOK(res1)) {
13157     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ehit" "', argument " "1"" of type '" "eSensor *""'"); 
13158   }
13159   arg1 = reinterpret_cast< eSensor * >(argp1);
13160   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eHalfEdge, SWIG_POINTER_DISOWN |  0 );
13161   if (!SWIG_IsOK(res2)) {
13162     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ehit" "', argument " "2"" of type '" "eHalfEdge *""'"); 
13163   }
13164   arg2 = reinterpret_cast< eHalfEdge * >(argp2);
13165   if (arg1) (arg1)->ehit = arg2;
13166   
13167   return Qnil;
13168 fail:
13169   return Qnil;
13170 }
13171 
13172 
13173 SWIGINTERN VALUE
13174 _wrap_ESensor_ehit_get(int argc, VALUE *argv, VALUE self) {
13175   eSensor *arg1 = (eSensor *) 0 ;
13176   eHalfEdge *result = 0 ;
13177   void *argp1 = 0 ;
13178   int res1 = 0 ;
13179   VALUE vresult = Qnil;
13180   
13181   if ((argc < 0) || (argc > 0)) {
13182     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13183   }
13184   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eSensor, 0 |  0 );
13185   if (!SWIG_IsOK(res1)) {
13186     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ehit" "', argument " "1"" of type '" "eSensor *""'"); 
13187   }
13188   arg1 = reinterpret_cast< eSensor * >(argp1);
13189   result = (eHalfEdge *) ((arg1)->ehit);
13190   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eHalfEdge, 0 |  0 );
13191   return vresult;
13192 fail:
13193   return Qnil;
13194 }
13195 
13196 
13197 SWIGINTERN VALUE
13198 _wrap_ESensor_lr_set(int argc, VALUE *argv, VALUE self) {
13199   eSensor *arg1 = (eSensor *) 0 ;
13200   int arg2 ;
13201   void *argp1 = 0 ;
13202   int res1 = 0 ;
13203   int val2 ;
13204   int ecode2 = 0 ;
13205   
13206   if ((argc < 1) || (argc > 1)) {
13207     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13208   }
13209   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eSensor, 0 |  0 );
13210   if (!SWIG_IsOK(res1)) {
13211     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lr" "', argument " "1"" of type '" "eSensor *""'"); 
13212   }
13213   arg1 = reinterpret_cast< eSensor * >(argp1);
13214   ecode2 = SWIG_AsVal_int(argv[0], &val2);
13215   if (!SWIG_IsOK(ecode2)) {
13216     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lr" "', argument " "2"" of type '" "int""'");
13217   } 
13218   arg2 = static_cast< int >(val2);
13219   if (arg1) (arg1)->lr = arg2;
13220   
13221   return Qnil;
13222 fail:
13223   return Qnil;
13224 }
13225 
13226 
13227 SWIGINTERN VALUE
13228 _wrap_ESensor_lr_get(int argc, VALUE *argv, VALUE self) {
13229   eSensor *arg1 = (eSensor *) 0 ;
13230   int result;
13231   void *argp1 = 0 ;
13232   int res1 = 0 ;
13233   VALUE vresult = Qnil;
13234   
13235   if ((argc < 0) || (argc > 0)) {
13236     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13237   }
13238   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eSensor, 0 |  0 );
13239   if (!SWIG_IsOK(res1)) {
13240     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lr" "', argument " "1"" of type '" "eSensor *""'"); 
13241   }
13242   arg1 = reinterpret_cast< eSensor * >(argp1);
13243   result = (int) ((arg1)->lr);
13244   vresult = SWIG_From_int(static_cast< int >(result));
13245   return vresult;
13246 fail:
13247   return Qnil;
13248 }
13249 
13250 
13251 SWIGINTERN VALUE
13252 _wrap_ESensor_before_hit_set(int argc, VALUE *argv, VALUE self) {
13253   eSensor *arg1 = (eSensor *) 0 ;
13254   eCoord arg2 ;
13255   void *argp1 = 0 ;
13256   int res1 = 0 ;
13257   void *argp2 ;
13258   int res2 = 0 ;
13259   
13260   if ((argc < 1) || (argc > 1)) {
13261     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13262   }
13263   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eSensor, 0 |  0 );
13264   if (!SWIG_IsOK(res1)) {
13265     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "before_hit" "', argument " "1"" of type '" "eSensor *""'"); 
13266   }
13267   arg1 = reinterpret_cast< eSensor * >(argp1);
13268   {
13269     res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_eCoord,  0 );
13270     if (!SWIG_IsOK(res2)) {
13271       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "before_hit" "', argument " "2"" of type '" "eCoord""'"); 
13272     }  
13273     if (!argp2) {
13274       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "before_hit" "', argument " "2"" of type '" "eCoord""'");
13275     } else {
13276       arg2 = *(reinterpret_cast< eCoord * >(argp2));
13277     }
13278   }
13279   if (arg1) (arg1)->before_hit = arg2;
13280   
13281   return Qnil;
13282 fail:
13283   return Qnil;
13284 }
13285 
13286 
13287 SWIGINTERN VALUE
13288 _wrap_ESensor_before_hit_get(int argc, VALUE *argv, VALUE self) {
13289   eSensor *arg1 = (eSensor *) 0 ;
13290   eCoord result;
13291   void *argp1 = 0 ;
13292   int res1 = 0 ;
13293   VALUE vresult = Qnil;
13294   
13295   if ((argc < 0) || (argc > 0)) {
13296     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13297   }
13298   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eSensor, 0 |  0 );
13299   if (!SWIG_IsOK(res1)) {
13300     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "before_hit" "', argument " "1"" of type '" "eSensor *""'"); 
13301   }
13302   arg1 = reinterpret_cast< eSensor * >(argp1);
13303   result =  ((arg1)->before_hit);
13304   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
13305   return vresult;
13306 fail:
13307   return Qnil;
13308 }
13309 
13310 
13311 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
13312 SWIGINTERN VALUE
13313 _wrap_ESensor_allocate(VALUE self) {
13314 #else
13315   SWIGINTERN VALUE
13316   _wrap_ESensor_allocate(int argc, VALUE *argv, VALUE self) {
13317 #endif
13318     
13319     
13320     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_eSensor);
13321 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
13322     rb_obj_call_init(vresult, argc, argv);
13323 #endif
13324     return vresult;
13325   }
13326   
13327 
13328 SWIGINTERN VALUE
13329 _wrap_new_ESensor(int argc, VALUE *argv, VALUE self) {
13330   eGameObject *arg1 = (eGameObject *) 0 ;
13331   eCoord *arg2 = 0 ;
13332   eCoord *arg3 = 0 ;
13333   eSensor *result = 0 ;
13334   void *argp1 = 0 ;
13335   int res1 = 0 ;
13336   void *argp2 ;
13337   int res2 = 0 ;
13338   void *argp3 ;
13339   int res3 = 0 ;
13340   const char *classname SWIGUNUSED = "Armagetronad::ESensor";
13341   
13342   if ((argc < 3) || (argc > 3)) {
13343     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
13344   }
13345   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
13346   if (!SWIG_IsOK(res1)) {
13347     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "eSensor" "', argument " "1"" of type '" "eGameObject *""'"); 
13348   }
13349   arg1 = reinterpret_cast< eGameObject * >(argp1);
13350   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_eCoord,  0 );
13351   if (!SWIG_IsOK(res2)) {
13352     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "eSensor" "', argument " "2"" of type '" "eCoord const &""'"); 
13353   }
13354   if (!argp2) {
13355     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "eSensor" "', argument " "2"" of type '" "eCoord const &""'"); 
13356   }
13357   arg2 = reinterpret_cast< eCoord * >(argp2);
13358   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_eCoord,  0 );
13359   if (!SWIG_IsOK(res3)) {
13360     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "eSensor" "', argument " "3"" of type '" "eCoord const &""'"); 
13361   }
13362   if (!argp3) {
13363     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "eSensor" "', argument " "3"" of type '" "eCoord const &""'"); 
13364   }
13365   arg3 = reinterpret_cast< eCoord * >(argp3);
13366   result = (eSensor *)new eSensor(arg1,(eCoord const &)*arg2,(eCoord const &)*arg3);DATA_PTR(self) = result;
13367   
13368   return self;
13369 fail:
13370   return Qnil;
13371 }
13372 
13373 
13374 SWIGINTERN VALUE
13375 _wrap_ESensor_pass_edge__SWIG_0(int argc, VALUE *argv, VALUE self) {
13376   eSensor *arg1 = (eSensor *) 0 ;
13377   eWall *arg2 = (eWall *) 0 ;
13378   REAL arg3 ;
13379   REAL arg4 ;
13380   int arg5 ;
13381   void *argp1 = 0 ;
13382   int res1 = 0 ;
13383   void *argp2 = 0 ;
13384   int res2 = 0 ;
13385   float val3 ;
13386   int ecode3 = 0 ;
13387   float val4 ;
13388   int ecode4 = 0 ;
13389   int val5 ;
13390   int ecode5 = 0 ;
13391   
13392   if ((argc < 4) || (argc > 4)) {
13393     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
13394   }
13395   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eSensor, 0 |  0 );
13396   if (!SWIG_IsOK(res1)) {
13397     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PassEdge" "', argument " "1"" of type '" "eSensor *""'"); 
13398   }
13399   arg1 = reinterpret_cast< eSensor * >(argp1);
13400   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eWall, 0 |  0 );
13401   if (!SWIG_IsOK(res2)) {
13402     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PassEdge" "', argument " "2"" of type '" "eWall const *""'"); 
13403   }
13404   arg2 = reinterpret_cast< eWall * >(argp2);
13405   ecode3 = SWIG_AsVal_float(argv[1], &val3);
13406   if (!SWIG_IsOK(ecode3)) {
13407     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PassEdge" "', argument " "3"" of type '" "REAL""'");
13408   } 
13409   arg3 = static_cast< REAL >(val3);
13410   ecode4 = SWIG_AsVal_float(argv[2], &val4);
13411   if (!SWIG_IsOK(ecode4)) {
13412     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PassEdge" "', argument " "4"" of type '" "REAL""'");
13413   } 
13414   arg4 = static_cast< REAL >(val4);
13415   ecode5 = SWIG_AsVal_int(argv[3], &val5);
13416   if (!SWIG_IsOK(ecode5)) {
13417     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PassEdge" "', argument " "5"" of type '" "int""'");
13418   } 
13419   arg5 = static_cast< int >(val5);
13420   (arg1)->PassEdge((eWall const *)arg2,arg3,arg4,arg5);
13421   return Qnil;
13422 fail:
13423   return Qnil;
13424 }
13425 
13426 
13427 SWIGINTERN VALUE
13428 _wrap_ESensor_pass_edge__SWIG_1(int argc, VALUE *argv, VALUE self) {
13429   eSensor *arg1 = (eSensor *) 0 ;
13430   eWall *arg2 = (eWall *) 0 ;
13431   REAL arg3 ;
13432   REAL arg4 ;
13433   void *argp1 = 0 ;
13434   int res1 = 0 ;
13435   void *argp2 = 0 ;
13436   int res2 = 0 ;
13437   float val3 ;
13438   int ecode3 = 0 ;
13439   float val4 ;
13440   int ecode4 = 0 ;
13441   
13442   if ((argc < 3) || (argc > 3)) {
13443     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
13444   }
13445   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eSensor, 0 |  0 );
13446   if (!SWIG_IsOK(res1)) {
13447     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PassEdge" "', argument " "1"" of type '" "eSensor *""'"); 
13448   }
13449   arg1 = reinterpret_cast< eSensor * >(argp1);
13450   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eWall, 0 |  0 );
13451   if (!SWIG_IsOK(res2)) {
13452     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PassEdge" "', argument " "2"" of type '" "eWall const *""'"); 
13453   }
13454   arg2 = reinterpret_cast< eWall * >(argp2);
13455   ecode3 = SWIG_AsVal_float(argv[1], &val3);
13456   if (!SWIG_IsOK(ecode3)) {
13457     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PassEdge" "', argument " "3"" of type '" "REAL""'");
13458   } 
13459   arg3 = static_cast< REAL >(val3);
13460   ecode4 = SWIG_AsVal_float(argv[2], &val4);
13461   if (!SWIG_IsOK(ecode4)) {
13462     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PassEdge" "', argument " "4"" of type '" "REAL""'");
13463   } 
13464   arg4 = static_cast< REAL >(val4);
13465   (arg1)->PassEdge((eWall const *)arg2,arg3,arg4);
13466   return Qnil;
13467 fail:
13468   return Qnil;
13469 }
13470 
13471 
13472 SWIGINTERN VALUE _wrap_ESensor_pass_edge(int nargs, VALUE *args, VALUE self) {
13473   int argc;
13474   VALUE argv[6];
13475   int ii;
13476   
13477   argc = nargs + 1;
13478   argv[0] = self;
13479   if (argc > 6) SWIG_fail;
13480   for (ii = 1; (ii < argc); ii++) {
13481     argv[ii] = args[ii-1];
13482   }
13483   if (argc == 4) {
13484     int _v;
13485     void *vptr = 0;
13486     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eSensor, 0);
13487     _v = SWIG_CheckState(res);
13488     if (_v) {
13489       void *vptr = 0;
13490       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eWall, 0);
13491       _v = SWIG_CheckState(res);
13492       if (_v) {
13493         {
13494           int res = SWIG_AsVal_float(argv[2], NULL);
13495           _v = SWIG_CheckState(res);
13496         }
13497         if (_v) {
13498           {
13499             int res = SWIG_AsVal_float(argv[3], NULL);
13500             _v = SWIG_CheckState(res);
13501           }
13502           if (_v) {
13503             return _wrap_ESensor_pass_edge__SWIG_1(nargs, args, self);
13504           }
13505         }
13506       }
13507     }
13508   }
13509   if (argc == 5) {
13510     int _v;
13511     void *vptr = 0;
13512     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eSensor, 0);
13513     _v = SWIG_CheckState(res);
13514     if (_v) {
13515       void *vptr = 0;
13516       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eWall, 0);
13517       _v = SWIG_CheckState(res);
13518       if (_v) {
13519         {
13520           int res = SWIG_AsVal_float(argv[2], NULL);
13521           _v = SWIG_CheckState(res);
13522         }
13523         if (_v) {
13524           {
13525             int res = SWIG_AsVal_float(argv[3], NULL);
13526             _v = SWIG_CheckState(res);
13527           }
13528           if (_v) {
13529             {
13530               int res = SWIG_AsVal_int(argv[4], NULL);
13531               _v = SWIG_CheckState(res);
13532             }
13533             if (_v) {
13534               return _wrap_ESensor_pass_edge__SWIG_0(nargs, args, self);
13535             }
13536           }
13537         }
13538       }
13539     }
13540   }
13541   
13542 fail:
13543   rb_raise(rb_eArgError, "No matching function for overloaded 'ESensor_pass_edge'");
13544   return Qnil;
13545 }
13546 
13547 
13548 SWIGINTERN VALUE
13549 _wrap_ESensor_detect(int argc, VALUE *argv, VALUE self) {
13550   eSensor *arg1 = (eSensor *) 0 ;
13551   REAL arg2 ;
13552   void *argp1 = 0 ;
13553   int res1 = 0 ;
13554   float val2 ;
13555   int ecode2 = 0 ;
13556   
13557   if ((argc < 1) || (argc > 1)) {
13558     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13559   }
13560   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eSensor, 0 |  0 );
13561   if (!SWIG_IsOK(res1)) {
13562     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "detect" "', argument " "1"" of type '" "eSensor *""'"); 
13563   }
13564   arg1 = reinterpret_cast< eSensor * >(argp1);
13565   ecode2 = SWIG_AsVal_float(argv[0], &val2);
13566   if (!SWIG_IsOK(ecode2)) {
13567     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "detect" "', argument " "2"" of type '" "REAL""'");
13568   } 
13569   arg2 = static_cast< REAL >(val2);
13570   (arg1)->detect(arg2);
13571   return Qnil;
13572 fail:
13573   return Qnil;
13574 }
13575 
13576 
13577 SWIGINTERN VALUE
13578 _wrap_ESensor_set_current_face(int argc, VALUE *argv, VALUE self) {
13579   eSensor *arg1 = (eSensor *) 0 ;
13580   eFace *arg2 = (eFace *) 0 ;
13581   void *argp1 = 0 ;
13582   int res1 = 0 ;
13583   void *argp2 = 0 ;
13584   int res2 = 0 ;
13585   
13586   if ((argc < 1) || (argc > 1)) {
13587     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13588   }
13589   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eSensor, 0 |  0 );
13590   if (!SWIG_IsOK(res1)) {
13591     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCurrentFace" "', argument " "1"" of type '" "eSensor *""'"); 
13592   }
13593   arg1 = reinterpret_cast< eSensor * >(argp1);
13594   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eFace, 0 |  0 );
13595   if (!SWIG_IsOK(res2)) {
13596     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCurrentFace" "', argument " "2"" of type '" "eFace *""'"); 
13597   }
13598   arg2 = reinterpret_cast< eFace * >(argp2);
13599   (arg1)->SetCurrentFace(arg2);
13600   return Qnil;
13601 fail:
13602   return Qnil;
13603 }
13604 
13605 
13606 SWIGINTERN VALUE
13607 _wrap_ESensor_set_inverse_speed(int argc, VALUE *argv, VALUE self) {
13608   eSensor *arg1 = (eSensor *) 0 ;
13609   REAL arg2 ;
13610   eSensor *result = 0 ;
13611   void *argp1 = 0 ;
13612   int res1 = 0 ;
13613   float val2 ;
13614   int ecode2 = 0 ;
13615   VALUE vresult = Qnil;
13616   
13617   if ((argc < 1) || (argc > 1)) {
13618     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13619   }
13620   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eSensor, 0 |  0 );
13621   if (!SWIG_IsOK(res1)) {
13622     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetInverseSpeed" "', argument " "1"" of type '" "eSensor *""'"); 
13623   }
13624   arg1 = reinterpret_cast< eSensor * >(argp1);
13625   ecode2 = SWIG_AsVal_float(argv[0], &val2);
13626   if (!SWIG_IsOK(ecode2)) {
13627     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetInverseSpeed" "', argument " "2"" of type '" "REAL""'");
13628   } 
13629   arg2 = static_cast< REAL >(val2);
13630   {
13631     eSensor &_result_ref = (arg1)->SetInverseSpeed(arg2);
13632     result = (eSensor *) &_result_ref;
13633   }
13634   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eSensor, 0 |  0 );
13635   return vresult;
13636 fail:
13637   return Qnil;
13638 }
13639 
13640 
13641 SWIGINTERN VALUE
13642 _wrap_ESensor_get_inverse_speed__SWIG_0(int argc, VALUE *argv, VALUE self) {
13643   eSensor *arg1 = (eSensor *) 0 ;
13644   REAL result;
13645   void *argp1 = 0 ;
13646   int res1 = 0 ;
13647   VALUE vresult = Qnil;
13648   
13649   if ((argc < 0) || (argc > 0)) {
13650     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13651   }
13652   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eSensor, 0 |  0 );
13653   if (!SWIG_IsOK(res1)) {
13654     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetInverseSpeed" "', argument " "1"" of type '" "eSensor const *""'"); 
13655   }
13656   arg1 = reinterpret_cast< eSensor * >(argp1);
13657   result = (REAL)((eSensor const *)arg1)->GetInverseSpeed();
13658   vresult = SWIG_From_float(static_cast< float >(result));
13659   return vresult;
13660 fail:
13661   return Qnil;
13662 }
13663 
13664 
13665 SWIGINTERN VALUE
13666 _wrap_ESensor_get_inverse_speed__SWIG_1(int argc, VALUE *argv, VALUE self) {
13667   eSensor *arg1 = (eSensor *) 0 ;
13668   REAL *arg2 = 0 ;
13669   eSensor *result = 0 ;
13670   void *argp1 = 0 ;
13671   int res1 = 0 ;
13672   void *argp2 = 0 ;
13673   int res2 = 0 ;
13674   VALUE vresult = Qnil;
13675   
13676   if ((argc < 1) || (argc > 1)) {
13677     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13678   }
13679   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_eSensor, 0 |  0 );
13680   if (!SWIG_IsOK(res1)) {
13681     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetInverseSpeed" "', argument " "1"" of type '" "eSensor const *""'"); 
13682   }
13683   arg1 = reinterpret_cast< eSensor * >(argp1);
13684   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_float,  0 );
13685   if (!SWIG_IsOK(res2)) {
13686     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetInverseSpeed" "', argument " "2"" of type '" "REAL &""'"); 
13687   }
13688   if (!argp2) {
13689     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetInverseSpeed" "', argument " "2"" of type '" "REAL &""'"); 
13690   }
13691   arg2 = reinterpret_cast< REAL * >(argp2);
13692   {
13693     eSensor const &_result_ref = ((eSensor const *)arg1)->GetInverseSpeed(*arg2);
13694     result = (eSensor *) &_result_ref;
13695   }
13696   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eSensor, 0 |  0 );
13697   return vresult;
13698 fail:
13699   return Qnil;
13700 }
13701 
13702 
13703 SWIGINTERN VALUE _wrap_ESensor_get_inverse_speed(int nargs, VALUE *args, VALUE self) {
13704   int argc;
13705   VALUE argv[3];
13706   int ii;
13707   
13708   argc = nargs + 1;
13709   argv[0] = self;
13710   if (argc > 3) SWIG_fail;
13711   for (ii = 1; (ii < argc); ii++) {
13712     argv[ii] = args[ii-1];
13713   }
13714   if (argc == 1) {
13715     int _v;
13716     void *vptr = 0;
13717     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eSensor, 0);
13718     _v = SWIG_CheckState(res);
13719     if (_v) {
13720       return _wrap_ESensor_get_inverse_speed__SWIG_0(nargs, args, self);
13721     }
13722   }
13723   if (argc == 2) {
13724     int _v;
13725     void *vptr = 0;
13726     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eSensor, 0);
13727     _v = SWIG_CheckState(res);
13728     if (_v) {
13729       void *vptr = 0;
13730       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
13731       _v = SWIG_CheckState(res);
13732       if (_v) {
13733         return _wrap_ESensor_get_inverse_speed__SWIG_1(nargs, args, self);
13734       }
13735     }
13736   }
13737   
13738 fail:
13739   rb_raise(rb_eArgError, "No matching function for overloaded 'ESensor_get_inverse_speed'");
13740   return Qnil;
13741 }
13742 
13743 
13744 SWIGINTERN void
13745 free_eSensor(eSensor *arg1) {
13746     delete arg1;
13747 }
13748 
13749 swig_class cGSimpleAI;
13750 
13751 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
13752 SWIGINTERN VALUE
13753 _wrap_GSimpleAI_allocate(VALUE self) {
13754 #else
13755   SWIGINTERN VALUE
13756   _wrap_GSimpleAI_allocate(int argc, VALUE *argv, VALUE self) {
13757 #endif
13758     
13759     
13760     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_gSimpleAI);
13761 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
13762     rb_obj_call_init(vresult, argc, argv);
13763 #endif
13764     return vresult;
13765   }
13766   
13767 
13768 SWIGINTERN VALUE
13769 _wrap_new_GSimpleAI(int argc, VALUE *argv, VALUE self) {
13770   VALUE arg1 = (VALUE) 0 ;
13771   gSimpleAI *result = 0 ;
13772   const char *classname SWIGUNUSED = "Armagetronad::GSimpleAI";
13773   
13774   if ((argc < 0) || (argc > 0)) {
13775     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13776   }
13777   arg1 = self;
13778   if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
13779     /* subclassed */
13780     result = (gSimpleAI *)new SwigDirector_GSimpleAI(arg1); 
13781   } else {
13782     rb_raise(rb_eNameError,"accessing abstract class or protected constructor"); 
13783     return Qnil;
13784   }
13785   DATA_PTR(self) = result;
13786   
13787   return self;
13788 fail:
13789   return Qnil;
13790 }
13791 
13792 
13793 SWIGINTERN VALUE
13794 _wrap_GSimpleAI_think(int argc, VALUE *argv, VALUE self) {
13795   gSimpleAI *arg1 = (gSimpleAI *) 0 ;
13796   REAL result;
13797   void *argp1 = 0 ;
13798   int res1 = 0 ;
13799   VALUE vresult = Qnil;
13800   
13801   if ((argc < 0) || (argc > 0)) {
13802     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13803   }
13804   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gSimpleAI, 0 |  0 );
13805   if (!SWIG_IsOK(res1)) {
13806     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Think" "', argument " "1"" of type '" "gSimpleAI *""'"); 
13807   }
13808   arg1 = reinterpret_cast< gSimpleAI * >(argp1);
13809   result = (REAL)(arg1)->Think();
13810   vresult = SWIG_From_float(static_cast< float >(result));
13811   return vresult;
13812 fail:
13813   return Qnil;
13814 }
13815 
13816 
13817 SWIGINTERN void
13818 free_gSimpleAI(gSimpleAI *arg1) {
13819     delete arg1;
13820 }
13821 
13822 SWIGINTERN VALUE
13823 _wrap_GSimpleAI_object(int argc, VALUE *argv, VALUE self) {
13824   gSimpleAI *arg1 = (gSimpleAI *) 0 ;
13825   gCycle *result = 0 ;
13826   void *argp1 = 0 ;
13827   int res1 = 0 ;
13828   VALUE vresult = Qnil;
13829   
13830   if ((argc < 0) || (argc > 0)) {
13831     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13832   }
13833   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gSimpleAI, 0 |  0 );
13834   if (!SWIG_IsOK(res1)) {
13835     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object" "', argument " "1"" of type '" "gSimpleAI *""'"); 
13836   }
13837   arg1 = reinterpret_cast< gSimpleAI * >(argp1);
13838   result = (gCycle *)(arg1)->Object();
13839   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gCycle, 0 |  0 );
13840   return vresult;
13841 fail:
13842   return Qnil;
13843 }
13844 
13845 
13846 SWIGINTERN VALUE
13847 _wrap_GSimpleAI_set_object(int argc, VALUE *argv, VALUE self) {
13848   gSimpleAI *arg1 = (gSimpleAI *) 0 ;
13849   gCycle *arg2 = (gCycle *) 0 ;
13850   void *argp1 = 0 ;
13851   int res1 = 0 ;
13852   void *argp2 = 0 ;
13853   int res2 = 0 ;
13854   
13855   if ((argc < 1) || (argc > 1)) {
13856     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13857   }
13858   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gSimpleAI, 0 |  0 );
13859   if (!SWIG_IsOK(res1)) {
13860     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetObject" "', argument " "1"" of type '" "gSimpleAI *""'"); 
13861   }
13862   arg1 = reinterpret_cast< gSimpleAI * >(argp1);
13863   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_gCycle, 0 |  0 );
13864   if (!SWIG_IsOK(res2)) {
13865     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetObject" "', argument " "2"" of type '" "gCycle *""'"); 
13866   }
13867   arg2 = reinterpret_cast< gCycle * >(argp2);
13868   (arg1)->SetObject(arg2);
13869   return Qnil;
13870 fail:
13871   return Qnil;
13872 }
13873 
13874 
13875 SWIGINTERN VALUE
13876 _wrap_GSimpleAI_do_think(int argc, VALUE *argv, VALUE self) {
13877   gSimpleAI *arg1 = (gSimpleAI *) 0 ;
13878   REAL result;
13879   void *argp1 = 0 ;
13880   int res1 = 0 ;
13881   Swig::Director *director = 0;
13882   bool upcall = false;
13883   SwigDirector_GSimpleAI *darg = 0;
13884   VALUE vresult = Qnil;
13885   
13886   if ((argc < 0) || (argc > 0)) {
13887     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13888   }
13889   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gSimpleAI, 0 |  0 );
13890   if (!SWIG_IsOK(res1)) {
13891     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoThink" "', argument " "1"" of type '" "gSimpleAI *""'"); 
13892   }
13893   arg1 = reinterpret_cast< gSimpleAI * >(argp1);
13894   director = dynamic_cast<Swig::Director *>(arg1);
13895   upcall = (director && (director->swig_get_self() == self));
13896   try {
13897     darg = dynamic_cast<SwigDirector_GSimpleAI *>(arg1);
13898     if (upcall) {
13899       Swig::DirectorPureVirtualException::raise("gSimpleAI::DoThink");
13900     } else {
13901       result = (REAL)(darg)->DoThink();
13902     }
13903   } catch (Swig::DirectorException& e) {
13904     rb_exc_raise(e.getError());
13905     SWIG_fail;
13906   }
13907   vresult = SWIG_From_float(static_cast< float >(result));
13908   return vresult;
13909 fail:
13910   return Qnil;
13911 }
13912 
13913 
13914 SWIGINTERN VALUE
13915 _wrap_disown_GSimpleAI(int argc, VALUE *argv, VALUE self) {
13916   gSimpleAI *arg1 = (gSimpleAI *) 0 ;
13917   void *argp1 = 0 ;
13918   int res1 = 0 ;
13919   
13920   if ((argc < 1) || (argc > 1)) {
13921     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13922   }
13923   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_gSimpleAI, 0 |  0 );
13924   if (!SWIG_IsOK(res1)) {
13925     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_GSimpleAI" "', argument " "1"" of type '" "gSimpleAI *""'"); 
13926   }
13927   arg1 = reinterpret_cast< gSimpleAI * >(argp1);
13928   {
13929     Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
13930     if (director) director->swig_disown();
13931   }
13932   
13933   return Qnil;
13934 fail:
13935   return Qnil;
13936 }
13937 
13938 
13939 swig_class cGSimpleAIFactory;
13940 
13941 SWIGINTERN VALUE
13942 _wrap_GSimpleAIFactory_create(int argc, VALUE *argv, VALUE self) {
13943   gSimpleAIFactory *arg1 = (gSimpleAIFactory *) 0 ;
13944   gCycle *arg2 = (gCycle *) 0 ;
13945   gSimpleAI *result = 0 ;
13946   void *argp1 = 0 ;
13947   int res1 = 0 ;
13948   void *argp2 = 0 ;
13949   int res2 = 0 ;
13950   Swig::Director *director = 0;
13951   VALUE vresult = Qnil;
13952   
13953   if ((argc < 1) || (argc > 1)) {
13954     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13955   }
13956   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gSimpleAIFactory, 0 |  0 );
13957   if (!SWIG_IsOK(res1)) {
13958     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Create" "', argument " "1"" of type '" "gSimpleAIFactory const *""'"); 
13959   }
13960   arg1 = reinterpret_cast< gSimpleAIFactory * >(argp1);
13961   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_gCycle, 0 |  0 );
13962   if (!SWIG_IsOK(res2)) {
13963     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Create" "', argument " "2"" of type '" "gCycle *""'"); 
13964   }
13965   arg2 = reinterpret_cast< gCycle * >(argp2);
13966   result = (gSimpleAI *)((gSimpleAIFactory const *)arg1)->Create(arg2);
13967   director = dynamic_cast<Swig::Director *>(result);
13968   if (director) {
13969     vresult = director->swig_get_self();
13970   } else {
13971     vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gSimpleAI, 0 |  0 );
13972   }
13973   return vresult;
13974 fail:
13975   return Qnil;
13976 }
13977 
13978 
13979 SWIGINTERN VALUE
13980 _wrap_GSimpleAIFactory_get(int argc, VALUE *argv, VALUE self) {
13981   gSimpleAIFactory *result = 0 ;
13982   Swig::Director *director = 0;
13983   VALUE vresult = Qnil;
13984   
13985   if ((argc < 0) || (argc > 0)) {
13986     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13987   }
13988   result = (gSimpleAIFactory *)gSimpleAIFactory::Get();
13989   director = dynamic_cast<Swig::Director *>(result);
13990   if (director) {
13991     vresult = director->swig_get_self();
13992   } else {
13993     vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gSimpleAIFactory, 0 |  0 );
13994   }
13995   return vresult;
13996 fail:
13997   return Qnil;
13998 }
13999 
14000 
14001 SWIGINTERN VALUE
14002 _wrap_GSimpleAIFactory_set(int argc, VALUE *argv, VALUE self) {
14003   gSimpleAIFactory *arg1 = (gSimpleAIFactory *) 0 ;
14004   void *argp1 = 0 ;
14005   int res1 = 0 ;
14006   
14007   if ((argc < 1) || (argc > 1)) {
14008     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14009   }
14010   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_gSimpleAIFactory, 0 |  0 );
14011   if (!SWIG_IsOK(res1)) {
14012     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gSimpleAIFactory::Set" "', argument " "1"" of type '" "gSimpleAIFactory *""'"); 
14013   }
14014   arg1 = reinterpret_cast< gSimpleAIFactory * >(argp1);
14015   gSimpleAIFactory::Set(arg1);
14016   return Qnil;
14017 fail:
14018   return Qnil;
14019 }
14020 
14021 
14022 SWIGINTERN VALUE
14023 _wrap_GSimpleAIFactory_do_create(int argc, VALUE *argv, VALUE self) {
14024   gSimpleAIFactory *arg1 = (gSimpleAIFactory *) 0 ;
14025   gSimpleAI *result = 0 ;
14026   void *argp1 = 0 ;
14027   int res1 = 0 ;
14028   Swig::Director *director = 0;
14029   bool upcall = false;
14030   SwigDirector_GSimpleAIFactory *darg = 0;
14031   VALUE vresult = Qnil;
14032   
14033   if ((argc < 0) || (argc > 0)) {
14034     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14035   }
14036   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gSimpleAIFactory, 0 |  0 );
14037   if (!SWIG_IsOK(res1)) {
14038     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoCreate" "', argument " "1"" of type '" "gSimpleAIFactory const *""'"); 
14039   }
14040   arg1 = reinterpret_cast< gSimpleAIFactory * >(argp1);
14041   director = dynamic_cast<Swig::Director *>(arg1);
14042   upcall = (director && (director->swig_get_self() == self));
14043   try {
14044     darg = dynamic_cast<SwigDirector_GSimpleAIFactory *>(arg1);
14045     if (upcall) {
14046       Swig::DirectorPureVirtualException::raise("gSimpleAIFactory::DoCreate");
14047     } else {
14048       result = (gSimpleAI *)((SwigDirector_GSimpleAIFactory const *)darg)->DoCreate();
14049     }
14050   } catch (Swig::DirectorException& e) {
14051     rb_exc_raise(e.getError());
14052     SWIG_fail;
14053   }
14054   director = dynamic_cast<Swig::Director *>(result);
14055   if (director) {
14056     vresult = director->swig_get_self();
14057   } else {
14058     vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gSimpleAI, 0 |  0 );
14059   }
14060   return vresult;
14061 fail:
14062   return Qnil;
14063 }
14064 
14065 
14066 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
14067 SWIGINTERN VALUE
14068 _wrap_GSimpleAIFactory_allocate(VALUE self) {
14069 #else
14070   SWIGINTERN VALUE
14071   _wrap_GSimpleAIFactory_allocate(int argc, VALUE *argv, VALUE self) {
14072 #endif
14073     
14074     
14075     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_gSimpleAIFactory);
14076 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
14077     rb_obj_call_init(vresult, argc, argv);
14078 #endif
14079     return vresult;
14080   }
14081   
14082 
14083 SWIGINTERN VALUE
14084 _wrap_new_GSimpleAIFactory(int argc, VALUE *argv, VALUE self) {
14085   VALUE arg1 = (VALUE) 0 ;
14086   gSimpleAIFactory *result = 0 ;
14087   const char *classname SWIGUNUSED = "Armagetronad::GSimpleAIFactory";
14088   
14089   if ((argc < 0) || (argc > 0)) {
14090     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14091   }
14092   arg1 = self;
14093   if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
14094     /* subclassed */
14095     result = (gSimpleAIFactory *)new SwigDirector_GSimpleAIFactory(arg1); 
14096   } else {
14097     rb_raise(rb_eNameError,"accessing abstract class or protected constructor"); 
14098     return Qnil;
14099   }
14100   DATA_PTR(self) = result;
14101   
14102   return self;
14103 fail:
14104   return Qnil;
14105 }
14106 
14107 
14108 SWIGINTERN void
14109 free_gSimpleAIFactory(gSimpleAIFactory *arg1) {
14110     delete arg1;
14111 }
14112 
14113 SWIGINTERN VALUE
14114 _wrap_disown_GSimpleAIFactory(int argc, VALUE *argv, VALUE self) {
14115   gSimpleAIFactory *arg1 = (gSimpleAIFactory *) 0 ;
14116   void *argp1 = 0 ;
14117   int res1 = 0 ;
14118   
14119   if ((argc < 1) || (argc > 1)) {
14120     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14121   }
14122   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_gSimpleAIFactory, 0 |  0 );
14123   if (!SWIG_IsOK(res1)) {
14124     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_GSimpleAIFactory" "', argument " "1"" of type '" "gSimpleAIFactory *""'"); 
14125   }
14126   arg1 = reinterpret_cast< gSimpleAIFactory * >(argp1);
14127   {
14128     Swig::Director *director = dynamic_cast<Swig::Director *>(arg1);
14129     if (director) director->swig_disown();
14130   }
14131   
14132   return Qnil;
14133 fail:
14134   return Qnil;
14135 }
14136 
14137 
14138 swig_class cGCycleMovement;
14139 
14140 SWIGINTERN VALUE
14141 _wrap_GCycleMovement_rubber_speed(int argc, VALUE *argv, VALUE self) {
14142   float result;
14143   VALUE vresult = Qnil;
14144   
14145   if ((argc < 0) || (argc > 0)) {
14146     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14147   }
14148   result = (float)gCycleMovement::RubberSpeed();
14149   vresult = SWIG_From_float(static_cast< float >(result));
14150   return vresult;
14151 fail:
14152   return Qnil;
14153 }
14154 
14155 
14156 SWIGINTERN VALUE
14157 _wrap_GCycleMovement_speed_multiplier(int argc, VALUE *argv, VALUE self) {
14158   float result;
14159   VALUE vresult = Qnil;
14160   
14161   if ((argc < 0) || (argc > 0)) {
14162     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14163   }
14164   result = (float)gCycleMovement::SpeedMultiplier();
14165   vresult = SWIG_From_float(static_cast< float >(result));
14166   return vresult;
14167 fail:
14168   return Qnil;
14169 }
14170 
14171 
14172 SWIGINTERN VALUE
14173 _wrap_GCycleMovement_set_speed_multiplier(int argc, VALUE *argv, VALUE self) {
14174   REAL arg1 ;
14175   float val1 ;
14176   int ecode1 = 0 ;
14177   
14178   if ((argc < 1) || (argc > 1)) {
14179     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14180   }
14181   ecode1 = SWIG_AsVal_float(argv[0], &val1);
14182   if (!SWIG_IsOK(ecode1)) {
14183     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gCycleMovement::SetSpeedMultiplier" "', argument " "1"" of type '" "REAL""'");
14184   } 
14185   arg1 = static_cast< REAL >(val1);
14186   gCycleMovement::SetSpeedMultiplier(arg1);
14187   return Qnil;
14188 fail:
14189   return Qnil;
14190 }
14191 
14192 
14193 SWIGINTERN VALUE
14194 _wrap_GCycleMovement_maximal_speed(int argc, VALUE *argv, VALUE self) {
14195   float result;
14196   VALUE vresult = Qnil;
14197   
14198   if ((argc < 0) || (argc > 0)) {
14199     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14200   }
14201   result = (float)gCycleMovement::MaximalSpeed();
14202   vresult = SWIG_From_float(static_cast< float >(result));
14203   return vresult;
14204 fail:
14205   return Qnil;
14206 }
14207 
14208 
14209 SWIGINTERN VALUE
14210 _wrap_GCycleMovement_winding_number(int argc, VALUE *argv, VALUE self) {
14211   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14212   int result;
14213   void *argp1 = 0 ;
14214   int res1 = 0 ;
14215   VALUE vresult = Qnil;
14216   
14217   if ((argc < 0) || (argc > 0)) {
14218     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14219   }
14220   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14221   if (!SWIG_IsOK(res1)) {
14222     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindingNumber" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14223   }
14224   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14225   result = (int)((gCycleMovement const *)arg1)->WindingNumber();
14226   vresult = SWIG_From_int(static_cast< int >(result));
14227   return vresult;
14228 fail:
14229   return Qnil;
14230 }
14231 
14232 
14233 SWIGINTERN VALUE
14234 _wrap_GCycleMovement_set_winding_number_wrapped(int argc, VALUE *argv, VALUE self) {
14235   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14236   int arg2 ;
14237   void *argp1 = 0 ;
14238   int res1 = 0 ;
14239   int val2 ;
14240   int ecode2 = 0 ;
14241   
14242   if ((argc < 1) || (argc > 1)) {
14243     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14244   }
14245   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14246   if (!SWIG_IsOK(res1)) {
14247     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetWindingNumberWrapped" "', argument " "1"" of type '" "gCycleMovement *""'"); 
14248   }
14249   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14250   ecode2 = SWIG_AsVal_int(argv[0], &val2);
14251   if (!SWIG_IsOK(ecode2)) {
14252     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetWindingNumberWrapped" "', argument " "2"" of type '" "int""'");
14253   } 
14254   arg2 = static_cast< int >(val2);
14255   (arg1)->SetWindingNumberWrapped(arg2);
14256   return Qnil;
14257 fail:
14258   return Qnil;
14259 }
14260 
14261 
14262 SWIGINTERN VALUE
14263 _wrap_GCycleMovement_direction(int argc, VALUE *argv, VALUE self) {
14264   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14265   eCoord result;
14266   void *argp1 = 0 ;
14267   int res1 = 0 ;
14268   VALUE vresult = Qnil;
14269   
14270   if ((argc < 0) || (argc > 0)) {
14271     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14272   }
14273   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14274   if (!SWIG_IsOK(res1)) {
14275     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Direction" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14276   }
14277   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14278   result = ((gCycleMovement const *)arg1)->Direction();
14279   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
14280   return vresult;
14281 fail:
14282   return Qnil;
14283 }
14284 
14285 
14286 SWIGINTERN VALUE
14287 _wrap_GCycleMovement_last_direction(int argc, VALUE *argv, VALUE self) {
14288   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14289   eCoord result;
14290   void *argp1 = 0 ;
14291   int res1 = 0 ;
14292   VALUE vresult = Qnil;
14293   
14294   if ((argc < 0) || (argc > 0)) {
14295     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14296   }
14297   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14298   if (!SWIG_IsOK(res1)) {
14299     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LastDirection" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14300   }
14301   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14302   result = ((gCycleMovement const *)arg1)->LastDirection();
14303   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
14304   return vresult;
14305 fail:
14306   return Qnil;
14307 }
14308 
14309 
14310 SWIGINTERN VALUE
14311 _wrap_GCycleMovement_speed(int argc, VALUE *argv, VALUE self) {
14312   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14313   REAL result;
14314   void *argp1 = 0 ;
14315   int res1 = 0 ;
14316   VALUE vresult = Qnil;
14317   
14318   if ((argc < 0) || (argc > 0)) {
14319     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14320   }
14321   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14322   if (!SWIG_IsOK(res1)) {
14323     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Speed" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14324   }
14325   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14326   result = (REAL)((gCycleMovement const *)arg1)->Speed();
14327   vresult = SWIG_From_float(static_cast< float >(result));
14328   return vresult;
14329 fail:
14330   return Qnil;
14331 }
14332 
14333 
14334 SWIGINTERN VALUE
14335 _wrap_GCycleMovement_alive(int argc, VALUE *argv, VALUE self) {
14336   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14337   bool result;
14338   void *argp1 = 0 ;
14339   int res1 = 0 ;
14340   VALUE vresult = Qnil;
14341   
14342   if ((argc < 0) || (argc > 0)) {
14343     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14344   }
14345   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14346   if (!SWIG_IsOK(res1)) {
14347     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Alive" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14348   }
14349   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14350   result = (bool)((gCycleMovement const *)arg1)->Alive();
14351   vresult = SWIG_From_bool(static_cast< bool >(result));
14352   return vresult;
14353 fail:
14354   return Qnil;
14355 }
14356 
14357 
14358 SWIGINTERN VALUE
14359 _wrap_GCycleMovement_vulnerable(int argc, VALUE *argv, VALUE self) {
14360   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14361   bool result;
14362   void *argp1 = 0 ;
14363   int res1 = 0 ;
14364   VALUE vresult = Qnil;
14365   
14366   if ((argc < 0) || (argc > 0)) {
14367     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14368   }
14369   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14370   if (!SWIG_IsOK(res1)) {
14371     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vulnerable" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14372   }
14373   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14374   result = (bool)((gCycleMovement const *)arg1)->Vulnerable();
14375   vresult = SWIG_From_bool(static_cast< bool >(result));
14376   return vresult;
14377 fail:
14378   return Qnil;
14379 }
14380 
14381 
14382 SWIGINTERN VALUE
14383 _wrap_GCycleMovement_spawn_direction(int argc, VALUE *argv, VALUE self) {
14384   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14385   eCoord result;
14386   void *argp1 = 0 ;
14387   int res1 = 0 ;
14388   VALUE vresult = Qnil;
14389   
14390   if ((argc < 0) || (argc > 0)) {
14391     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14392   }
14393   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14394   if (!SWIG_IsOK(res1)) {
14395     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SpawnDirection" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14396   }
14397   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14398   result = ((gCycleMovement const *)arg1)->SpawnDirection();
14399   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
14400   return vresult;
14401 fail:
14402   return Qnil;
14403 }
14404 
14405 
14406 SWIGINTERN VALUE
14407 _wrap_GCycleMovement_can_make_turn__SWIG_0(int argc, VALUE *argv, VALUE self) {
14408   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14409   int arg2 ;
14410   bool result;
14411   void *argp1 = 0 ;
14412   int res1 = 0 ;
14413   int val2 ;
14414   int ecode2 = 0 ;
14415   VALUE vresult = Qnil;
14416   
14417   if ((argc < 1) || (argc > 1)) {
14418     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14419   }
14420   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14421   if (!SWIG_IsOK(res1)) {
14422     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CanMakeTurn" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14423   }
14424   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14425   ecode2 = SWIG_AsVal_int(argv[0], &val2);
14426   if (!SWIG_IsOK(ecode2)) {
14427     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CanMakeTurn" "', argument " "2"" of type '" "int""'");
14428   } 
14429   arg2 = static_cast< int >(val2);
14430   result = (bool)((gCycleMovement const *)arg1)->CanMakeTurn(arg2);
14431   vresult = SWIG_From_bool(static_cast< bool >(result));
14432   return vresult;
14433 fail:
14434   return Qnil;
14435 }
14436 
14437 
14438 SWIGINTERN VALUE
14439 _wrap_GCycleMovement_can_make_turn__SWIG_1(int argc, VALUE *argv, VALUE self) {
14440   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14441   REAL arg2 ;
14442   int arg3 ;
14443   bool result;
14444   void *argp1 = 0 ;
14445   int res1 = 0 ;
14446   float val2 ;
14447   int ecode2 = 0 ;
14448   int val3 ;
14449   int ecode3 = 0 ;
14450   VALUE vresult = Qnil;
14451   
14452   if ((argc < 2) || (argc > 2)) {
14453     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
14454   }
14455   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14456   if (!SWIG_IsOK(res1)) {
14457     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CanMakeTurn" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14458   }
14459   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14460   ecode2 = SWIG_AsVal_float(argv[0], &val2);
14461   if (!SWIG_IsOK(ecode2)) {
14462     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CanMakeTurn" "', argument " "2"" of type '" "REAL""'");
14463   } 
14464   arg2 = static_cast< REAL >(val2);
14465   ecode3 = SWIG_AsVal_int(argv[1], &val3);
14466   if (!SWIG_IsOK(ecode3)) {
14467     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CanMakeTurn" "', argument " "3"" of type '" "int""'");
14468   } 
14469   arg3 = static_cast< int >(val3);
14470   result = (bool)((gCycleMovement const *)arg1)->CanMakeTurn(arg2,arg3);
14471   vresult = SWIG_From_bool(static_cast< bool >(result));
14472   return vresult;
14473 fail:
14474   return Qnil;
14475 }
14476 
14477 
14478 SWIGINTERN VALUE _wrap_GCycleMovement_can_make_turn(int nargs, VALUE *args, VALUE self) {
14479   int argc;
14480   VALUE argv[4];
14481   int ii;
14482   
14483   argc = nargs + 1;
14484   argv[0] = self;
14485   if (argc > 4) SWIG_fail;
14486   for (ii = 1; (ii < argc); ii++) {
14487     argv[ii] = args[ii-1];
14488   }
14489   if (argc == 2) {
14490     int _v;
14491     void *vptr = 0;
14492     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
14493     _v = SWIG_CheckState(res);
14494     if (_v) {
14495       {
14496         int res = SWIG_AsVal_int(argv[1], NULL);
14497         _v = SWIG_CheckState(res);
14498       }
14499       if (_v) {
14500         return _wrap_GCycleMovement_can_make_turn__SWIG_0(nargs, args, self);
14501       }
14502     }
14503   }
14504   if (argc == 3) {
14505     int _v;
14506     void *vptr = 0;
14507     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
14508     _v = SWIG_CheckState(res);
14509     if (_v) {
14510       {
14511         int res = SWIG_AsVal_float(argv[1], NULL);
14512         _v = SWIG_CheckState(res);
14513       }
14514       if (_v) {
14515         {
14516           int res = SWIG_AsVal_int(argv[2], NULL);
14517           _v = SWIG_CheckState(res);
14518         }
14519         if (_v) {
14520           return _wrap_GCycleMovement_can_make_turn__SWIG_1(nargs, args, self);
14521         }
14522       }
14523     }
14524   }
14525   
14526 fail:
14527   rb_raise(rb_eArgError, "No matching function for overloaded 'GCycleMovement_can_make_turn'");
14528   return Qnil;
14529 }
14530 
14531 
14532 SWIGINTERN VALUE
14533 _wrap_GCycleMovement_get_distance_since_last_turn(int argc, VALUE *argv, VALUE self) {
14534   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14535   REAL result;
14536   void *argp1 = 0 ;
14537   int res1 = 0 ;
14538   VALUE vresult = Qnil;
14539   
14540   if ((argc < 0) || (argc > 0)) {
14541     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14542   }
14543   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14544   if (!SWIG_IsOK(res1)) {
14545     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDistanceSinceLastTurn" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14546   }
14547   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14548   result = (REAL)((gCycleMovement const *)arg1)->GetDistanceSinceLastTurn();
14549   vresult = SWIG_From_float(static_cast< float >(result));
14550   return vresult;
14551 fail:
14552   return Qnil;
14553 }
14554 
14555 
14556 SWIGINTERN VALUE
14557 _wrap_GCycleMovement_get_turn_delay(int argc, VALUE *argv, VALUE self) {
14558   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14559   REAL result;
14560   void *argp1 = 0 ;
14561   int res1 = 0 ;
14562   VALUE vresult = Qnil;
14563   
14564   if ((argc < 0) || (argc > 0)) {
14565     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14566   }
14567   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14568   if (!SWIG_IsOK(res1)) {
14569     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTurnDelay" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14570   }
14571   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14572   result = (REAL)((gCycleMovement const *)arg1)->GetTurnDelay();
14573   vresult = SWIG_From_float(static_cast< float >(result));
14574   return vresult;
14575 fail:
14576   return Qnil;
14577 }
14578 
14579 
14580 SWIGINTERN VALUE
14581 _wrap_GCycleMovement_get_turn_delay_db(int argc, VALUE *argv, VALUE self) {
14582   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14583   REAL result;
14584   void *argp1 = 0 ;
14585   int res1 = 0 ;
14586   VALUE vresult = Qnil;
14587   
14588   if ((argc < 0) || (argc > 0)) {
14589     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14590   }
14591   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14592   if (!SWIG_IsOK(res1)) {
14593     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTurnDelayDb" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14594   }
14595   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14596   result = (REAL)((gCycleMovement const *)arg1)->GetTurnDelayDb();
14597   vresult = SWIG_From_float(static_cast< float >(result));
14598   return vresult;
14599 fail:
14600   return Qnil;
14601 }
14602 
14603 
14604 SWIGINTERN VALUE
14605 _wrap_GCycleMovement_get_next_turn(int argc, VALUE *argv, VALUE self) {
14606   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14607   int arg2 ;
14608   REAL result;
14609   void *argp1 = 0 ;
14610   int res1 = 0 ;
14611   int val2 ;
14612   int ecode2 = 0 ;
14613   VALUE vresult = Qnil;
14614   
14615   if ((argc < 1) || (argc > 1)) {
14616     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14617   }
14618   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14619   if (!SWIG_IsOK(res1)) {
14620     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetNextTurn" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14621   }
14622   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14623   ecode2 = SWIG_AsVal_int(argv[0], &val2);
14624   if (!SWIG_IsOK(ecode2)) {
14625     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetNextTurn" "', argument " "2"" of type '" "int""'");
14626   } 
14627   arg2 = static_cast< int >(val2);
14628   result = (REAL)((gCycleMovement const *)arg1)->GetNextTurn(arg2);
14629   vresult = SWIG_From_float(static_cast< float >(result));
14630   return vresult;
14631 fail:
14632   return Qnil;
14633 }
14634 
14635 
14636 SWIGINTERN VALUE
14637 _wrap_GCycleMovement_add_destination__SWIG_0(int argc, VALUE *argv, VALUE self) {
14638   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14639   void *argp1 = 0 ;
14640   int res1 = 0 ;
14641   
14642   if ((argc < 0) || (argc > 0)) {
14643     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14644   }
14645   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14646   if (!SWIG_IsOK(res1)) {
14647     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddDestination" "', argument " "1"" of type '" "gCycleMovement *""'"); 
14648   }
14649   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14650   (arg1)->AddDestination();
14651   return Qnil;
14652 fail:
14653   return Qnil;
14654 }
14655 
14656 
14657 SWIGINTERN VALUE
14658 _wrap_GCycleMovement_advance_destination(int argc, VALUE *argv, VALUE self) {
14659   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14660   void *argp1 = 0 ;
14661   int res1 = 0 ;
14662   
14663   if ((argc < 0) || (argc > 0)) {
14664     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14665   }
14666   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14667   if (!SWIG_IsOK(res1)) {
14668     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdvanceDestination" "', argument " "1"" of type '" "gCycleMovement *""'"); 
14669   }
14670   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14671   (arg1)->AdvanceDestination();
14672   return Qnil;
14673 fail:
14674   return Qnil;
14675 }
14676 
14677 
14678 SWIGINTERN VALUE
14679 _wrap_GCycleMovement_add_destination__SWIG_1(int argc, VALUE *argv, VALUE self) {
14680   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14681   gDestination *arg2 = (gDestination *) 0 ;
14682   void *argp1 = 0 ;
14683   int res1 = 0 ;
14684   void *argp2 = 0 ;
14685   int res2 = 0 ;
14686   
14687   if ((argc < 1) || (argc > 1)) {
14688     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14689   }
14690   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14691   if (!SWIG_IsOK(res1)) {
14692     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddDestination" "', argument " "1"" of type '" "gCycleMovement *""'"); 
14693   }
14694   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14695   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_gDestination, 0 |  0 );
14696   if (!SWIG_IsOK(res2)) {
14697     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddDestination" "', argument " "2"" of type '" "gDestination *""'"); 
14698   }
14699   arg2 = reinterpret_cast< gDestination * >(argp2);
14700   (arg1)->AddDestination(arg2);
14701   return Qnil;
14702 fail:
14703   return Qnil;
14704 }
14705 
14706 
14707 SWIGINTERN VALUE _wrap_GCycleMovement_add_destination(int nargs, VALUE *args, VALUE self) {
14708   int argc;
14709   VALUE argv[3];
14710   int ii;
14711   
14712   argc = nargs + 1;
14713   argv[0] = self;
14714   if (argc > 3) SWIG_fail;
14715   for (ii = 1; (ii < argc); ii++) {
14716     argv[ii] = args[ii-1];
14717   }
14718   if (argc == 1) {
14719     int _v;
14720     void *vptr = 0;
14721     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
14722     _v = SWIG_CheckState(res);
14723     if (_v) {
14724       return _wrap_GCycleMovement_add_destination__SWIG_0(nargs, args, self);
14725     }
14726   }
14727   if (argc == 2) {
14728     int _v;
14729     void *vptr = 0;
14730     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
14731     _v = SWIG_CheckState(res);
14732     if (_v) {
14733       void *vptr = 0;
14734       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_gDestination, 0);
14735       _v = SWIG_CheckState(res);
14736       if (_v) {
14737         return _wrap_GCycleMovement_add_destination__SWIG_1(nargs, args, self);
14738       }
14739     }
14740   }
14741   
14742 fail:
14743   rb_raise(rb_eArgError, "No matching function for overloaded 'GCycleMovement_add_destination'");
14744   return Qnil;
14745 }
14746 
14747 
14748 SWIGINTERN VALUE
14749 _wrap_GCycleMovement_get_current_destination(int argc, VALUE *argv, VALUE self) {
14750   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14751   gDestination *result = 0 ;
14752   void *argp1 = 0 ;
14753   int res1 = 0 ;
14754   VALUE vresult = Qnil;
14755   
14756   if ((argc < 0) || (argc > 0)) {
14757     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14758   }
14759   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14760   if (!SWIG_IsOK(res1)) {
14761     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetCurrentDestination" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14762   }
14763   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14764   result = (gDestination *)((gCycleMovement const *)arg1)->GetCurrentDestination();
14765   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gDestination, 0 |  0 );
14766   return vresult;
14767 fail:
14768   return Qnil;
14769 }
14770 
14771 
14772 SWIGINTERN VALUE
14773 _wrap_GCycleMovement_notify_new_destination(int argc, VALUE *argv, VALUE self) {
14774   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14775   gDestination *arg2 = (gDestination *) 0 ;
14776   void *argp1 = 0 ;
14777   int res1 = 0 ;
14778   void *argp2 = 0 ;
14779   int res2 = 0 ;
14780   
14781   if ((argc < 1) || (argc > 1)) {
14782     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14783   }
14784   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14785   if (!SWIG_IsOK(res1)) {
14786     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyNewDestination" "', argument " "1"" of type '" "gCycleMovement *""'"); 
14787   }
14788   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14789   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_gDestination, 0 |  0 );
14790   if (!SWIG_IsOK(res2)) {
14791     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NotifyNewDestination" "', argument " "2"" of type '" "gDestination *""'"); 
14792   }
14793   arg2 = reinterpret_cast< gDestination * >(argp2);
14794   (arg1)->NotifyNewDestination(arg2);
14795   return Qnil;
14796 fail:
14797   return Qnil;
14798 }
14799 
14800 
14801 SWIGINTERN VALUE
14802 _wrap_GCycleMovement_is_destination_used(int argc, VALUE *argv, VALUE self) {
14803   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14804   gDestination *arg2 = (gDestination *) 0 ;
14805   bool result;
14806   void *argp1 = 0 ;
14807   int res1 = 0 ;
14808   void *argp2 = 0 ;
14809   int res2 = 0 ;
14810   VALUE vresult = Qnil;
14811   
14812   if ((argc < 1) || (argc > 1)) {
14813     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14814   }
14815   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14816   if (!SWIG_IsOK(res1)) {
14817     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsDestinationUsed" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14818   }
14819   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14820   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_gDestination, 0 |  0 );
14821   if (!SWIG_IsOK(res2)) {
14822     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IsDestinationUsed" "', argument " "2"" of type '" "gDestination const *""'"); 
14823   }
14824   arg2 = reinterpret_cast< gDestination * >(argp2);
14825   result = (bool)((gCycleMovement const *)arg1)->IsDestinationUsed((gDestination const *)arg2);
14826   vresult = SWIG_From_bool(static_cast< bool >(result));
14827   return vresult;
14828 fail:
14829   return Qnil;
14830 }
14831 
14832 
14833 SWIGINTERN VALUE
14834 _wrap_GCycleMovement_drop_temp_wall(int argc, VALUE *argv, VALUE self) {
14835   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14836   gPlayerWall *arg2 = (gPlayerWall *) 0 ;
14837   eCoord *arg3 = 0 ;
14838   eCoord *arg4 = 0 ;
14839   void *argp1 = 0 ;
14840   int res1 = 0 ;
14841   void *argp2 = 0 ;
14842   int res2 = 0 ;
14843   void *argp3 ;
14844   int res3 = 0 ;
14845   void *argp4 ;
14846   int res4 = 0 ;
14847   
14848   if ((argc < 3) || (argc > 3)) {
14849     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
14850   }
14851   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14852   if (!SWIG_IsOK(res1)) {
14853     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropTempWall" "', argument " "1"" of type '" "gCycleMovement *""'"); 
14854   }
14855   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14856   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_gPlayerWall, 0 |  0 );
14857   if (!SWIG_IsOK(res2)) {
14858     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DropTempWall" "', argument " "2"" of type '" "gPlayerWall *""'"); 
14859   }
14860   arg2 = reinterpret_cast< gPlayerWall * >(argp2);
14861   res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_eCoord,  0 );
14862   if (!SWIG_IsOK(res3)) {
14863     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DropTempWall" "', argument " "3"" of type '" "eCoord const &""'"); 
14864   }
14865   if (!argp3) {
14866     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropTempWall" "', argument " "3"" of type '" "eCoord const &""'"); 
14867   }
14868   arg3 = reinterpret_cast< eCoord * >(argp3);
14869   res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_eCoord,  0 );
14870   if (!SWIG_IsOK(res4)) {
14871     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DropTempWall" "', argument " "4"" of type '" "eCoord const &""'"); 
14872   }
14873   if (!argp4) {
14874     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DropTempWall" "', argument " "4"" of type '" "eCoord const &""'"); 
14875   }
14876   arg4 = reinterpret_cast< eCoord * >(argp4);
14877   (arg1)->DropTempWall(arg2,(eCoord const &)*arg3,(eCoord const &)*arg4);
14878   return Qnil;
14879 fail:
14880   return Qnil;
14881 }
14882 
14883 
14884 SWIGINTERN VALUE
14885 _wrap_GCycleMovement_edge_is_dangerous(int argc, VALUE *argv, VALUE self) {
14886   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14887   eWall *arg2 = (eWall *) 0 ;
14888   REAL arg3 ;
14889   REAL arg4 ;
14890   bool result;
14891   void *argp1 = 0 ;
14892   int res1 = 0 ;
14893   void *argp2 = 0 ;
14894   int res2 = 0 ;
14895   float val3 ;
14896   int ecode3 = 0 ;
14897   float val4 ;
14898   int ecode4 = 0 ;
14899   VALUE vresult = Qnil;
14900   
14901   if ((argc < 3) || (argc > 3)) {
14902     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
14903   }
14904   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14905   if (!SWIG_IsOK(res1)) {
14906     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EdgeIsDangerous" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
14907   }
14908   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14909   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eWall, 0 |  0 );
14910   if (!SWIG_IsOK(res2)) {
14911     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EdgeIsDangerous" "', argument " "2"" of type '" "eWall const *""'"); 
14912   }
14913   arg2 = reinterpret_cast< eWall * >(argp2);
14914   ecode3 = SWIG_AsVal_float(argv[1], &val3);
14915   if (!SWIG_IsOK(ecode3)) {
14916     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EdgeIsDangerous" "', argument " "3"" of type '" "REAL""'");
14917   } 
14918   arg3 = static_cast< REAL >(val3);
14919   ecode4 = SWIG_AsVal_float(argv[2], &val4);
14920   if (!SWIG_IsOK(ecode4)) {
14921     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EdgeIsDangerous" "', argument " "4"" of type '" "REAL""'");
14922   } 
14923   arg4 = static_cast< REAL >(val4);
14924   result = (bool)((gCycleMovement const *)arg1)->EdgeIsDangerous((eWall const *)arg2,arg3,arg4);
14925   vresult = SWIG_From_bool(static_cast< bool >(result));
14926   return vresult;
14927 fail:
14928   return Qnil;
14929 }
14930 
14931 
14932 SWIGINTERN VALUE
14933 _wrap_GCycleMovement_turn__SWIG_0(int argc, VALUE *argv, VALUE self) {
14934   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14935   REAL arg2 ;
14936   bool result;
14937   void *argp1 = 0 ;
14938   int res1 = 0 ;
14939   float val2 ;
14940   int ecode2 = 0 ;
14941   VALUE vresult = Qnil;
14942   
14943   if ((argc < 1) || (argc > 1)) {
14944     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14945   }
14946   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14947   if (!SWIG_IsOK(res1)) {
14948     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Turn" "', argument " "1"" of type '" "gCycleMovement *""'"); 
14949   }
14950   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14951   ecode2 = SWIG_AsVal_float(argv[0], &val2);
14952   if (!SWIG_IsOK(ecode2)) {
14953     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Turn" "', argument " "2"" of type '" "REAL""'");
14954   } 
14955   arg2 = static_cast< REAL >(val2);
14956   result = (bool)(arg1)->Turn(arg2);
14957   vresult = SWIG_From_bool(static_cast< bool >(result));
14958   return vresult;
14959 fail:
14960   return Qnil;
14961 }
14962 
14963 
14964 SWIGINTERN VALUE
14965 _wrap_GCycleMovement_turn__SWIG_1(int argc, VALUE *argv, VALUE self) {
14966   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
14967   int arg2 ;
14968   bool result;
14969   void *argp1 = 0 ;
14970   int res1 = 0 ;
14971   int val2 ;
14972   int ecode2 = 0 ;
14973   VALUE vresult = Qnil;
14974   
14975   if ((argc < 1) || (argc > 1)) {
14976     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14977   }
14978   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
14979   if (!SWIG_IsOK(res1)) {
14980     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Turn" "', argument " "1"" of type '" "gCycleMovement *""'"); 
14981   }
14982   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
14983   ecode2 = SWIG_AsVal_int(argv[0], &val2);
14984   if (!SWIG_IsOK(ecode2)) {
14985     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Turn" "', argument " "2"" of type '" "int""'");
14986   } 
14987   arg2 = static_cast< int >(val2);
14988   result = (bool)(arg1)->Turn(arg2);
14989   vresult = SWIG_From_bool(static_cast< bool >(result));
14990   return vresult;
14991 fail:
14992   return Qnil;
14993 }
14994 
14995 
14996 SWIGINTERN VALUE _wrap_GCycleMovement_turn(int nargs, VALUE *args, VALUE self) {
14997   int argc;
14998   VALUE argv[3];
14999   int ii;
15000   
15001   argc = nargs + 1;
15002   argv[0] = self;
15003   if (argc > 3) SWIG_fail;
15004   for (ii = 1; (ii < argc); ii++) {
15005     argv[ii] = args[ii-1];
15006   }
15007   if (argc == 2) {
15008     int _v;
15009     void *vptr = 0;
15010     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15011     _v = SWIG_CheckState(res);
15012     if (_v) {
15013       {
15014         int res = SWIG_AsVal_int(argv[1], NULL);
15015         _v = SWIG_CheckState(res);
15016       }
15017       if (_v) {
15018         return _wrap_GCycleMovement_turn__SWIG_1(nargs, args, self);
15019       }
15020     }
15021   }
15022   if (argc == 2) {
15023     int _v;
15024     void *vptr = 0;
15025     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15026     _v = SWIG_CheckState(res);
15027     if (_v) {
15028       {
15029         int res = SWIG_AsVal_float(argv[1], NULL);
15030         _v = SWIG_CheckState(res);
15031       }
15032       if (_v) {
15033         return _wrap_GCycleMovement_turn__SWIG_0(nargs, args, self);
15034       }
15035     }
15036   }
15037   
15038 fail:
15039   rb_raise(rb_eArgError, "No matching function for overloaded 'GCycleMovement_turn'");
15040   return Qnil;
15041 }
15042 
15043 
15044 SWIGINTERN VALUE
15045 _wrap_GCycleMovement_move_safely(int argc, VALUE *argv, VALUE self) {
15046   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15047   eCoord *arg2 = 0 ;
15048   REAL arg3 ;
15049   REAL arg4 ;
15050   void *argp1 = 0 ;
15051   int res1 = 0 ;
15052   void *argp2 ;
15053   int res2 = 0 ;
15054   float val3 ;
15055   int ecode3 = 0 ;
15056   float val4 ;
15057   int ecode4 = 0 ;
15058   
15059   if ((argc < 3) || (argc > 3)) {
15060     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
15061   }
15062   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15063   if (!SWIG_IsOK(res1)) {
15064     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveSafely" "', argument " "1"" of type '" "gCycleMovement *""'"); 
15065   }
15066   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15067   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_eCoord,  0 );
15068   if (!SWIG_IsOK(res2)) {
15069     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MoveSafely" "', argument " "2"" of type '" "eCoord const &""'"); 
15070   }
15071   if (!argp2) {
15072     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MoveSafely" "', argument " "2"" of type '" "eCoord const &""'"); 
15073   }
15074   arg2 = reinterpret_cast< eCoord * >(argp2);
15075   ecode3 = SWIG_AsVal_float(argv[1], &val3);
15076   if (!SWIG_IsOK(ecode3)) {
15077     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MoveSafely" "', argument " "3"" of type '" "REAL""'");
15078   } 
15079   arg3 = static_cast< REAL >(val3);
15080   ecode4 = SWIG_AsVal_float(argv[2], &val4);
15081   if (!SWIG_IsOK(ecode4)) {
15082     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MoveSafely" "', argument " "4"" of type '" "REAL""'");
15083   } 
15084   arg4 = static_cast< REAL >(val4);
15085   (arg1)->MoveSafely((eCoord const &)*arg2,arg3,arg4);
15086   return Qnil;
15087 fail:
15088   return Qnil;
15089 }
15090 
15091 
15092 SWIGINTERN VALUE
15093 _wrap_GCycleMovement_timestep(int argc, VALUE *argv, VALUE self) {
15094   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15095   REAL arg2 ;
15096   bool result;
15097   void *argp1 = 0 ;
15098   int res1 = 0 ;
15099   float val2 ;
15100   int ecode2 = 0 ;
15101   VALUE vresult = Qnil;
15102   
15103   if ((argc < 1) || (argc > 1)) {
15104     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15105   }
15106   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15107   if (!SWIG_IsOK(res1)) {
15108     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timestep" "', argument " "1"" of type '" "gCycleMovement *""'"); 
15109   }
15110   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15111   ecode2 = SWIG_AsVal_float(argv[0], &val2);
15112   if (!SWIG_IsOK(ecode2)) {
15113     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timestep" "', argument " "2"" of type '" "REAL""'");
15114   } 
15115   arg2 = static_cast< REAL >(val2);
15116   result = (bool)(arg1)->Timestep(arg2);
15117   vresult = SWIG_From_bool(static_cast< bool >(result));
15118   return vresult;
15119 fail:
15120   return Qnil;
15121 }
15122 
15123 
15124 SWIGINTERN VALUE
15125 _wrap_GCycleMovement_next_interesting_time(int argc, VALUE *argv, VALUE self) {
15126   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15127   REAL result;
15128   void *argp1 = 0 ;
15129   int res1 = 0 ;
15130   VALUE vresult = Qnil;
15131   
15132   if ((argc < 0) || (argc > 0)) {
15133     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15134   }
15135   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15136   if (!SWIG_IsOK(res1)) {
15137     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NextInterestingTime" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15138   }
15139   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15140   result = (REAL)((gCycleMovement const *)arg1)->NextInterestingTime();
15141   vresult = SWIG_From_float(static_cast< float >(result));
15142   return vresult;
15143 fail:
15144   return Qnil;
15145 }
15146 
15147 
15148 SWIGINTERN VALUE
15149 _wrap_GCycleMovement_add_ref(int argc, VALUE *argv, VALUE self) {
15150   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15151   void *argp1 = 0 ;
15152   int res1 = 0 ;
15153   
15154   if ((argc < 0) || (argc > 0)) {
15155     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15156   }
15157   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15158   if (!SWIG_IsOK(res1)) {
15159     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddRef" "', argument " "1"" of type '" "gCycleMovement *""'"); 
15160   }
15161   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15162   (arg1)->AddRef();
15163   return Qnil;
15164 fail:
15165   return Qnil;
15166 }
15167 
15168 
15169 SWIGINTERN void
15170 free_gCycleMovement(gCycleMovement *arg1) {
15171     delete arg1;
15172 }
15173 
15174 SWIGINTERN VALUE
15175 _wrap_GCycleMovement_remove_from_game(int argc, VALUE *argv, VALUE self) {
15176   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15177   void *argp1 = 0 ;
15178   int res1 = 0 ;
15179   
15180   if ((argc < 0) || (argc > 0)) {
15181     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15182   }
15183   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15184   if (!SWIG_IsOK(res1)) {
15185     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RemoveFromGame" "', argument " "1"" of type '" "gCycleMovement *""'"); 
15186   }
15187   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15188   (arg1)->RemoveFromGame();
15189   return Qnil;
15190 fail:
15191   return Qnil;
15192 }
15193 
15194 
15195 SWIGINTERN VALUE
15196 _wrap_GCycleMovement_get_max_space_ahead(int argc, VALUE *argv, VALUE self) {
15197   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15198   REAL arg2 ;
15199   REAL result;
15200   void *argp1 = 0 ;
15201   int res1 = 0 ;
15202   float val2 ;
15203   int ecode2 = 0 ;
15204   VALUE vresult = Qnil;
15205   
15206   if ((argc < 1) || (argc > 1)) {
15207     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15208   }
15209   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15210   if (!SWIG_IsOK(res1)) {
15211     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetMaxSpaceAhead" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15212   }
15213   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15214   ecode2 = SWIG_AsVal_float(argv[0], &val2);
15215   if (!SWIG_IsOK(ecode2)) {
15216     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GetMaxSpaceAhead" "', argument " "2"" of type '" "REAL""'");
15217   } 
15218   arg2 = static_cast< REAL >(val2);
15219   result = (REAL)((gCycleMovement const *)arg1)->GetMaxSpaceAhead(arg2);
15220   vresult = SWIG_From_float(static_cast< float >(result));
15221   return vresult;
15222 fail:
15223   return Qnil;
15224 }
15225 
15226 
15227 SWIGINTERN VALUE
15228 _wrap_GCycleMovement_get_distance__SWIG_0(int argc, VALUE *argv, VALUE self) {
15229   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15230   REAL result;
15231   void *argp1 = 0 ;
15232   int res1 = 0 ;
15233   VALUE vresult = Qnil;
15234   
15235   if ((argc < 0) || (argc > 0)) {
15236     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15237   }
15238   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15239   if (!SWIG_IsOK(res1)) {
15240     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDistance" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15241   }
15242   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15243   result = (REAL)((gCycleMovement const *)arg1)->GetDistance();
15244   vresult = SWIG_From_float(static_cast< float >(result));
15245   return vresult;
15246 fail:
15247   return Qnil;
15248 }
15249 
15250 
15251 SWIGINTERN VALUE
15252 _wrap_GCycleMovement_get_distance__SWIG_1(int argc, VALUE *argv, VALUE self) {
15253   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15254   REAL *arg2 = 0 ;
15255   gCycleMovement *result = 0 ;
15256   void *argp1 = 0 ;
15257   int res1 = 0 ;
15258   void *argp2 = 0 ;
15259   int res2 = 0 ;
15260   VALUE vresult = Qnil;
15261   
15262   if ((argc < 1) || (argc > 1)) {
15263     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15264   }
15265   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15266   if (!SWIG_IsOK(res1)) {
15267     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetDistance" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15268   }
15269   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15270   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_float,  0 );
15271   if (!SWIG_IsOK(res2)) {
15272     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetDistance" "', argument " "2"" of type '" "REAL &""'"); 
15273   }
15274   if (!argp2) {
15275     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetDistance" "', argument " "2"" of type '" "REAL &""'"); 
15276   }
15277   arg2 = reinterpret_cast< REAL * >(argp2);
15278   {
15279     gCycleMovement const &_result_ref = ((gCycleMovement const *)arg1)->GetDistance(*arg2);
15280     result = (gCycleMovement *) &_result_ref;
15281   }
15282   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gCycleMovement, 0 |  0 );
15283   return vresult;
15284 fail:
15285   return Qnil;
15286 }
15287 
15288 
15289 SWIGINTERN VALUE _wrap_GCycleMovement_get_distance(int nargs, VALUE *args, VALUE self) {
15290   int argc;
15291   VALUE argv[3];
15292   int ii;
15293   
15294   argc = nargs + 1;
15295   argv[0] = self;
15296   if (argc > 3) SWIG_fail;
15297   for (ii = 1; (ii < argc); ii++) {
15298     argv[ii] = args[ii-1];
15299   }
15300   if (argc == 1) {
15301     int _v;
15302     void *vptr = 0;
15303     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15304     _v = SWIG_CheckState(res);
15305     if (_v) {
15306       return _wrap_GCycleMovement_get_distance__SWIG_0(nargs, args, self);
15307     }
15308   }
15309   if (argc == 2) {
15310     int _v;
15311     void *vptr = 0;
15312     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15313     _v = SWIG_CheckState(res);
15314     if (_v) {
15315       void *vptr = 0;
15316       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
15317       _v = SWIG_CheckState(res);
15318       if (_v) {
15319         return _wrap_GCycleMovement_get_distance__SWIG_1(nargs, args, self);
15320       }
15321     }
15322   }
15323   
15324 fail:
15325   rb_raise(rb_eArgError, "No matching function for overloaded 'GCycleMovement_get_distance'");
15326   return Qnil;
15327 }
15328 
15329 
15330 SWIGINTERN VALUE
15331 _wrap_GCycleMovement_get_rubber__SWIG_0(int argc, VALUE *argv, VALUE self) {
15332   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15333   REAL result;
15334   void *argp1 = 0 ;
15335   int res1 = 0 ;
15336   VALUE vresult = Qnil;
15337   
15338   if ((argc < 0) || (argc > 0)) {
15339     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15340   }
15341   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15342   if (!SWIG_IsOK(res1)) {
15343     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetRubber" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15344   }
15345   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15346   result = (REAL)((gCycleMovement const *)arg1)->GetRubber();
15347   vresult = SWIG_From_float(static_cast< float >(result));
15348   return vresult;
15349 fail:
15350   return Qnil;
15351 }
15352 
15353 
15354 SWIGINTERN VALUE
15355 _wrap_GCycleMovement_get_rubber__SWIG_1(int argc, VALUE *argv, VALUE self) {
15356   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15357   REAL *arg2 = 0 ;
15358   gCycleMovement *result = 0 ;
15359   void *argp1 = 0 ;
15360   int res1 = 0 ;
15361   void *argp2 = 0 ;
15362   int res2 = 0 ;
15363   VALUE vresult = Qnil;
15364   
15365   if ((argc < 1) || (argc > 1)) {
15366     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15367   }
15368   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15369   if (!SWIG_IsOK(res1)) {
15370     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetRubber" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15371   }
15372   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15373   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_float,  0 );
15374   if (!SWIG_IsOK(res2)) {
15375     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetRubber" "', argument " "2"" of type '" "REAL &""'"); 
15376   }
15377   if (!argp2) {
15378     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetRubber" "', argument " "2"" of type '" "REAL &""'"); 
15379   }
15380   arg2 = reinterpret_cast< REAL * >(argp2);
15381   {
15382     gCycleMovement const &_result_ref = ((gCycleMovement const *)arg1)->GetRubber(*arg2);
15383     result = (gCycleMovement *) &_result_ref;
15384   }
15385   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gCycleMovement, 0 |  0 );
15386   return vresult;
15387 fail:
15388   return Qnil;
15389 }
15390 
15391 
15392 SWIGINTERN VALUE _wrap_GCycleMovement_get_rubber(int nargs, VALUE *args, VALUE self) {
15393   int argc;
15394   VALUE argv[3];
15395   int ii;
15396   
15397   argc = nargs + 1;
15398   argv[0] = self;
15399   if (argc > 3) SWIG_fail;
15400   for (ii = 1; (ii < argc); ii++) {
15401     argv[ii] = args[ii-1];
15402   }
15403   if (argc == 1) {
15404     int _v;
15405     void *vptr = 0;
15406     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15407     _v = SWIG_CheckState(res);
15408     if (_v) {
15409       return _wrap_GCycleMovement_get_rubber__SWIG_0(nargs, args, self);
15410     }
15411   }
15412   if (argc == 2) {
15413     int _v;
15414     void *vptr = 0;
15415     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15416     _v = SWIG_CheckState(res);
15417     if (_v) {
15418       void *vptr = 0;
15419       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
15420       _v = SWIG_CheckState(res);
15421       if (_v) {
15422         return _wrap_GCycleMovement_get_rubber__SWIG_1(nargs, args, self);
15423       }
15424     }
15425   }
15426   
15427 fail:
15428   rb_raise(rb_eArgError, "No matching function for overloaded 'GCycleMovement_get_rubber'");
15429   return Qnil;
15430 }
15431 
15432 
15433 SWIGINTERN VALUE
15434 _wrap_GCycleMovement_get_turns__SWIG_0(int argc, VALUE *argv, VALUE self) {
15435   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15436   unsigned short result;
15437   void *argp1 = 0 ;
15438   int res1 = 0 ;
15439   VALUE vresult = Qnil;
15440   
15441   if ((argc < 0) || (argc > 0)) {
15442     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15443   }
15444   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15445   if (!SWIG_IsOK(res1)) {
15446     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTurns" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15447   }
15448   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15449   result = (unsigned short)((gCycleMovement const *)arg1)->GetTurns();
15450   vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
15451   return vresult;
15452 fail:
15453   return Qnil;
15454 }
15455 
15456 
15457 SWIGINTERN VALUE
15458 _wrap_GCycleMovement_get_turns__SWIG_1(int argc, VALUE *argv, VALUE self) {
15459   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15460   unsigned short *arg2 = 0 ;
15461   gCycleMovement *result = 0 ;
15462   void *argp1 = 0 ;
15463   int res1 = 0 ;
15464   void *argp2 = 0 ;
15465   int res2 = 0 ;
15466   VALUE vresult = Qnil;
15467   
15468   if ((argc < 1) || (argc > 1)) {
15469     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15470   }
15471   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15472   if (!SWIG_IsOK(res1)) {
15473     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetTurns" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15474   }
15475   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15476   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_unsigned_short,  0 );
15477   if (!SWIG_IsOK(res2)) {
15478     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetTurns" "', argument " "2"" of type '" "unsigned short &""'"); 
15479   }
15480   if (!argp2) {
15481     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetTurns" "', argument " "2"" of type '" "unsigned short &""'"); 
15482   }
15483   arg2 = reinterpret_cast< unsigned short * >(argp2);
15484   {
15485     gCycleMovement const &_result_ref = ((gCycleMovement const *)arg1)->GetTurns(*arg2);
15486     result = (gCycleMovement *) &_result_ref;
15487   }
15488   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gCycleMovement, 0 |  0 );
15489   return vresult;
15490 fail:
15491   return Qnil;
15492 }
15493 
15494 
15495 SWIGINTERN VALUE _wrap_GCycleMovement_get_turns(int nargs, VALUE *args, VALUE self) {
15496   int argc;
15497   VALUE argv[3];
15498   int ii;
15499   
15500   argc = nargs + 1;
15501   argv[0] = self;
15502   if (argc > 3) SWIG_fail;
15503   for (ii = 1; (ii < argc); ii++) {
15504     argv[ii] = args[ii-1];
15505   }
15506   if (argc == 1) {
15507     int _v;
15508     void *vptr = 0;
15509     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15510     _v = SWIG_CheckState(res);
15511     if (_v) {
15512       return _wrap_GCycleMovement_get_turns__SWIG_0(nargs, args, self);
15513     }
15514   }
15515   if (argc == 2) {
15516     int _v;
15517     void *vptr = 0;
15518     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15519     _v = SWIG_CheckState(res);
15520     if (_v) {
15521       void *vptr = 0;
15522       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0);
15523       _v = SWIG_CheckState(res);
15524       if (_v) {
15525         return _wrap_GCycleMovement_get_turns__SWIG_1(nargs, args, self);
15526       }
15527     }
15528   }
15529   
15530 fail:
15531   rb_raise(rb_eArgError, "No matching function for overloaded 'GCycleMovement_get_turns'");
15532   return Qnil;
15533 }
15534 
15535 
15536 SWIGINTERN VALUE
15537 _wrap_GCycleMovement_get_braking__SWIG_0(int argc, VALUE *argv, VALUE self) {
15538   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15539   unsigned short result;
15540   void *argp1 = 0 ;
15541   int res1 = 0 ;
15542   VALUE vresult = Qnil;
15543   
15544   if ((argc < 0) || (argc > 0)) {
15545     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15546   }
15547   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15548   if (!SWIG_IsOK(res1)) {
15549     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBraking" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15550   }
15551   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15552   result = (unsigned short)((gCycleMovement const *)arg1)->GetBraking();
15553   vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
15554   return vresult;
15555 fail:
15556   return Qnil;
15557 }
15558 
15559 
15560 SWIGINTERN VALUE
15561 _wrap_GCycleMovement_get_braking__SWIG_1(int argc, VALUE *argv, VALUE self) {
15562   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15563   unsigned short *arg2 = 0 ;
15564   gCycleMovement *result = 0 ;
15565   void *argp1 = 0 ;
15566   int res1 = 0 ;
15567   void *argp2 = 0 ;
15568   int res2 = 0 ;
15569   VALUE vresult = Qnil;
15570   
15571   if ((argc < 1) || (argc > 1)) {
15572     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15573   }
15574   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15575   if (!SWIG_IsOK(res1)) {
15576     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBraking" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15577   }
15578   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15579   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_unsigned_short,  0 );
15580   if (!SWIG_IsOK(res2)) {
15581     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetBraking" "', argument " "2"" of type '" "unsigned short &""'"); 
15582   }
15583   if (!argp2) {
15584     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBraking" "', argument " "2"" of type '" "unsigned short &""'"); 
15585   }
15586   arg2 = reinterpret_cast< unsigned short * >(argp2);
15587   {
15588     gCycleMovement const &_result_ref = ((gCycleMovement const *)arg1)->GetBraking(*arg2);
15589     result = (gCycleMovement *) &_result_ref;
15590   }
15591   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gCycleMovement, 0 |  0 );
15592   return vresult;
15593 fail:
15594   return Qnil;
15595 }
15596 
15597 
15598 SWIGINTERN VALUE _wrap_GCycleMovement_get_braking(int nargs, VALUE *args, VALUE self) {
15599   int argc;
15600   VALUE argv[3];
15601   int ii;
15602   
15603   argc = nargs + 1;
15604   argv[0] = self;
15605   if (argc > 3) SWIG_fail;
15606   for (ii = 1; (ii < argc); ii++) {
15607     argv[ii] = args[ii-1];
15608   }
15609   if (argc == 1) {
15610     int _v;
15611     void *vptr = 0;
15612     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15613     _v = SWIG_CheckState(res);
15614     if (_v) {
15615       return _wrap_GCycleMovement_get_braking__SWIG_0(nargs, args, self);
15616     }
15617   }
15618   if (argc == 2) {
15619     int _v;
15620     void *vptr = 0;
15621     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15622     _v = SWIG_CheckState(res);
15623     if (_v) {
15624       void *vptr = 0;
15625       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0);
15626       _v = SWIG_CheckState(res);
15627       if (_v) {
15628         return _wrap_GCycleMovement_get_braking__SWIG_1(nargs, args, self);
15629       }
15630     }
15631   }
15632   
15633 fail:
15634   rb_raise(rb_eArgError, "No matching function for overloaded 'GCycleMovement_get_braking'");
15635   return Qnil;
15636 }
15637 
15638 
15639 SWIGINTERN VALUE
15640 _wrap_GCycleMovement_get_braking_reservoir__SWIG_0(int argc, VALUE *argv, VALUE self) {
15641   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15642   REAL result;
15643   void *argp1 = 0 ;
15644   int res1 = 0 ;
15645   VALUE vresult = Qnil;
15646   
15647   if ((argc < 0) || (argc > 0)) {
15648     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15649   }
15650   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15651   if (!SWIG_IsOK(res1)) {
15652     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBrakingReservoir" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15653   }
15654   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15655   result = (REAL)((gCycleMovement const *)arg1)->GetBrakingReservoir();
15656   vresult = SWIG_From_float(static_cast< float >(result));
15657   return vresult;
15658 fail:
15659   return Qnil;
15660 }
15661 
15662 
15663 SWIGINTERN VALUE
15664 _wrap_GCycleMovement_get_braking_reservoir__SWIG_1(int argc, VALUE *argv, VALUE self) {
15665   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15666   REAL *arg2 = 0 ;
15667   gCycleMovement *result = 0 ;
15668   void *argp1 = 0 ;
15669   int res1 = 0 ;
15670   void *argp2 = 0 ;
15671   int res2 = 0 ;
15672   VALUE vresult = Qnil;
15673   
15674   if ((argc < 1) || (argc > 1)) {
15675     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15676   }
15677   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15678   if (!SWIG_IsOK(res1)) {
15679     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetBrakingReservoir" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15680   }
15681   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15682   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_float,  0 );
15683   if (!SWIG_IsOK(res2)) {
15684     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetBrakingReservoir" "', argument " "2"" of type '" "REAL &""'"); 
15685   }
15686   if (!argp2) {
15687     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetBrakingReservoir" "', argument " "2"" of type '" "REAL &""'"); 
15688   }
15689   arg2 = reinterpret_cast< REAL * >(argp2);
15690   {
15691     gCycleMovement const &_result_ref = ((gCycleMovement const *)arg1)->GetBrakingReservoir(*arg2);
15692     result = (gCycleMovement *) &_result_ref;
15693   }
15694   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gCycleMovement, 0 |  0 );
15695   return vresult;
15696 fail:
15697   return Qnil;
15698 }
15699 
15700 
15701 SWIGINTERN VALUE _wrap_GCycleMovement_get_braking_reservoir(int nargs, VALUE *args, VALUE self) {
15702   int argc;
15703   VALUE argv[3];
15704   int ii;
15705   
15706   argc = nargs + 1;
15707   argv[0] = self;
15708   if (argc > 3) SWIG_fail;
15709   for (ii = 1; (ii < argc); ii++) {
15710     argv[ii] = args[ii-1];
15711   }
15712   if (argc == 1) {
15713     int _v;
15714     void *vptr = 0;
15715     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15716     _v = SWIG_CheckState(res);
15717     if (_v) {
15718       return _wrap_GCycleMovement_get_braking_reservoir__SWIG_0(nargs, args, self);
15719     }
15720   }
15721   if (argc == 2) {
15722     int _v;
15723     void *vptr = 0;
15724     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15725     _v = SWIG_CheckState(res);
15726     if (_v) {
15727       void *vptr = 0;
15728       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
15729       _v = SWIG_CheckState(res);
15730       if (_v) {
15731         return _wrap_GCycleMovement_get_braking_reservoir__SWIG_1(nargs, args, self);
15732       }
15733     }
15734   }
15735   
15736 fail:
15737   rb_raise(rb_eArgError, "No matching function for overloaded 'GCycleMovement_get_braking_reservoir'");
15738   return Qnil;
15739 }
15740 
15741 
15742 SWIGINTERN VALUE
15743 _wrap_GCycleMovement_get_rubber_malus__SWIG_0(int argc, VALUE *argv, VALUE self) {
15744   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15745   REAL result;
15746   void *argp1 = 0 ;
15747   int res1 = 0 ;
15748   VALUE vresult = Qnil;
15749   
15750   if ((argc < 0) || (argc > 0)) {
15751     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15752   }
15753   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15754   if (!SWIG_IsOK(res1)) {
15755     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetRubberMalus" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15756   }
15757   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15758   result = (REAL)((gCycleMovement const *)arg1)->GetRubberMalus();
15759   vresult = SWIG_From_float(static_cast< float >(result));
15760   return vresult;
15761 fail:
15762   return Qnil;
15763 }
15764 
15765 
15766 SWIGINTERN VALUE
15767 _wrap_GCycleMovement_get_rubber_malus__SWIG_1(int argc, VALUE *argv, VALUE self) {
15768   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15769   REAL *arg2 = 0 ;
15770   gCycleMovement *result = 0 ;
15771   void *argp1 = 0 ;
15772   int res1 = 0 ;
15773   void *argp2 = 0 ;
15774   int res2 = 0 ;
15775   VALUE vresult = Qnil;
15776   
15777   if ((argc < 1) || (argc > 1)) {
15778     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15779   }
15780   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15781   if (!SWIG_IsOK(res1)) {
15782     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetRubberMalus" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15783   }
15784   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15785   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_float,  0 );
15786   if (!SWIG_IsOK(res2)) {
15787     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetRubberMalus" "', argument " "2"" of type '" "REAL &""'"); 
15788   }
15789   if (!argp2) {
15790     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetRubberMalus" "', argument " "2"" of type '" "REAL &""'"); 
15791   }
15792   arg2 = reinterpret_cast< REAL * >(argp2);
15793   {
15794     gCycleMovement const &_result_ref = ((gCycleMovement const *)arg1)->GetRubberMalus(*arg2);
15795     result = (gCycleMovement *) &_result_ref;
15796   }
15797   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gCycleMovement, 0 |  0 );
15798   return vresult;
15799 fail:
15800   return Qnil;
15801 }
15802 
15803 
15804 SWIGINTERN VALUE _wrap_GCycleMovement_get_rubber_malus(int nargs, VALUE *args, VALUE self) {
15805   int argc;
15806   VALUE argv[3];
15807   int ii;
15808   
15809   argc = nargs + 1;
15810   argv[0] = self;
15811   if (argc > 3) SWIG_fail;
15812   for (ii = 1; (ii < argc); ii++) {
15813     argv[ii] = args[ii-1];
15814   }
15815   if (argc == 1) {
15816     int _v;
15817     void *vptr = 0;
15818     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15819     _v = SWIG_CheckState(res);
15820     if (_v) {
15821       return _wrap_GCycleMovement_get_rubber_malus__SWIG_0(nargs, args, self);
15822     }
15823   }
15824   if (argc == 2) {
15825     int _v;
15826     void *vptr = 0;
15827     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15828     _v = SWIG_CheckState(res);
15829     if (_v) {
15830       void *vptr = 0;
15831       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
15832       _v = SWIG_CheckState(res);
15833       if (_v) {
15834         return _wrap_GCycleMovement_get_rubber_malus__SWIG_1(nargs, args, self);
15835       }
15836     }
15837   }
15838   
15839 fail:
15840   rb_raise(rb_eArgError, "No matching function for overloaded 'GCycleMovement_get_rubber_malus'");
15841   return Qnil;
15842 }
15843 
15844 
15845 SWIGINTERN VALUE
15846 _wrap_GCycleMovement_rubber_malus_active(int argc, VALUE *argv, VALUE self) {
15847   bool result;
15848   VALUE vresult = Qnil;
15849   
15850   if ((argc < 0) || (argc > 0)) {
15851     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15852   }
15853   result = (bool)gCycleMovement::RubberMalusActive();
15854   vresult = SWIG_From_bool(static_cast< bool >(result));
15855   return vresult;
15856 fail:
15857   return Qnil;
15858 }
15859 
15860 
15861 SWIGINTERN VALUE
15862 _wrap_GCycleMovement_get_last_turn_pos__SWIG_0(int argc, VALUE *argv, VALUE self) {
15863   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15864   eCoord *result = 0 ;
15865   void *argp1 = 0 ;
15866   int res1 = 0 ;
15867   VALUE vresult = Qnil;
15868   
15869   if ((argc < 0) || (argc > 0)) {
15870     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15871   }
15872   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15873   if (!SWIG_IsOK(res1)) {
15874     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetLastTurnPos" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15875   }
15876   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15877   {
15878     eCoord const &_result_ref = ((gCycleMovement const *)arg1)->GetLastTurnPos();
15879     result = (eCoord *) &_result_ref;
15880   }
15881   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eCoord, 0 |  0 );
15882   return vresult;
15883 fail:
15884   return Qnil;
15885 }
15886 
15887 
15888 SWIGINTERN VALUE
15889 _wrap_GCycleMovement_get_last_turn_pos__SWIG_1(int argc, VALUE *argv, VALUE self) {
15890   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15891   eCoord *arg2 = 0 ;
15892   gCycleMovement *result = 0 ;
15893   void *argp1 = 0 ;
15894   int res1 = 0 ;
15895   void *argp2 = 0 ;
15896   int res2 = 0 ;
15897   VALUE vresult = Qnil;
15898   
15899   if ((argc < 1) || (argc > 1)) {
15900     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15901   }
15902   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15903   if (!SWIG_IsOK(res1)) {
15904     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetLastTurnPos" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15905   }
15906   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15907   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_eCoord,  0 );
15908   if (!SWIG_IsOK(res2)) {
15909     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetLastTurnPos" "', argument " "2"" of type '" "eCoord &""'"); 
15910   }
15911   if (!argp2) {
15912     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetLastTurnPos" "', argument " "2"" of type '" "eCoord &""'"); 
15913   }
15914   arg2 = reinterpret_cast< eCoord * >(argp2);
15915   {
15916     gCycleMovement const &_result_ref = ((gCycleMovement const *)arg1)->GetLastTurnPos(*arg2);
15917     result = (gCycleMovement *) &_result_ref;
15918   }
15919   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gCycleMovement, 0 |  0 );
15920   return vresult;
15921 fail:
15922   return Qnil;
15923 }
15924 
15925 
15926 SWIGINTERN VALUE _wrap_GCycleMovement_get_last_turn_pos(int nargs, VALUE *args, VALUE self) {
15927   int argc;
15928   VALUE argv[3];
15929   int ii;
15930   
15931   argc = nargs + 1;
15932   argv[0] = self;
15933   if (argc > 3) SWIG_fail;
15934   for (ii = 1; (ii < argc); ii++) {
15935     argv[ii] = args[ii-1];
15936   }
15937   if (argc == 1) {
15938     int _v;
15939     void *vptr = 0;
15940     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15941     _v = SWIG_CheckState(res);
15942     if (_v) {
15943       return _wrap_GCycleMovement_get_last_turn_pos__SWIG_0(nargs, args, self);
15944     }
15945   }
15946   if (argc == 2) {
15947     int _v;
15948     void *vptr = 0;
15949     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
15950     _v = SWIG_CheckState(res);
15951     if (_v) {
15952       void *vptr = 0;
15953       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eCoord, 0);
15954       _v = SWIG_CheckState(res);
15955       if (_v) {
15956         return _wrap_GCycleMovement_get_last_turn_pos__SWIG_1(nargs, args, self);
15957       }
15958     }
15959   }
15960   
15961 fail:
15962   rb_raise(rb_eArgError, "No matching function for overloaded 'GCycleMovement_get_last_turn_pos'");
15963   return Qnil;
15964 }
15965 
15966 
15967 SWIGINTERN VALUE
15968 _wrap_GCycleMovement_get_last_turn_time__SWIG_0(int argc, VALUE *argv, VALUE self) {
15969   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15970   REAL *result = 0 ;
15971   void *argp1 = 0 ;
15972   int res1 = 0 ;
15973   VALUE vresult = Qnil;
15974   
15975   if ((argc < 0) || (argc > 0)) {
15976     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15977   }
15978   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
15979   if (!SWIG_IsOK(res1)) {
15980     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetLastTurnTime" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
15981   }
15982   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
15983   {
15984     REAL const &_result_ref = ((gCycleMovement const *)arg1)->GetLastTurnTime();
15985     result = (REAL *) &_result_ref;
15986   }
15987   vresult = SWIG_From_float(static_cast< float >(*result));
15988   return vresult;
15989 fail:
15990   return Qnil;
15991 }
15992 
15993 
15994 SWIGINTERN VALUE
15995 _wrap_GCycleMovement_get_last_turn_time__SWIG_1(int argc, VALUE *argv, VALUE self) {
15996   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
15997   REAL *arg2 = 0 ;
15998   gCycleMovement *result = 0 ;
15999   void *argp1 = 0 ;
16000   int res1 = 0 ;
16001   void *argp2 = 0 ;
16002   int res2 = 0 ;
16003   VALUE vresult = Qnil;
16004   
16005   if ((argc < 1) || (argc > 1)) {
16006     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16007   }
16008   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
16009   if (!SWIG_IsOK(res1)) {
16010     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetLastTurnTime" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
16011   }
16012   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
16013   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_float,  0 );
16014   if (!SWIG_IsOK(res2)) {
16015     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GetLastTurnTime" "', argument " "2"" of type '" "REAL &""'"); 
16016   }
16017   if (!argp2) {
16018     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetLastTurnTime" "', argument " "2"" of type '" "REAL &""'"); 
16019   }
16020   arg2 = reinterpret_cast< REAL * >(argp2);
16021   {
16022     gCycleMovement const &_result_ref = ((gCycleMovement const *)arg1)->GetLastTurnTime(*arg2);
16023     result = (gCycleMovement *) &_result_ref;
16024   }
16025   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gCycleMovement, 0 |  0 );
16026   return vresult;
16027 fail:
16028   return Qnil;
16029 }
16030 
16031 
16032 SWIGINTERN VALUE _wrap_GCycleMovement_get_last_turn_time(int nargs, VALUE *args, VALUE self) {
16033   int argc;
16034   VALUE argv[3];
16035   int ii;
16036   
16037   argc = nargs + 1;
16038   argv[0] = self;
16039   if (argc > 3) SWIG_fail;
16040   for (ii = 1; (ii < argc); ii++) {
16041     argv[ii] = args[ii-1];
16042   }
16043   if (argc == 1) {
16044     int _v;
16045     void *vptr = 0;
16046     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
16047     _v = SWIG_CheckState(res);
16048     if (_v) {
16049       return _wrap_GCycleMovement_get_last_turn_time__SWIG_0(nargs, args, self);
16050     }
16051   }
16052   if (argc == 2) {
16053     int _v;
16054     void *vptr = 0;
16055     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycleMovement, 0);
16056     _v = SWIG_CheckState(res);
16057     if (_v) {
16058       void *vptr = 0;
16059       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
16060       _v = SWIG_CheckState(res);
16061       if (_v) {
16062         return _wrap_GCycleMovement_get_last_turn_time__SWIG_1(nargs, args, self);
16063       }
16064     }
16065   }
16066   
16067 fail:
16068   rb_raise(rb_eArgError, "No matching function for overloaded 'GCycleMovement_get_last_turn_time'");
16069   return Qnil;
16070 }
16071 
16072 
16073 SWIGINTERN VALUE
16074 _wrap_GCycleMovement_get_acceleration(int argc, VALUE *argv, VALUE self) {
16075   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
16076   REAL result;
16077   void *argp1 = 0 ;
16078   int res1 = 0 ;
16079   VALUE vresult = Qnil;
16080   
16081   if ((argc < 0) || (argc > 0)) {
16082     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16083   }
16084   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
16085   if (!SWIG_IsOK(res1)) {
16086     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GetAcceleration" "', argument " "1"" of type '" "gCycleMovement const *""'"); 
16087   }
16088   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
16089   result = (REAL)((gCycleMovement const *)arg1)->GetAcceleration();
16090   vresult = SWIG_From_float(static_cast< float >(result));
16091   return vresult;
16092 fail:
16093   return Qnil;
16094 }
16095 
16096 
16097 SWIGINTERN VALUE
16098 _wrap_GCycleMovement_set_rubber(int argc, VALUE *argv, VALUE self) {
16099   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
16100   REAL arg2 ;
16101   gCycleMovement *result = 0 ;
16102   void *argp1 = 0 ;
16103   int res1 = 0 ;
16104   float val2 ;
16105   int ecode2 = 0 ;
16106   VALUE vresult = Qnil;
16107   
16108   if ((argc < 1) || (argc > 1)) {
16109     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16110   }
16111   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
16112   if (!SWIG_IsOK(res1)) {
16113     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetRubber" "', argument " "1"" of type '" "gCycleMovement *""'"); 
16114   }
16115   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
16116   ecode2 = SWIG_AsVal_float(argv[0], &val2);
16117   if (!SWIG_IsOK(ecode2)) {
16118     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetRubber" "', argument " "2"" of type '" "REAL""'");
16119   } 
16120   arg2 = static_cast< REAL >(val2);
16121   {
16122     gCycleMovement &_result_ref = (arg1)->SetRubber(arg2);
16123     result = (gCycleMovement *) &_result_ref;
16124   }
16125   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gCycleMovement, 0 |  0 );
16126   return vresult;
16127 fail:
16128   return Qnil;
16129 }
16130 
16131 
16132 SWIGINTERN VALUE
16133 _wrap_GCycleMovement_set_braking_reservoir(int argc, VALUE *argv, VALUE self) {
16134   gCycleMovement *arg1 = (gCycleMovement *) 0 ;
16135   REAL arg2 ;
16136   gCycleMovement *result = 0 ;
16137   void *argp1 = 0 ;
16138   int res1 = 0 ;
16139   float val2 ;
16140   int ecode2 = 0 ;
16141   VALUE vresult = Qnil;
16142   
16143   if ((argc < 1) || (argc > 1)) {
16144     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16145   }
16146   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycleMovement, 0 |  0 );
16147   if (!SWIG_IsOK(res1)) {
16148     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetBrakingReservoir" "', argument " "1"" of type '" "gCycleMovement *""'"); 
16149   }
16150   arg1 = reinterpret_cast< gCycleMovement * >(argp1);
16151   ecode2 = SWIG_AsVal_float(argv[0], &val2);
16152   if (!SWIG_IsOK(ecode2)) {
16153     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SetBrakingReservoir" "', argument " "2"" of type '" "REAL""'");
16154   } 
16155   arg2 = static_cast< REAL >(val2);
16156   {
16157     gCycleMovement &_result_ref = (arg1)->SetBrakingReservoir(arg2);
16158     result = (gCycleMovement *) &_result_ref;
16159   }
16160   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gCycleMovement, 0 |  0 );
16161   return vresult;
16162 fail:
16163   return Qnil;
16164 }
16165 
16166 
16167 swig_class cGCycle;
16168 
16169 SWIGINTERN VALUE
16170 _wrap_GCycle_lastGoodPosition__set(int argc, VALUE *argv, VALUE self) {
16171   gCycle *arg1 = (gCycle *) 0 ;
16172   eCoord arg2 ;
16173   void *argp1 = 0 ;
16174   int res1 = 0 ;
16175   void *argp2 ;
16176   int res2 = 0 ;
16177   
16178   if ((argc < 1) || (argc > 1)) {
16179     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16180   }
16181   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16182   if (!SWIG_IsOK(res1)) {
16183     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lastGoodPosition_" "', argument " "1"" of type '" "gCycle *""'"); 
16184   }
16185   arg1 = reinterpret_cast< gCycle * >(argp1);
16186   {
16187     res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_eCoord,  0 );
16188     if (!SWIG_IsOK(res2)) {
16189       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lastGoodPosition_" "', argument " "2"" of type '" "eCoord""'"); 
16190     }  
16191     if (!argp2) {
16192       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "lastGoodPosition_" "', argument " "2"" of type '" "eCoord""'");
16193     } else {
16194       arg2 = *(reinterpret_cast< eCoord * >(argp2));
16195     }
16196   }
16197   if (arg1) (arg1)->lastGoodPosition_ = arg2;
16198   
16199   return Qnil;
16200 fail:
16201   return Qnil;
16202 }
16203 
16204 
16205 SWIGINTERN VALUE
16206 _wrap_GCycle_lastGoodPosition__get(int argc, VALUE *argv, VALUE self) {
16207   gCycle *arg1 = (gCycle *) 0 ;
16208   eCoord result;
16209   void *argp1 = 0 ;
16210   int res1 = 0 ;
16211   VALUE vresult = Qnil;
16212   
16213   if ((argc < 0) || (argc > 0)) {
16214     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16215   }
16216   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16217   if (!SWIG_IsOK(res1)) {
16218     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lastGoodPosition_" "', argument " "1"" of type '" "gCycle *""'"); 
16219   }
16220   arg1 = reinterpret_cast< gCycle * >(argp1);
16221   result =  ((arg1)->lastGoodPosition_);
16222   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
16223   return vresult;
16224 fail:
16225   return Qnil;
16226 }
16227 
16228 
16229 SWIGINTERN VALUE
16230 _wrap_GCycle_skew_set(int argc, VALUE *argv, VALUE self) {
16231   gCycle *arg1 = (gCycle *) 0 ;
16232   REAL arg2 ;
16233   void *argp1 = 0 ;
16234   int res1 = 0 ;
16235   float val2 ;
16236   int ecode2 = 0 ;
16237   
16238   if ((argc < 1) || (argc > 1)) {
16239     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16240   }
16241   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16242   if (!SWIG_IsOK(res1)) {
16243     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "skew" "', argument " "1"" of type '" "gCycle *""'"); 
16244   }
16245   arg1 = reinterpret_cast< gCycle * >(argp1);
16246   ecode2 = SWIG_AsVal_float(argv[0], &val2);
16247   if (!SWIG_IsOK(ecode2)) {
16248     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "skew" "', argument " "2"" of type '" "REAL""'");
16249   } 
16250   arg2 = static_cast< REAL >(val2);
16251   if (arg1) (arg1)->skew = arg2;
16252   
16253   return Qnil;
16254 fail:
16255   return Qnil;
16256 }
16257 
16258 
16259 SWIGINTERN VALUE
16260 _wrap_GCycle_skew_get(int argc, VALUE *argv, VALUE self) {
16261   gCycle *arg1 = (gCycle *) 0 ;
16262   REAL result;
16263   void *argp1 = 0 ;
16264   int res1 = 0 ;
16265   VALUE vresult = Qnil;
16266   
16267   if ((argc < 0) || (argc > 0)) {
16268     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16269   }
16270   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16271   if (!SWIG_IsOK(res1)) {
16272     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "skew" "', argument " "1"" of type '" "gCycle *""'"); 
16273   }
16274   arg1 = reinterpret_cast< gCycle * >(argp1);
16275   result = (REAL) ((arg1)->skew);
16276   vresult = SWIG_From_float(static_cast< float >(result));
16277   return vresult;
16278 fail:
16279   return Qnil;
16280 }
16281 
16282 
16283 SWIGINTERN VALUE
16284 _wrap_GCycle_skewDot_set(int argc, VALUE *argv, VALUE self) {
16285   gCycle *arg1 = (gCycle *) 0 ;
16286   REAL arg2 ;
16287   void *argp1 = 0 ;
16288   int res1 = 0 ;
16289   float val2 ;
16290   int ecode2 = 0 ;
16291   
16292   if ((argc < 1) || (argc > 1)) {
16293     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16294   }
16295   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16296   if (!SWIG_IsOK(res1)) {
16297     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "skewDot" "', argument " "1"" of type '" "gCycle *""'"); 
16298   }
16299   arg1 = reinterpret_cast< gCycle * >(argp1);
16300   ecode2 = SWIG_AsVal_float(argv[0], &val2);
16301   if (!SWIG_IsOK(ecode2)) {
16302     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "skewDot" "', argument " "2"" of type '" "REAL""'");
16303   } 
16304   arg2 = static_cast< REAL >(val2);
16305   if (arg1) (arg1)->skewDot = arg2;
16306   
16307   return Qnil;
16308 fail:
16309   return Qnil;
16310 }
16311 
16312 
16313 SWIGINTERN VALUE
16314 _wrap_GCycle_skewDot_get(int argc, VALUE *argv, VALUE self) {
16315   gCycle *arg1 = (gCycle *) 0 ;
16316   REAL result;
16317   void *argp1 = 0 ;
16318   int res1 = 0 ;
16319   VALUE vresult = Qnil;
16320   
16321   if ((argc < 0) || (argc > 0)) {
16322     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16323   }
16324   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16325   if (!SWIG_IsOK(res1)) {
16326     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "skewDot" "', argument " "1"" of type '" "gCycle *""'"); 
16327   }
16328   arg1 = reinterpret_cast< gCycle * >(argp1);
16329   result = (REAL) ((arg1)->skewDot);
16330   vresult = SWIG_From_float(static_cast< float >(result));
16331   return vresult;
16332 fail:
16333   return Qnil;
16334 }
16335 
16336 
16337 SWIGINTERN VALUE
16338 _wrap_GCycle_mp_set(int argc, VALUE *argv, VALUE self) {
16339   gCycle *arg1 = (gCycle *) 0 ;
16340   bool arg2 ;
16341   void *argp1 = 0 ;
16342   int res1 = 0 ;
16343   bool val2 ;
16344   int ecode2 = 0 ;
16345   
16346   if ((argc < 1) || (argc > 1)) {
16347     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16348   }
16349   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16350   if (!SWIG_IsOK(res1)) {
16351     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mp" "', argument " "1"" of type '" "gCycle *""'"); 
16352   }
16353   arg1 = reinterpret_cast< gCycle * >(argp1);
16354   ecode2 = SWIG_AsVal_bool(argv[0], &val2);
16355   if (!SWIG_IsOK(ecode2)) {
16356     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mp" "', argument " "2"" of type '" "bool""'");
16357   } 
16358   arg2 = static_cast< bool >(val2);
16359   if (arg1) (arg1)->mp = arg2;
16360   
16361   return Qnil;
16362 fail:
16363   return Qnil;
16364 }
16365 
16366 
16367 SWIGINTERN VALUE
16368 _wrap_GCycle_mp_get(int argc, VALUE *argv, VALUE self) {
16369   gCycle *arg1 = (gCycle *) 0 ;
16370   bool result;
16371   void *argp1 = 0 ;
16372   int res1 = 0 ;
16373   VALUE vresult = Qnil;
16374   
16375   if ((argc < 0) || (argc > 0)) {
16376     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16377   }
16378   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16379   if (!SWIG_IsOK(res1)) {
16380     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mp" "', argument " "1"" of type '" "gCycle *""'"); 
16381   }
16382   arg1 = reinterpret_cast< gCycle * >(argp1);
16383   result = (bool) ((arg1)->mp);
16384   vresult = SWIG_From_bool(static_cast< bool >(result));
16385   return vresult;
16386 fail:
16387   return Qnil;
16388 }
16389 
16390 
16391 SWIGINTERN VALUE
16392 _wrap_GCycle_body_set(int argc, VALUE *argv, VALUE self) {
16393   gCycle *arg1 = (gCycle *) 0 ;
16394   rModel *arg2 = (rModel *) 0 ;
16395   void *argp1 = 0 ;
16396   int res1 = 0 ;
16397   void *argp2 = 0 ;
16398   int res2 = 0 ;
16399   
16400   if ((argc < 1) || (argc > 1)) {
16401     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16402   }
16403   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16404   if (!SWIG_IsOK(res1)) {
16405     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "body" "', argument " "1"" of type '" "gCycle *""'"); 
16406   }
16407   arg1 = reinterpret_cast< gCycle * >(argp1);
16408   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_rModel, SWIG_POINTER_DISOWN |  0 );
16409   if (!SWIG_IsOK(res2)) {
16410     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "body" "', argument " "2"" of type '" "rModel *""'"); 
16411   }
16412   arg2 = reinterpret_cast< rModel * >(argp2);
16413   if (arg1) (arg1)->body = arg2;
16414   
16415   return Qnil;
16416 fail:
16417   return Qnil;
16418 }
16419 
16420 
16421 SWIGINTERN VALUE
16422 _wrap_GCycle_body_get(int argc, VALUE *argv, VALUE self) {
16423   gCycle *arg1 = (gCycle *) 0 ;
16424   rModel *result = 0 ;
16425   void *argp1 = 0 ;
16426   int res1 = 0 ;
16427   VALUE vresult = Qnil;
16428   
16429   if ((argc < 0) || (argc > 0)) {
16430     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16431   }
16432   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16433   if (!SWIG_IsOK(res1)) {
16434     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "body" "', argument " "1"" of type '" "gCycle *""'"); 
16435   }
16436   arg1 = reinterpret_cast< gCycle * >(argp1);
16437   result = (rModel *) ((arg1)->body);
16438   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rModel, 0 |  0 );
16439   return vresult;
16440 fail:
16441   return Qnil;
16442 }
16443 
16444 
16445 SWIGINTERN VALUE
16446 _wrap_GCycle_front_set(int argc, VALUE *argv, VALUE self) {
16447   gCycle *arg1 = (gCycle *) 0 ;
16448   rModel *arg2 = (rModel *) 0 ;
16449   void *argp1 = 0 ;
16450   int res1 = 0 ;
16451   void *argp2 = 0 ;
16452   int res2 = 0 ;
16453   
16454   if ((argc < 1) || (argc > 1)) {
16455     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16456   }
16457   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16458   if (!SWIG_IsOK(res1)) {
16459     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "front" "', argument " "1"" of type '" "gCycle *""'"); 
16460   }
16461   arg1 = reinterpret_cast< gCycle * >(argp1);
16462   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_rModel, SWIG_POINTER_DISOWN |  0 );
16463   if (!SWIG_IsOK(res2)) {
16464     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "front" "', argument " "2"" of type '" "rModel *""'"); 
16465   }
16466   arg2 = reinterpret_cast< rModel * >(argp2);
16467   if (arg1) (arg1)->front = arg2;
16468   
16469   return Qnil;
16470 fail:
16471   return Qnil;
16472 }
16473 
16474 
16475 SWIGINTERN VALUE
16476 _wrap_GCycle_front_get(int argc, VALUE *argv, VALUE self) {
16477   gCycle *arg1 = (gCycle *) 0 ;
16478   rModel *result = 0 ;
16479   void *argp1 = 0 ;
16480   int res1 = 0 ;
16481   VALUE vresult = Qnil;
16482   
16483   if ((argc < 0) || (argc > 0)) {
16484     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16485   }
16486   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16487   if (!SWIG_IsOK(res1)) {
16488     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "front" "', argument " "1"" of type '" "gCycle *""'"); 
16489   }
16490   arg1 = reinterpret_cast< gCycle * >(argp1);
16491   result = (rModel *) ((arg1)->front);
16492   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rModel, 0 |  0 );
16493   return vresult;
16494 fail:
16495   return Qnil;
16496 }
16497 
16498 
16499 SWIGINTERN VALUE
16500 _wrap_GCycle_rear_set(int argc, VALUE *argv, VALUE self) {
16501   gCycle *arg1 = (gCycle *) 0 ;
16502   rModel *arg2 = (rModel *) 0 ;
16503   void *argp1 = 0 ;
16504   int res1 = 0 ;
16505   void *argp2 = 0 ;
16506   int res2 = 0 ;
16507   
16508   if ((argc < 1) || (argc > 1)) {
16509     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16510   }
16511   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16512   if (!SWIG_IsOK(res1)) {
16513     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rear" "', argument " "1"" of type '" "gCycle *""'"); 
16514   }
16515   arg1 = reinterpret_cast< gCycle * >(argp1);
16516   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_rModel, SWIG_POINTER_DISOWN |  0 );
16517   if (!SWIG_IsOK(res2)) {
16518     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rear" "', argument " "2"" of type '" "rModel *""'"); 
16519   }
16520   arg2 = reinterpret_cast< rModel * >(argp2);
16521   if (arg1) (arg1)->rear = arg2;
16522   
16523   return Qnil;
16524 fail:
16525   return Qnil;
16526 }
16527 
16528 
16529 SWIGINTERN VALUE
16530 _wrap_GCycle_rear_get(int argc, VALUE *argv, VALUE self) {
16531   gCycle *arg1 = (gCycle *) 0 ;
16532   rModel *result = 0 ;
16533   void *argp1 = 0 ;
16534   int res1 = 0 ;
16535   VALUE vresult = Qnil;
16536   
16537   if ((argc < 0) || (argc > 0)) {
16538     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16539   }
16540   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16541   if (!SWIG_IsOK(res1)) {
16542     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rear" "', argument " "1"" of type '" "gCycle *""'"); 
16543   }
16544   arg1 = reinterpret_cast< gCycle * >(argp1);
16545   result = (rModel *) ((arg1)->rear);
16546   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rModel, 0 |  0 );
16547   return vresult;
16548 fail:
16549   return Qnil;
16550 }
16551 
16552 
16553 SWIGINTERN VALUE
16554 _wrap_GCycle_customModel_set(int argc, VALUE *argv, VALUE self) {
16555   gCycle *arg1 = (gCycle *) 0 ;
16556   rModel *arg2 = (rModel *) 0 ;
16557   void *argp1 = 0 ;
16558   int res1 = 0 ;
16559   void *argp2 = 0 ;
16560   int res2 = 0 ;
16561   
16562   if ((argc < 1) || (argc > 1)) {
16563     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16564   }
16565   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16566   if (!SWIG_IsOK(res1)) {
16567     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "customModel" "', argument " "1"" of type '" "gCycle *""'"); 
16568   }
16569   arg1 = reinterpret_cast< gCycle * >(argp1);
16570   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_rModel, SWIG_POINTER_DISOWN |  0 );
16571   if (!SWIG_IsOK(res2)) {
16572     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "customModel" "', argument " "2"" of type '" "rModel *""'"); 
16573   }
16574   arg2 = reinterpret_cast< rModel * >(argp2);
16575   if (arg1) (arg1)->customModel = arg2;
16576   
16577   return Qnil;
16578 fail:
16579   return Qnil;
16580 }
16581 
16582 
16583 SWIGINTERN VALUE
16584 _wrap_GCycle_customModel_get(int argc, VALUE *argv, VALUE self) {
16585   gCycle *arg1 = (gCycle *) 0 ;
16586   rModel *result = 0 ;
16587   void *argp1 = 0 ;
16588   int res1 = 0 ;
16589   VALUE vresult = Qnil;
16590   
16591   if ((argc < 0) || (argc > 0)) {
16592     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16593   }
16594   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16595   if (!SWIG_IsOK(res1)) {
16596     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "customModel" "', argument " "1"" of type '" "gCycle *""'"); 
16597   }
16598   arg1 = reinterpret_cast< gCycle * >(argp1);
16599   result = (rModel *) ((arg1)->customModel);
16600   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rModel, 0 |  0 );
16601   return vresult;
16602 fail:
16603   return Qnil;
16604 }
16605 
16606 
16607 SWIGINTERN VALUE
16608 _wrap_GCycle_wheelTex_set(int argc, VALUE *argv, VALUE self) {
16609   gCycle *arg1 = (gCycle *) 0 ;
16610   gTextureCycle *arg2 = (gTextureCycle *) 0 ;
16611   void *argp1 = 0 ;
16612   int res1 = 0 ;
16613   void *argp2 = 0 ;
16614   int res2 = 0 ;
16615   
16616   if ((argc < 1) || (argc > 1)) {
16617     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16618   }
16619   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16620   if (!SWIG_IsOK(res1)) {
16621     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wheelTex" "', argument " "1"" of type '" "gCycle *""'"); 
16622   }
16623   arg1 = reinterpret_cast< gCycle * >(argp1);
16624   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_gTextureCycle, SWIG_POINTER_DISOWN |  0 );
16625   if (!SWIG_IsOK(res2)) {
16626     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wheelTex" "', argument " "2"" of type '" "gTextureCycle *""'"); 
16627   }
16628   arg2 = reinterpret_cast< gTextureCycle * >(argp2);
16629   if (arg1) (arg1)->wheelTex = arg2;
16630   
16631   return Qnil;
16632 fail:
16633   return Qnil;
16634 }
16635 
16636 
16637 SWIGINTERN VALUE
16638 _wrap_GCycle_wheelTex_get(int argc, VALUE *argv, VALUE self) {
16639   gCycle *arg1 = (gCycle *) 0 ;
16640   gTextureCycle *result = 0 ;
16641   void *argp1 = 0 ;
16642   int res1 = 0 ;
16643   VALUE vresult = Qnil;
16644   
16645   if ((argc < 0) || (argc > 0)) {
16646     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16647   }
16648   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16649   if (!SWIG_IsOK(res1)) {
16650     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wheelTex" "', argument " "1"" of type '" "gCycle *""'"); 
16651   }
16652   arg1 = reinterpret_cast< gCycle * >(argp1);
16653   result = (gTextureCycle *) ((arg1)->wheelTex);
16654   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gTextureCycle, 0 |  0 );
16655   return vresult;
16656 fail:
16657   return Qnil;
16658 }
16659 
16660 
16661 SWIGINTERN VALUE
16662 _wrap_GCycle_bodyTex_set(int argc, VALUE *argv, VALUE self) {
16663   gCycle *arg1 = (gCycle *) 0 ;
16664   gTextureCycle *arg2 = (gTextureCycle *) 0 ;
16665   void *argp1 = 0 ;
16666   int res1 = 0 ;
16667   void *argp2 = 0 ;
16668   int res2 = 0 ;
16669   
16670   if ((argc < 1) || (argc > 1)) {
16671     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16672   }
16673   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16674   if (!SWIG_IsOK(res1)) {
16675     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bodyTex" "', argument " "1"" of type '" "gCycle *""'"); 
16676   }
16677   arg1 = reinterpret_cast< gCycle * >(argp1);
16678   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_gTextureCycle, SWIG_POINTER_DISOWN |  0 );
16679   if (!SWIG_IsOK(res2)) {
16680     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bodyTex" "', argument " "2"" of type '" "gTextureCycle *""'"); 
16681   }
16682   arg2 = reinterpret_cast< gTextureCycle * >(argp2);
16683   if (arg1) (arg1)->bodyTex = arg2;
16684   
16685   return Qnil;
16686 fail:
16687   return Qnil;
16688 }
16689 
16690 
16691 SWIGINTERN VALUE
16692 _wrap_GCycle_bodyTex_get(int argc, VALUE *argv, VALUE self) {
16693   gCycle *arg1 = (gCycle *) 0 ;
16694   gTextureCycle *result = 0 ;
16695   void *argp1 = 0 ;
16696   int res1 = 0 ;
16697   VALUE vresult = Qnil;
16698   
16699   if ((argc < 0) || (argc > 0)) {
16700     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16701   }
16702   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16703   if (!SWIG_IsOK(res1)) {
16704     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bodyTex" "', argument " "1"" of type '" "gCycle *""'"); 
16705   }
16706   arg1 = reinterpret_cast< gCycle * >(argp1);
16707   result = (gTextureCycle *) ((arg1)->bodyTex);
16708   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gTextureCycle, 0 |  0 );
16709   return vresult;
16710 fail:
16711   return Qnil;
16712 }
16713 
16714 
16715 SWIGINTERN VALUE
16716 _wrap_GCycle_customTexture_set(int argc, VALUE *argv, VALUE self) {
16717   gCycle *arg1 = (gCycle *) 0 ;
16718   gTextureCycle *arg2 = (gTextureCycle *) 0 ;
16719   void *argp1 = 0 ;
16720   int res1 = 0 ;
16721   void *argp2 = 0 ;
16722   int res2 = 0 ;
16723   
16724   if ((argc < 1) || (argc > 1)) {
16725     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16726   }
16727   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16728   if (!SWIG_IsOK(res1)) {
16729     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "customTexture" "', argument " "1"" of type '" "gCycle *""'"); 
16730   }
16731   arg1 = reinterpret_cast< gCycle * >(argp1);
16732   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_gTextureCycle, SWIG_POINTER_DISOWN |  0 );
16733   if (!SWIG_IsOK(res2)) {
16734     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "customTexture" "', argument " "2"" of type '" "gTextureCycle *""'"); 
16735   }
16736   arg2 = reinterpret_cast< gTextureCycle * >(argp2);
16737   if (arg1) (arg1)->customTexture = arg2;
16738   
16739   return Qnil;
16740 fail:
16741   return Qnil;
16742 }
16743 
16744 
16745 SWIGINTERN VALUE
16746 _wrap_GCycle_customTexture_get(int argc, VALUE *argv, VALUE self) {
16747   gCycle *arg1 = (gCycle *) 0 ;
16748   gTextureCycle *result = 0 ;
16749   void *argp1 = 0 ;
16750   int res1 = 0 ;
16751   VALUE vresult = Qnil;
16752   
16753   if ((argc < 0) || (argc > 0)) {
16754     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16755   }
16756   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16757   if (!SWIG_IsOK(res1)) {
16758     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "customTexture" "', argument " "1"" of type '" "gCycle *""'"); 
16759   }
16760   arg1 = reinterpret_cast< gCycle * >(argp1);
16761   result = (gTextureCycle *) ((arg1)->customTexture);
16762   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gTextureCycle, 0 |  0 );
16763   return vresult;
16764 fail:
16765   return Qnil;
16766 }
16767 
16768 
16769 SWIGINTERN VALUE
16770 _wrap_GCycle_rotationFrontWheel_set(int argc, VALUE *argv, VALUE self) {
16771   gCycle *arg1 = (gCycle *) 0 ;
16772   eCoord arg2 ;
16773   void *argp1 = 0 ;
16774   int res1 = 0 ;
16775   void *argp2 ;
16776   int res2 = 0 ;
16777   
16778   if ((argc < 1) || (argc > 1)) {
16779     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16780   }
16781   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16782   if (!SWIG_IsOK(res1)) {
16783     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rotationFrontWheel" "', argument " "1"" of type '" "gCycle *""'"); 
16784   }
16785   arg1 = reinterpret_cast< gCycle * >(argp1);
16786   {
16787     res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_eCoord,  0 );
16788     if (!SWIG_IsOK(res2)) {
16789       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rotationFrontWheel" "', argument " "2"" of type '" "eCoord""'"); 
16790     }  
16791     if (!argp2) {
16792       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rotationFrontWheel" "', argument " "2"" of type '" "eCoord""'");
16793     } else {
16794       arg2 = *(reinterpret_cast< eCoord * >(argp2));
16795     }
16796   }
16797   if (arg1) (arg1)->rotationFrontWheel = arg2;
16798   
16799   return Qnil;
16800 fail:
16801   return Qnil;
16802 }
16803 
16804 
16805 SWIGINTERN VALUE
16806 _wrap_GCycle_rotationFrontWheel_get(int argc, VALUE *argv, VALUE self) {
16807   gCycle *arg1 = (gCycle *) 0 ;
16808   eCoord result;
16809   void *argp1 = 0 ;
16810   int res1 = 0 ;
16811   VALUE vresult = Qnil;
16812   
16813   if ((argc < 0) || (argc > 0)) {
16814     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16815   }
16816   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16817   if (!SWIG_IsOK(res1)) {
16818     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rotationFrontWheel" "', argument " "1"" of type '" "gCycle *""'"); 
16819   }
16820   arg1 = reinterpret_cast< gCycle * >(argp1);
16821   result =  ((arg1)->rotationFrontWheel);
16822   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
16823   return vresult;
16824 fail:
16825   return Qnil;
16826 }
16827 
16828 
16829 SWIGINTERN VALUE
16830 _wrap_GCycle_rotationRearWheel_set(int argc, VALUE *argv, VALUE self) {
16831   gCycle *arg1 = (gCycle *) 0 ;
16832   eCoord arg2 ;
16833   void *argp1 = 0 ;
16834   int res1 = 0 ;
16835   void *argp2 ;
16836   int res2 = 0 ;
16837   
16838   if ((argc < 1) || (argc > 1)) {
16839     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16840   }
16841   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16842   if (!SWIG_IsOK(res1)) {
16843     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rotationRearWheel" "', argument " "1"" of type '" "gCycle *""'"); 
16844   }
16845   arg1 = reinterpret_cast< gCycle * >(argp1);
16846   {
16847     res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_eCoord,  0 );
16848     if (!SWIG_IsOK(res2)) {
16849       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rotationRearWheel" "', argument " "2"" of type '" "eCoord""'"); 
16850     }  
16851     if (!argp2) {
16852       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rotationRearWheel" "', argument " "2"" of type '" "eCoord""'");
16853     } else {
16854       arg2 = *(reinterpret_cast< eCoord * >(argp2));
16855     }
16856   }
16857   if (arg1) (arg1)->rotationRearWheel = arg2;
16858   
16859   return Qnil;
16860 fail:
16861   return Qnil;
16862 }
16863 
16864 
16865 SWIGINTERN VALUE
16866 _wrap_GCycle_rotationRearWheel_get(int argc, VALUE *argv, VALUE self) {
16867   gCycle *arg1 = (gCycle *) 0 ;
16868   eCoord result;
16869   void *argp1 = 0 ;
16870   int res1 = 0 ;
16871   VALUE vresult = Qnil;
16872   
16873   if ((argc < 0) || (argc > 0)) {
16874     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16875   }
16876   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16877   if (!SWIG_IsOK(res1)) {
16878     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rotationRearWheel" "', argument " "1"" of type '" "gCycle *""'"); 
16879   }
16880   arg1 = reinterpret_cast< gCycle * >(argp1);
16881   result =  ((arg1)->rotationRearWheel);
16882   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
16883   return vresult;
16884 fail:
16885   return Qnil;
16886 }
16887 
16888 
16889 SWIGINTERN VALUE
16890 _wrap_GCycle_heightFrontWheel_set(int argc, VALUE *argv, VALUE self) {
16891   gCycle *arg1 = (gCycle *) 0 ;
16892   REAL arg2 ;
16893   void *argp1 = 0 ;
16894   int res1 = 0 ;
16895   float val2 ;
16896   int ecode2 = 0 ;
16897   
16898   if ((argc < 1) || (argc > 1)) {
16899     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16900   }
16901   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16902   if (!SWIG_IsOK(res1)) {
16903     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "heightFrontWheel" "', argument " "1"" of type '" "gCycle *""'"); 
16904   }
16905   arg1 = reinterpret_cast< gCycle * >(argp1);
16906   ecode2 = SWIG_AsVal_float(argv[0], &val2);
16907   if (!SWIG_IsOK(ecode2)) {
16908     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "heightFrontWheel" "', argument " "2"" of type '" "REAL""'");
16909   } 
16910   arg2 = static_cast< REAL >(val2);
16911   if (arg1) (arg1)->heightFrontWheel = arg2;
16912   
16913   return Qnil;
16914 fail:
16915   return Qnil;
16916 }
16917 
16918 
16919 SWIGINTERN VALUE
16920 _wrap_GCycle_heightFrontWheel_get(int argc, VALUE *argv, VALUE self) {
16921   gCycle *arg1 = (gCycle *) 0 ;
16922   REAL result;
16923   void *argp1 = 0 ;
16924   int res1 = 0 ;
16925   VALUE vresult = Qnil;
16926   
16927   if ((argc < 0) || (argc > 0)) {
16928     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16929   }
16930   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16931   if (!SWIG_IsOK(res1)) {
16932     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "heightFrontWheel" "', argument " "1"" of type '" "gCycle *""'"); 
16933   }
16934   arg1 = reinterpret_cast< gCycle * >(argp1);
16935   result = (REAL) ((arg1)->heightFrontWheel);
16936   vresult = SWIG_From_float(static_cast< float >(result));
16937   return vresult;
16938 fail:
16939   return Qnil;
16940 }
16941 
16942 
16943 SWIGINTERN VALUE
16944 _wrap_GCycle_heightRearWheel_set(int argc, VALUE *argv, VALUE self) {
16945   gCycle *arg1 = (gCycle *) 0 ;
16946   REAL arg2 ;
16947   void *argp1 = 0 ;
16948   int res1 = 0 ;
16949   float val2 ;
16950   int ecode2 = 0 ;
16951   
16952   if ((argc < 1) || (argc > 1)) {
16953     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
16954   }
16955   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16956   if (!SWIG_IsOK(res1)) {
16957     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "heightRearWheel" "', argument " "1"" of type '" "gCycle *""'"); 
16958   }
16959   arg1 = reinterpret_cast< gCycle * >(argp1);
16960   ecode2 = SWIG_AsVal_float(argv[0], &val2);
16961   if (!SWIG_IsOK(ecode2)) {
16962     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "heightRearWheel" "', argument " "2"" of type '" "REAL""'");
16963   } 
16964   arg2 = static_cast< REAL >(val2);
16965   if (arg1) (arg1)->heightRearWheel = arg2;
16966   
16967   return Qnil;
16968 fail:
16969   return Qnil;
16970 }
16971 
16972 
16973 SWIGINTERN VALUE
16974 _wrap_GCycle_heightRearWheel_get(int argc, VALUE *argv, VALUE self) {
16975   gCycle *arg1 = (gCycle *) 0 ;
16976   REAL result;
16977   void *argp1 = 0 ;
16978   int res1 = 0 ;
16979   VALUE vresult = Qnil;
16980   
16981   if ((argc < 0) || (argc > 0)) {
16982     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
16983   }
16984   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
16985   if (!SWIG_IsOK(res1)) {
16986     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "heightRearWheel" "', argument " "1"" of type '" "gCycle *""'"); 
16987   }
16988   arg1 = reinterpret_cast< gCycle * >(argp1);
16989   result = (REAL) ((arg1)->heightRearWheel);
16990   vresult = SWIG_From_float(static_cast< float >(result));
16991   return vresult;
16992 fail:
16993   return Qnil;
16994 }
16995 
16996 
16997 SWIGINTERN VALUE
16998 _wrap_GCycle_memory_set(int argc, VALUE *argv, VALUE self) {
16999   gCycle *arg1 = (gCycle *) 0 ;
17000   gCycleMemory arg2 ;
17001   void *argp1 = 0 ;
17002   int res1 = 0 ;
17003   void *argp2 ;
17004   int res2 = 0 ;
17005   
17006   if ((argc < 1) || (argc > 1)) {
17007     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
17008   }
17009   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17010   if (!SWIG_IsOK(res1)) {
17011     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memory" "', argument " "1"" of type '" "gCycle *""'"); 
17012   }
17013   arg1 = reinterpret_cast< gCycle * >(argp1);
17014   {
17015     res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_gCycleMemory,  0 );
17016     if (!SWIG_IsOK(res2)) {
17017       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "memory" "', argument " "2"" of type '" "gCycleMemory""'"); 
17018     }  
17019     if (!argp2) {
17020       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "memory" "', argument " "2"" of type '" "gCycleMemory""'");
17021     } else {
17022       arg2 = *(reinterpret_cast< gCycleMemory * >(argp2));
17023     }
17024   }
17025   if (arg1) (arg1)->memory = arg2;
17026   
17027   return Qnil;
17028 fail:
17029   return Qnil;
17030 }
17031 
17032 
17033 SWIGINTERN VALUE
17034 _wrap_GCycle_memory_get(int argc, VALUE *argv, VALUE self) {
17035   gCycle *arg1 = (gCycle *) 0 ;
17036   gCycleMemory result;
17037   void *argp1 = 0 ;
17038   int res1 = 0 ;
17039   VALUE vresult = Qnil;
17040   
17041   if ((argc < 0) || (argc > 0)) {
17042     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
17043   }
17044   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17045   if (!SWIG_IsOK(res1)) {
17046     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memory" "', argument " "1"" of type '" "gCycle *""'"); 
17047   }
17048   arg1 = reinterpret_cast< gCycle * >(argp1);
17049   result =  ((arg1)->memory);
17050   vresult = SWIG_NewPointerObj((new gCycleMemory(static_cast< const gCycleMemory& >(result))), SWIGTYPE_p_gCycleMemory, SWIG_POINTER_OWN |  0 );
17051   return vresult;
17052 fail:
17053   return Qnil;
17054 }
17055 
17056 
17057 SWIGINTERN VALUE
17058 _wrap_GCycle_color__set(int argc, VALUE *argv, VALUE self) {
17059   gCycle *arg1 = (gCycle *) 0 ;
17060   gRealColor arg2 ;
17061   void *argp1 = 0 ;
17062   int res1 = 0 ;
17063   void *argp2 ;
17064   int res2 = 0 ;
17065   
17066   if ((argc < 1) || (argc > 1)) {
17067     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
17068   }
17069   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17070   if (!SWIG_IsOK(res1)) {
17071     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "color_" "', argument " "1"" of type '" "gCycle *""'"); 
17072   }
17073   arg1 = reinterpret_cast< gCycle * >(argp1);
17074   {
17075     res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_gRealColor,  0 );
17076     if (!SWIG_IsOK(res2)) {
17077       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "color_" "', argument " "2"" of type '" "gRealColor""'"); 
17078     }  
17079     if (!argp2) {
17080       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "color_" "', argument " "2"" of type '" "gRealColor""'");
17081     } else {
17082       arg2 = *(reinterpret_cast< gRealColor * >(argp2));
17083     }
17084   }
17085   if (arg1) (arg1)->color_ = arg2;
17086   
17087   return Qnil;
17088 fail:
17089   return Qnil;
17090 }
17091 
17092 
17093 SWIGINTERN VALUE
17094 _wrap_GCycle_color__get(int argc, VALUE *argv, VALUE self) {
17095   gCycle *arg1 = (gCycle *) 0 ;
17096   gRealColor result;
17097   void *argp1 = 0 ;
17098   int res1 = 0 ;
17099   VALUE vresult = Qnil;
17100   
17101   if ((argc < 0) || (argc > 0)) {
17102     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
17103   }
17104   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17105   if (!SWIG_IsOK(res1)) {
17106     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "color_" "', argument " "1"" of type '" "gCycle *""'"); 
17107   }
17108   arg1 = reinterpret_cast< gCycle * >(argp1);
17109   result =  ((arg1)->color_);
17110   vresult = SWIG_NewPointerObj((new gRealColor(static_cast< const gRealColor& >(result))), SWIGTYPE_p_gRealColor, SWIG_POINTER_OWN |  0 );
17111   return vresult;
17112 fail:
17113   return Qnil;
17114 }
17115 
17116 
17117 SWIGINTERN VALUE
17118 _wrap_GCycle_trailColor__set(int argc, VALUE *argv, VALUE self) {
17119   gCycle *arg1 = (gCycle *) 0 ;
17120   gRealColor arg2 ;
17121   void *argp1 = 0 ;
17122   int res1 = 0 ;
17123   void *argp2 ;
17124   int res2 = 0 ;
17125   
17126   if ((argc < 1) || (argc > 1)) {
17127     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
17128   }
17129   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17130   if (!SWIG_IsOK(res1)) {
17131     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trailColor_" "', argument " "1"" of type '" "gCycle *""'"); 
17132   }
17133   arg1 = reinterpret_cast< gCycle * >(argp1);
17134   {
17135     res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_gRealColor,  0 );
17136     if (!SWIG_IsOK(res2)) {
17137       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "trailColor_" "', argument " "2"" of type '" "gRealColor""'"); 
17138     }  
17139     if (!argp2) {
17140       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "trailColor_" "', argument " "2"" of type '" "gRealColor""'");
17141     } else {
17142       arg2 = *(reinterpret_cast< gRealColor * >(argp2));
17143     }
17144   }
17145   if (arg1) (arg1)->trailColor_ = arg2;
17146   
17147   return Qnil;
17148 fail:
17149   return Qnil;
17150 }
17151 
17152 
17153 SWIGINTERN VALUE
17154 _wrap_GCycle_trailColor__get(int argc, VALUE *argv, VALUE self) {
17155   gCycle *arg1 = (gCycle *) 0 ;
17156   gRealColor result;
17157   void *argp1 = 0 ;
17158   int res1 = 0 ;
17159   VALUE vresult = Qnil;
17160   
17161   if ((argc < 0) || (argc > 0)) {
17162     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
17163   }
17164   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17165   if (!SWIG_IsOK(res1)) {
17166     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "trailColor_" "', argument " "1"" of type '" "gCycle *""'"); 
17167   }
17168   arg1 = reinterpret_cast< gCycle * >(argp1);
17169   result =  ((arg1)->trailColor_);
17170   vresult = SWIG_NewPointerObj((new gRealColor(static_cast< const gRealColor& >(result))), SWIGTYPE_p_gRealColor, SWIG_POINTER_OWN |  0 );
17171   return vresult;
17172 fail:
17173   return Qnil;
17174 }
17175 
17176 
17177 SWIGINTERN VALUE
17178 _wrap_GCycle_correctPosSmooth_set(int argc, VALUE *argv, VALUE self) {
17179   gCycle *arg1 = (gCycle *) 0 ;
17180   eCoord arg2 ;
17181   void *argp1 = 0 ;
17182   int res1 = 0 ;
17183   void *argp2 ;
17184   int res2 = 0 ;
17185   
17186   if ((argc < 1) || (argc > 1)) {
17187     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
17188   }
17189   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17190   if (!SWIG_IsOK(res1)) {
17191     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "correctPosSmooth" "', argument " "1"" of type '" "gCycle *""'"); 
17192   }
17193   arg1 = reinterpret_cast< gCycle * >(argp1);
17194   {
17195     res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_eCoord,  0 );
17196     if (!SWIG_IsOK(res2)) {
17197       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "correctPosSmooth" "', argument " "2"" of type '" "eCoord""'"); 
17198     }  
17199     if (!argp2) {
17200       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "correctPosSmooth" "', argument " "2"" of type '" "eCoord""'");
17201     } else {
17202       arg2 = *(reinterpret_cast< eCoord * >(argp2));
17203     }
17204   }
17205   if (arg1) (arg1)->correctPosSmooth = arg2;
17206   
17207   return Qnil;
17208 fail:
17209   return Qnil;
17210 }
17211 
17212 
17213 SWIGINTERN VALUE
17214 _wrap_GCycle_correctPosSmooth_get(int argc, VALUE *argv, VALUE self) {
17215   gCycle *arg1 = (gCycle *) 0 ;
17216   eCoord result;
17217   void *argp1 = 0 ;
17218   int res1 = 0 ;
17219   VALUE vresult = Qnil;
17220   
17221   if ((argc < 0) || (argc > 0)) {
17222     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
17223   }
17224   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17225   if (!SWIG_IsOK(res1)) {
17226     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "correctPosSmooth" "', argument " "1"" of type '" "gCycle *""'"); 
17227   }
17228   arg1 = reinterpret_cast< gCycle * >(argp1);
17229   result =  ((arg1)->correctPosSmooth);
17230   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
17231   return vresult;
17232 fail:
17233   return Qnil;
17234 }
17235 
17236 
17237 SWIGINTERN VALUE
17238 _wrap_GCycle_predictPosition__set(int argc, VALUE *argv, VALUE self) {
17239   gCycle *arg1 = (gCycle *) 0 ;
17240   eCoord arg2 ;
17241   void *argp1 = 0 ;
17242   int res1 = 0 ;
17243   void *argp2 ;
17244   int res2 = 0 ;
17245   
17246   if ((argc < 1) || (argc > 1)) {
17247     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
17248   }
17249   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17250   if (!SWIG_IsOK(res1)) {
17251     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "predictPosition_" "', argument " "1"" of type '" "gCycle *""'"); 
17252   }
17253   arg1 = reinterpret_cast< gCycle * >(argp1);
17254   {
17255     res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_eCoord,  0 );
17256     if (!SWIG_IsOK(res2)) {
17257       SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "predictPosition_" "', argument " "2"" of type '" "eCoord""'"); 
17258     }  
17259     if (!argp2) {
17260       SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "predictPosition_" "', argument " "2"" of type '" "eCoord""'");
17261     } else {
17262       arg2 = *(reinterpret_cast< eCoord * >(argp2));
17263     }
17264   }
17265   if (arg1) (arg1)->predictPosition_ = arg2;
17266   
17267   return Qnil;
17268 fail:
17269   return Qnil;
17270 }
17271 
17272 
17273 SWIGINTERN VALUE
17274 _wrap_GCycle_predictPosition__get(int argc, VALUE *argv, VALUE self) {
17275   gCycle *arg1 = (gCycle *) 0 ;
17276   eCoord result;
17277   void *argp1 = 0 ;
17278   int res1 = 0 ;
17279   VALUE vresult = Qnil;
17280   
17281   if ((argc < 0) || (argc > 0)) {
17282     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
17283   }
17284   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17285   if (!SWIG_IsOK(res1)) {
17286     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "predictPosition_" "', argument " "1"" of type '" "gCycle *""'"); 
17287   }
17288   arg1 = reinterpret_cast< gCycle * >(argp1);
17289   result =  ((arg1)->predictPosition_);
17290   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
17291   return vresult;
17292 fail:
17293   return Qnil;
17294 }
17295 
17296 
17297 SWIGINTERN VALUE
17298 _wrap_GCycle_correctDistanceSmooth_set(int argc, VALUE *argv, VALUE self) {
17299   gCycle *arg1 = (gCycle *) 0 ;
17300   REAL arg2 ;
17301   void *argp1 = 0 ;
17302   int res1 = 0 ;
17303   float val2 ;
17304   int ecode2 = 0 ;
17305   
17306   if ((argc < 1) || (argc > 1)) {
17307     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
17308   }
17309   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17310   if (!SWIG_IsOK(res1)) {
17311     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "correctDistanceSmooth" "', argument " "1"" of type '" "gCycle *""'"); 
17312   }
17313   arg1 = reinterpret_cast< gCycle * >(argp1);
17314   ecode2 = SWIG_AsVal_float(argv[0], &val2);
17315   if (!SWIG_IsOK(ecode2)) {
17316     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "correctDistanceSmooth" "', argument " "2"" of type '" "REAL""'");
17317   } 
17318   arg2 = static_cast< REAL >(val2);
17319   if (arg1) (arg1)->correctDistanceSmooth = arg2;
17320   
17321   return Qnil;
17322 fail:
17323   return Qnil;
17324 }
17325 
17326 
17327 SWIGINTERN VALUE
17328 _wrap_GCycle_correctDistanceSmooth_get(int argc, VALUE *argv, VALUE self) {
17329   gCycle *arg1 = (gCycle *) 0 ;
17330   REAL result;
17331   void *argp1 = 0 ;
17332   int res1 = 0 ;
17333   VALUE vresult = Qnil;
17334   
17335   if ((argc < 0) || (argc > 0)) {
17336     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
17337   }
17338   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17339   if (!SWIG_IsOK(res1)) {
17340     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "correctDistanceSmooth" "', argument " "1"" of type '" "gCycle *""'"); 
17341   }
17342   arg1 = reinterpret_cast< gCycle * >(argp1);
17343   result = (REAL) ((arg1)->correctDistanceSmooth);
17344   vresult = SWIG_From_float(static_cast< float >(result));
17345   return vresult;
17346 fail:
17347   return Qnil;
17348 }
17349 
17350 
17351 SWIGINTERN VALUE
17352 _wrap_GCycle_die(int argc, VALUE *argv, VALUE self) {
17353   gCycle *arg1 = (gCycle *) 0 ;
17354   REAL arg2 ;
17355   void *argp1 = 0 ;
17356   int res1 = 0 ;
17357   float val2 ;
17358   int ecode2 = 0 ;
17359   
17360   if ((argc < 1) || (argc > 1)) {
17361     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
17362   }
17363   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17364   if (!SWIG_IsOK(res1)) {
17365     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Die" "', argument " "1"" of type '" "gCycle *""'"); 
17366   }
17367   arg1 = reinterpret_cast< gCycle * >(argp1);
17368   ecode2 = SWIG_AsVal_float(argv[0], &val2);
17369   if (!SWIG_IsOK(ecode2)) {
17370     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Die" "', argument " "2"" of type '" "REAL""'");
17371   } 
17372   arg2 = static_cast< REAL >(val2);
17373   (arg1)->Die(arg2);
17374   return Qnil;
17375 fail:
17376   return Qnil;
17377 }
17378 
17379 
17380 SWIGINTERN VALUE
17381 _wrap_GCycle_kill_at(int argc, VALUE *argv, VALUE self) {
17382   gCycle *arg1 = (gCycle *) 0 ;
17383   eCoord *arg2 = 0 ;
17384   void *argp1 = 0 ;
17385   int res1 = 0 ;
17386   void *argp2 ;
17387   int res2 = 0 ;
17388   
17389   if ((argc < 1) || (argc > 1)) {
17390     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
17391   }
17392   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17393   if (!SWIG_IsOK(res1)) {
17394     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KillAt" "', argument " "1"" of type '" "gCycle *""'"); 
17395   }
17396   arg1 = reinterpret_cast< gCycle * >(argp1);
17397   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_eCoord,  0 );
17398   if (!SWIG_IsOK(res2)) {
17399     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "KillAt" "', argument " "2"" of type '" "eCoord const &""'"); 
17400   }
17401   if (!argp2) {
17402     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "KillAt" "', argument " "2"" of type '" "eCoord const &""'"); 
17403   }
17404   arg2 = reinterpret_cast< eCoord * >(argp2);
17405   (arg1)->KillAt((eCoord const &)*arg2);
17406   return Qnil;
17407 fail:
17408   return Qnil;
17409 }
17410 
17411 
17412 SWIGINTERN VALUE
17413 _wrap_GCycle_winding_number(int argc, VALUE *argv, VALUE self) {
17414   gCycle *arg1 = (gCycle *) 0 ;
17415   int result;
17416   void *argp1 = 0 ;
17417   int res1 = 0 ;
17418   VALUE vresult = Qnil;
17419   
17420   if ((argc < 0) || (argc > 0)) {
17421     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
17422   }
17423   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17424   if (!SWIG_IsOK(res1)) {
17425     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindingNumber" "', argument " "1"" of type '" "gCycle const *""'"); 
17426   }
17427   arg1 = reinterpret_cast< gCycle * >(argp1);
17428   result = (int)((gCycle const *)arg1)->WindingNumber();
17429   vresult = SWIG_From_int(static_cast< int >(result));
17430   return vresult;
17431 fail:
17432   return Qnil;
17433 }
17434 
17435 
17436 SWIGINTERN VALUE
17437 _wrap_GCycle_vulnerable(int argc, VALUE *argv, VALUE self) {
17438   gCycle *arg1 = (gCycle *) 0 ;
17439   bool result;
17440   void *argp1 = 0 ;
17441   int res1 = 0 ;
17442   VALUE vresult = Qnil;
17443   
17444   if ((argc < 0) || (argc > 0)) {
17445     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
17446   }
17447   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17448   if (!SWIG_IsOK(res1)) {
17449     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vulnerable" "', argument " "1"" of type '" "gCycle const *""'"); 
17450   }
17451   arg1 = reinterpret_cast< gCycle * >(argp1);
17452   result = (bool)((gCycle const *)arg1)->Vulnerable();
17453   vresult = SWIG_From_bool(static_cast< bool >(result));
17454   return vresult;
17455 fail:
17456   return Qnil;
17457 }
17458 
17459 
17460 SWIGINTERN VALUE
17461 _wrap_GCycle_init_after_creation(int argc, VALUE *argv, VALUE self) {
17462   gCycle *arg1 = (gCycle *) 0 ;
17463   void *argp1 = 0 ;
17464   int res1 = 0 ;
17465   
17466   if ((argc < 0) || (argc > 0)) {
17467     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
17468   }
17469   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17470   if (!SWIG_IsOK(res1)) {
17471     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InitAfterCreation" "', argument " "1"" of type '" "gCycle *""'"); 
17472   }
17473   arg1 = reinterpret_cast< gCycle * >(argp1);
17474   (arg1)->InitAfterCreation();
17475   return Qnil;
17476 fail:
17477   return Qnil;
17478 }
17479 
17480 
17481 SWIGINTERN VALUE
17482 _wrap_new_GCycle__SWIG_0(int argc, VALUE *argv, VALUE self) {
17483   eGrid *arg1 = (eGrid *) 0 ;
17484   eCoord *arg2 = 0 ;
17485   eCoord *arg3 = 0 ;
17486   ePlayerNetID *arg4 = (ePlayerNetID *) 0 ;
17487   bool arg5 ;
17488   gCycle *result = 0 ;
17489   void *argp1 = 0 ;
17490   int res1 = 0 ;
17491   void *argp2 ;
17492   int res2 = 0 ;
17493   void *argp3 ;
17494   int res3 = 0 ;
17495   void *argp4 = 0 ;
17496   int res4 = 0 ;
17497   bool val5 ;
17498   int ecode5 = 0 ;
17499   const char *classname SWIGUNUSED = "Armagetronad::GCycle";
17500   
17501   if ((argc < 5) || (argc > 5)) {
17502     rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
17503   }
17504   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_eGrid, 0 |  0 );
17505   if (!SWIG_IsOK(res1)) {
17506     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gCycle" "', argument " "1"" of type '" "eGrid *""'"); 
17507   }
17508   arg1 = reinterpret_cast< eGrid * >(argp1);
17509   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_eCoord,  0 );
17510   if (!SWIG_IsOK(res2)) {
17511     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gCycle" "', argument " "2"" of type '" "eCoord const &""'"); 
17512   }
17513   if (!argp2) {
17514     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gCycle" "', argument " "2"" of type '" "eCoord const &""'"); 
17515   }
17516   arg2 = reinterpret_cast< eCoord * >(argp2);
17517   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_eCoord,  0 );
17518   if (!SWIG_IsOK(res3)) {
17519     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gCycle" "', argument " "3"" of type '" "eCoord const &""'"); 
17520   }
17521   if (!argp3) {
17522     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gCycle" "', argument " "3"" of type '" "eCoord const &""'"); 
17523   }
17524   arg3 = reinterpret_cast< eCoord * >(argp3);
17525   res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_ePlayerNetID, 0 |  0 );
17526   if (!SWIG_IsOK(res4)) {
17527     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gCycle" "', argument " "4"" of type '" "ePlayerNetID *""'"); 
17528   }
17529   arg4 = reinterpret_cast< ePlayerNetID * >(argp4);
17530   ecode5 = SWIG_AsVal_bool(argv[4], &val5);
17531   if (!SWIG_IsOK(ecode5)) {
17532     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gCycle" "', argument " "5"" of type '" "bool""'");
17533   } 
17534   arg5 = static_cast< bool >(val5);
17535   result = (gCycle *)new gCycle(arg1,(eCoord const &)*arg2,(eCoord const &)*arg3,arg4,arg5);DATA_PTR(self) = result;
17536   
17537   return self;
17538 fail:
17539   return Qnil;
17540 }
17541 
17542 
17543 SWIGINTERN VALUE
17544 _wrap_new_GCycle__SWIG_1(int argc, VALUE *argv, VALUE self) {
17545   eGrid *arg1 = (eGrid *) 0 ;
17546   eCoord *arg2 = 0 ;
17547   eCoord *arg3 = 0 ;
17548   ePlayerNetID *arg4 = (ePlayerNetID *) 0 ;
17549   gCycle *result = 0 ;
17550   void *argp1 = 0 ;
17551   int res1 = 0 ;
17552   void *argp2 ;
17553   int res2 = 0 ;
17554   void *argp3 ;
17555   int res3 = 0 ;
17556   void *argp4 = 0 ;
17557   int res4 = 0 ;
17558   const char *classname SWIGUNUSED = "Armagetronad::GCycle";
17559   
17560   if ((argc < 4) || (argc > 4)) {
17561     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
17562   }
17563   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_eGrid, 0 |  0 );
17564   if (!SWIG_IsOK(res1)) {
17565     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gCycle" "', argument " "1"" of type '" "eGrid *""'"); 
17566   }
17567   arg1 = reinterpret_cast< eGrid * >(argp1);
17568   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_eCoord,  0 );
17569   if (!SWIG_IsOK(res2)) {
17570     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gCycle" "', argument " "2"" of type '" "eCoord const &""'"); 
17571   }
17572   if (!argp2) {
17573     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gCycle" "', argument " "2"" of type '" "eCoord const &""'"); 
17574   }
17575   arg2 = reinterpret_cast< eCoord * >(argp2);
17576   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_eCoord,  0 );
17577   if (!SWIG_IsOK(res3)) {
17578     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gCycle" "', argument " "3"" of type '" "eCoord const &""'"); 
17579   }
17580   if (!argp3) {
17581     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gCycle" "', argument " "3"" of type '" "eCoord const &""'"); 
17582   }
17583   arg3 = reinterpret_cast< eCoord * >(argp3);
17584   res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_ePlayerNetID, 0 |  0 );
17585   if (!SWIG_IsOK(res4)) {
17586     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gCycle" "', argument " "4"" of type '" "ePlayerNetID *""'"); 
17587   }
17588   arg4 = reinterpret_cast< ePlayerNetID * >(argp4);
17589   result = (gCycle *)new gCycle(arg1,(eCoord const &)*arg2,(eCoord const &)*arg3,arg4);DATA_PTR(self) = result;
17590   
17591   return self;
17592 fail:
17593   return Qnil;
17594 }
17595 
17596 
17597 SWIGINTERN VALUE
17598 _wrap_new_GCycle__SWIG_2(int argc, VALUE *argv, VALUE self) {
17599   eGrid *arg1 = (eGrid *) 0 ;
17600   eCoord *arg2 = 0 ;
17601   eCoord *arg3 = 0 ;
17602   gCycle *result = 0 ;
17603   void *argp1 = 0 ;
17604   int res1 = 0 ;
17605   void *argp2 ;
17606   int res2 = 0 ;
17607   void *argp3 ;
17608   int res3 = 0 ;
17609   const char *classname SWIGUNUSED = "Armagetronad::GCycle";
17610   
17611   if ((argc < 3) || (argc > 3)) {
17612     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
17613   }
17614   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_eGrid, 0 |  0 );
17615   if (!SWIG_IsOK(res1)) {
17616     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gCycle" "', argument " "1"" of type '" "eGrid *""'"); 
17617   }
17618   arg1 = reinterpret_cast< eGrid * >(argp1);
17619   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_eCoord,  0 );
17620   if (!SWIG_IsOK(res2)) {
17621     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gCycle" "', argument " "2"" of type '" "eCoord const &""'"); 
17622   }
17623   if (!argp2) {
17624     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gCycle" "', argument " "2"" of type '" "eCoord const &""'"); 
17625   }
17626   arg2 = reinterpret_cast< eCoord * >(argp2);
17627   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_eCoord,  0 );
17628   if (!SWIG_IsOK(res3)) {
17629     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gCycle" "', argument " "3"" of type '" "eCoord const &""'"); 
17630   }
17631   if (!argp3) {
17632     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gCycle" "', argument " "3"" of type '" "eCoord const &""'"); 
17633   }
17634   arg3 = reinterpret_cast< eCoord * >(argp3);
17635   result = (gCycle *)new gCycle(arg1,(eCoord const &)*arg2,(eCoord const &)*arg3);DATA_PTR(self) = result;
17636   
17637   return self;
17638 fail:
17639   return Qnil;
17640 }
17641 
17642 
17643 SWIGINTERN VALUE
17644 _wrap_GCycle_set_walls_stay_up_delay(int argc, VALUE *argv, VALUE self) {
17645   REAL arg1 ;
17646   float val1 ;
17647   int ecode1 = 0 ;
17648   
17649   if ((argc < 1) || (argc > 1)) {
17650     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
17651   }
17652   ecode1 = SWIG_AsVal_float(argv[0], &val1);
17653   if (!SWIG_IsOK(ecode1)) {
17654     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gCycle::SetWallsStayUpDelay" "', argument " "1"" of type '" "REAL""'");
17655   } 
17656   arg1 = static_cast< REAL >(val1);
17657   gCycle::SetWallsStayUpDelay(arg1);
17658   return Qnil;
17659 fail:
17660   return Qnil;
17661 }
17662 
17663 
17664 SWIGINTERN VALUE
17665 _wrap_GCycle_set_walls_length(int argc, VALUE *argv, VALUE self) {
17666   REAL arg1 ;
17667   float val1 ;
17668   int ecode1 = 0 ;
17669   
17670   if ((argc < 1) || (argc > 1)) {
17671     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
17672   }
17673   ecode1 = SWIG_AsVal_float(argv[0], &val1);
17674   if (!SWIG_IsOK(ecode1)) {
17675     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gCycle::SetWallsLength" "', argument " "1"" of type '" "REAL""'");
17676   } 
17677   arg1 = static_cast< REAL >(val1);
17678   gCycle::SetWallsLength(arg1);
17679   return Qnil;
17680 fail:
17681   return Qnil;
17682 }
17683 
17684 
17685 SWIGINTERN VALUE
17686 _wrap_GCycle_set_explosion_radius(int argc, VALUE *argv, VALUE self) {
17687   REAL arg1 ;
17688   float val1 ;
17689   int ecode1 = 0 ;
17690   
17691   if ((argc < 1) || (argc > 1)) {
17692     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
17693   }
17694   ecode1 = SWIG_AsVal_float(argv[0], &val1);
17695   if (!SWIG_IsOK(ecode1)) {
17696     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gCycle::SetExplosionRadius" "', argument " "1"" of type '" "REAL""'");
17697   } 
17698   arg1 = static_cast< REAL >(val1);
17699   gCycle::SetExplosionRadius(arg1);
17700   return Qnil;
17701 fail:
17702   return Qnil;
17703 }
17704 
17705 
17706 SWIGINTERN VALUE
17707 _wrap_GCycle_walls_stay_up_delay(int argc, VALUE *argv, VALUE self) {
17708   REAL result;
17709   VALUE vresult = Qnil;
17710   
17711   if ((argc < 0) || (argc > 0)) {
17712     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
17713   }
17714   result = (REAL)gCycle::WallsStayUpDelay();
17715   vresult = SWIG_From_float(static_cast< float >(result));
17716   return vresult;
17717 fail:
17718   return Qnil;
17719 }
17720 
17721 
17722 SWIGINTERN VALUE
17723 _wrap_GCycle_walls_length(int argc, VALUE *argv, VALUE self) {
17724   REAL result;
17725   VALUE vresult = Qnil;
17726   
17727   if ((argc < 0) || (argc > 0)) {
17728     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
17729   }
17730   result = (REAL)gCycle::WallsLength();
17731   vresult = SWIG_From_float(static_cast< float >(result));
17732   return vresult;
17733 fail:
17734   return Qnil;
17735 }
17736 
17737 
17738 SWIGINTERN VALUE
17739 _wrap_GCycle_max_walls_length(int argc, VALUE *argv, VALUE self) {
17740   gCycle *arg1 = (gCycle *) 0 ;
17741   REAL result;
17742   void *argp1 = 0 ;
17743   int res1 = 0 ;
17744   VALUE vresult = Qnil;
17745   
17746   if ((argc < 0) || (argc > 0)) {
17747     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
17748   }
17749   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17750   if (!SWIG_IsOK(res1)) {
17751     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MaxWallsLength" "', argument " "1"" of type '" "gCycle const *""'"); 
17752   }
17753   arg1 = reinterpret_cast< gCycle * >(argp1);
17754   result = (REAL)((gCycle const *)arg1)->MaxWallsLength();
17755   vresult = SWIG_From_float(static_cast< float >(result));
17756   return vresult;
17757 fail:
17758   return Qnil;
17759 }
17760 
17761 
17762 SWIGINTERN VALUE
17763 _wrap_GCycle_this_walls_length(int argc, VALUE *argv, VALUE self) {
17764   gCycle *arg1 = (gCycle *) 0 ;
17765   REAL result;
17766   void *argp1 = 0 ;
17767   int res1 = 0 ;
17768   VALUE vresult = Qnil;
17769   
17770   if ((argc < 0) || (argc > 0)) {
17771     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
17772   }
17773   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17774   if (!SWIG_IsOK(res1)) {
17775     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThisWallsLength" "', argument " "1"" of type '" "gCycle const *""'"); 
17776   }
17777   arg1 = reinterpret_cast< gCycle * >(argp1);
17778   result = (REAL)((gCycle const *)arg1)->ThisWallsLength();
17779   vresult = SWIG_From_float(static_cast< float >(result));
17780   return vresult;
17781 fail:
17782   return Qnil;
17783 }
17784 
17785 
17786 SWIGINTERN VALUE
17787 _wrap_GCycle_wall_end_speed(int argc, VALUE *argv, VALUE self) {
17788   gCycle *arg1 = (gCycle *) 0 ;
17789   REAL result;
17790   void *argp1 = 0 ;
17791   int res1 = 0 ;
17792   VALUE vresult = Qnil;
17793   
17794   if ((argc < 0) || (argc > 0)) {
17795     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
17796   }
17797   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17798   if (!SWIG_IsOK(res1)) {
17799     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WallEndSpeed" "', argument " "1"" of type '" "gCycle const *""'"); 
17800   }
17801   arg1 = reinterpret_cast< gCycle * >(argp1);
17802   result = (REAL)((gCycle const *)arg1)->WallEndSpeed();
17803   vresult = SWIG_From_float(static_cast< float >(result));
17804   return vresult;
17805 fail:
17806   return Qnil;
17807 }
17808 
17809 
17810 SWIGINTERN VALUE
17811 _wrap_GCycle_explosion_radius(int argc, VALUE *argv, VALUE self) {
17812   REAL result;
17813   VALUE vresult = Qnil;
17814   
17815   if ((argc < 0) || (argc > 0)) {
17816     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
17817   }
17818   result = (REAL)gCycle::ExplosionRadius();
17819   vresult = SWIG_From_float(static_cast< float >(result));
17820   return vresult;
17821 fail:
17822   return Qnil;
17823 }
17824 
17825 
17826 SWIGINTERN VALUE
17827 _wrap_GCycle_is_me(int argc, VALUE *argv, VALUE self) {
17828   gCycle *arg1 = (gCycle *) 0 ;
17829   eGameObject *arg2 = (eGameObject *) 0 ;
17830   bool result;
17831   void *argp1 = 0 ;
17832   int res1 = 0 ;
17833   void *argp2 = 0 ;
17834   int res2 = 0 ;
17835   VALUE vresult = Qnil;
17836   
17837   if ((argc < 1) || (argc > 1)) {
17838     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
17839   }
17840   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
17841   if (!SWIG_IsOK(res1)) {
17842     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsMe" "', argument " "1"" of type '" "gCycle const *""'"); 
17843   }
17844   arg1 = reinterpret_cast< gCycle * >(argp1);
17845   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eGameObject, 0 |  0 );
17846   if (!SWIG_IsOK(res2)) {
17847     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IsMe" "', argument " "2"" of type '" "eGameObject const *""'"); 
17848   }
17849   arg2 = reinterpret_cast< eGameObject * >(argp2);
17850   result = (bool)((gCycle const *)arg1)->IsMe((eGameObject const *)arg2);
17851   vresult = SWIG_From_bool(static_cast< bool >(result));
17852   return vresult;
17853 fail:
17854   return Qnil;
17855 }
17856 
17857 
17858 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
17859 SWIGINTERN VALUE
17860 _wrap_GCycle_allocate(VALUE self) {
17861 #else
17862   SWIGINTERN VALUE
17863   _wrap_GCycle_allocate(int argc, VALUE *argv, VALUE self) {
17864 #endif
17865     
17866     
17867     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_gCycle);
17868 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
17869     rb_obj_call_init(vresult, argc, argv);
17870 #endif
17871     return vresult;
17872   }
17873   
17874 
17875 SWIGINTERN VALUE
17876 _wrap_new_GCycle__SWIG_3(int argc, VALUE *argv, VALUE self) {
17877   nMessage *arg1 = 0 ;
17878   gCycle *result = 0 ;
17879   void *argp1 = 0 ;
17880   int res1 = 0 ;
17881   const char *classname SWIGUNUSED = "Armagetronad::GCycle";
17882   
17883   if ((argc < 1) || (argc > 1)) {
17884     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
17885   }
17886   res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_nMessage,  0 );
17887   if (!SWIG_IsOK(res1)) {
17888     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gCycle" "', argument " "1"" of type '" "nMessage &""'"); 
17889   }
17890   if (!argp1) {
17891     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gCycle" "', argument " "1"" of type '" "nMessage &""'"); 
17892   }
17893   arg1 = reinterpret_cast< nMessage * >(argp1);
17894   result = (gCycle *)new gCycle(*arg1);DATA_PTR(self) = result;
17895   
17896   return self;
17897 fail:
17898   return Qnil;
17899 }
17900 
17901 
17902 SWIGINTERN VALUE _wrap_new_GCycle(int nargs, VALUE *args, VALUE self) {
17903   int argc;
17904   VALUE argv[5];
17905   int ii;
17906   
17907   argc = nargs;
17908   if (argc > 5) SWIG_fail;
17909   for (ii = 0; (ii < argc); ii++) {
17910     argv[ii] = args[ii];
17911   }
17912   if (argc == 1) {
17913     int _v;
17914     void *vptr = 0;
17915     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_nMessage, 0);
17916     _v = SWIG_CheckState(res);
17917     if (_v) {
17918       return _wrap_new_GCycle__SWIG_3(nargs, args, self);
17919     }
17920   }
17921   if (argc == 3) {
17922     int _v;
17923     void *vptr = 0;
17924     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGrid, 0);
17925     _v = SWIG_CheckState(res);
17926     if (_v) {
17927       void *vptr = 0;
17928       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eCoord, 0);
17929       _v = SWIG_CheckState(res);
17930       if (_v) {
17931         void *vptr = 0;
17932         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_eCoord, 0);
17933         _v = SWIG_CheckState(res);
17934         if (_v) {
17935           return _wrap_new_GCycle__SWIG_2(nargs, args, self);
17936         }
17937       }
17938     }
17939   }
17940   if (argc == 4) {
17941     int _v;
17942     void *vptr = 0;
17943     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGrid, 0);
17944     _v = SWIG_CheckState(res);
17945     if (_v) {
17946       void *vptr = 0;
17947       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eCoord, 0);
17948       _v = SWIG_CheckState(res);
17949       if (_v) {
17950         void *vptr = 0;
17951         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_eCoord, 0);
17952         _v = SWIG_CheckState(res);
17953         if (_v) {
17954           void *vptr = 0;
17955           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_ePlayerNetID, 0);
17956           _v = SWIG_CheckState(res);
17957           if (_v) {
17958             return _wrap_new_GCycle__SWIG_1(nargs, args, self);
17959           }
17960         }
17961       }
17962     }
17963   }
17964   if (argc == 5) {
17965     int _v;
17966     void *vptr = 0;
17967     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_eGrid, 0);
17968     _v = SWIG_CheckState(res);
17969     if (_v) {
17970       void *vptr = 0;
17971       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eCoord, 0);
17972       _v = SWIG_CheckState(res);
17973       if (_v) {
17974         void *vptr = 0;
17975         int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_eCoord, 0);
17976         _v = SWIG_CheckState(res);
17977         if (_v) {
17978           void *vptr = 0;
17979           int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_ePlayerNetID, 0);
17980           _v = SWIG_CheckState(res);
17981           if (_v) {
17982             {
17983               int res = SWIG_AsVal_bool(argv[4], NULL);
17984               _v = SWIG_CheckState(res);
17985             }
17986             if (_v) {
17987               return _wrap_new_GCycle__SWIG_0(nargs, args, self);
17988             }
17989           }
17990         }
17991       }
17992     }
17993   }
17994   
17995 fail:
17996   rb_raise(rb_eArgError, "No matching function for overloaded 'new_GCycle'");
17997   return Qnil;
17998 }
17999 
18000 
18001 SWIGINTERN VALUE
18002 _wrap_GCycle_write_create(int argc, VALUE *argv, VALUE self) {
18003   gCycle *arg1 = (gCycle *) 0 ;
18004   nMessage *arg2 = 0 ;
18005   void *argp1 = 0 ;
18006   int res1 = 0 ;
18007   void *argp2 = 0 ;
18008   int res2 = 0 ;
18009   
18010   if ((argc < 1) || (argc > 1)) {
18011     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
18012   }
18013   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18014   if (!SWIG_IsOK(res1)) {
18015     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WriteCreate" "', argument " "1"" of type '" "gCycle *""'"); 
18016   }
18017   arg1 = reinterpret_cast< gCycle * >(argp1);
18018   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_nMessage,  0 );
18019   if (!SWIG_IsOK(res2)) {
18020     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WriteCreate" "', argument " "2"" of type '" "nMessage &""'"); 
18021   }
18022   if (!argp2) {
18023     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WriteCreate" "', argument " "2"" of type '" "nMessage &""'"); 
18024   }
18025   arg2 = reinterpret_cast< nMessage * >(argp2);
18026   (arg1)->WriteCreate(*arg2);
18027   return Qnil;
18028 fail:
18029   return Qnil;
18030 }
18031 
18032 
18033 SWIGINTERN VALUE
18034 _wrap_GCycle_write_sync(int argc, VALUE *argv, VALUE self) {
18035   gCycle *arg1 = (gCycle *) 0 ;
18036   nMessage *arg2 = 0 ;
18037   void *argp1 = 0 ;
18038   int res1 = 0 ;
18039   void *argp2 = 0 ;
18040   int res2 = 0 ;
18041   
18042   if ((argc < 1) || (argc > 1)) {
18043     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
18044   }
18045   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18046   if (!SWIG_IsOK(res1)) {
18047     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WriteSync" "', argument " "1"" of type '" "gCycle *""'"); 
18048   }
18049   arg1 = reinterpret_cast< gCycle * >(argp1);
18050   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_nMessage,  0 );
18051   if (!SWIG_IsOK(res2)) {
18052     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WriteSync" "', argument " "2"" of type '" "nMessage &""'"); 
18053   }
18054   if (!argp2) {
18055     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WriteSync" "', argument " "2"" of type '" "nMessage &""'"); 
18056   }
18057   arg2 = reinterpret_cast< nMessage * >(argp2);
18058   (arg1)->WriteSync(*arg2);
18059   return Qnil;
18060 fail:
18061   return Qnil;
18062 }
18063 
18064 
18065 SWIGINTERN VALUE
18066 _wrap_GCycle_read_sync(int argc, VALUE *argv, VALUE self) {
18067   gCycle *arg1 = (gCycle *) 0 ;
18068   nMessage *arg2 = 0 ;
18069   void *argp1 = 0 ;
18070   int res1 = 0 ;
18071   void *argp2 = 0 ;
18072   int res2 = 0 ;
18073   
18074   if ((argc < 1) || (argc > 1)) {
18075     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
18076   }
18077   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18078   if (!SWIG_IsOK(res1)) {
18079     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReadSync" "', argument " "1"" of type '" "gCycle *""'"); 
18080   }
18081   arg1 = reinterpret_cast< gCycle * >(argp1);
18082   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_nMessage,  0 );
18083   if (!SWIG_IsOK(res2)) {
18084     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ReadSync" "', argument " "2"" of type '" "nMessage &""'"); 
18085   }
18086   if (!argp2) {
18087     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ReadSync" "', argument " "2"" of type '" "nMessage &""'"); 
18088   }
18089   arg2 = reinterpret_cast< nMessage * >(argp2);
18090   (arg1)->ReadSync(*arg2);
18091   return Qnil;
18092 fail:
18093   return Qnil;
18094 }
18095 
18096 
18097 SWIGINTERN VALUE
18098 _wrap_GCycle_request_sync_owner(int argc, VALUE *argv, VALUE self) {
18099   gCycle *arg1 = (gCycle *) 0 ;
18100   void *argp1 = 0 ;
18101   int res1 = 0 ;
18102   
18103   if ((argc < 0) || (argc > 0)) {
18104     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
18105   }
18106   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18107   if (!SWIG_IsOK(res1)) {
18108     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestSyncOwner" "', argument " "1"" of type '" "gCycle *""'"); 
18109   }
18110   arg1 = reinterpret_cast< gCycle * >(argp1);
18111   (arg1)->RequestSyncOwner();
18112   return Qnil;
18113 fail:
18114   return Qnil;
18115 }
18116 
18117 
18118 SWIGINTERN VALUE
18119 _wrap_GCycle_request_sync_all(int argc, VALUE *argv, VALUE self) {
18120   gCycle *arg1 = (gCycle *) 0 ;
18121   void *argp1 = 0 ;
18122   int res1 = 0 ;
18123   
18124   if ((argc < 0) || (argc > 0)) {
18125     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
18126   }
18127   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18128   if (!SWIG_IsOK(res1)) {
18129     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RequestSyncAll" "', argument " "1"" of type '" "gCycle *""'"); 
18130   }
18131   arg1 = reinterpret_cast< gCycle * >(argp1);
18132   (arg1)->RequestSyncAll();
18133   return Qnil;
18134 fail:
18135   return Qnil;
18136 }
18137 
18138 
18139 SWIGINTERN VALUE
18140 _wrap_GCycle_sync_enemy(int argc, VALUE *argv, VALUE self) {
18141   gCycle *arg1 = (gCycle *) 0 ;
18142   eCoord *arg2 = 0 ;
18143   void *argp1 = 0 ;
18144   int res1 = 0 ;
18145   void *argp2 ;
18146   int res2 = 0 ;
18147   
18148   if ((argc < 1) || (argc > 1)) {
18149     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
18150   }
18151   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18152   if (!SWIG_IsOK(res1)) {
18153     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SyncEnemy" "', argument " "1"" of type '" "gCycle *""'"); 
18154   }
18155   arg1 = reinterpret_cast< gCycle * >(argp1);
18156   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_eCoord,  0 );
18157   if (!SWIG_IsOK(res2)) {
18158     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SyncEnemy" "', argument " "2"" of type '" "eCoord const &""'"); 
18159   }
18160   if (!argp2) {
18161     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SyncEnemy" "', argument " "2"" of type '" "eCoord const &""'"); 
18162   }
18163   arg2 = reinterpret_cast< eCoord * >(argp2);
18164   (arg1)->SyncEnemy((eCoord const &)*arg2);
18165   return Qnil;
18166 fail:
18167   return Qnil;
18168 }
18169 
18170 
18171 SWIGINTERN VALUE
18172 _wrap_GCycle_receive_control(int argc, VALUE *argv, VALUE self) {
18173   gCycle *arg1 = (gCycle *) 0 ;
18174   REAL arg2 ;
18175   uActionPlayer *arg3 = (uActionPlayer *) 0 ;
18176   REAL arg4 ;
18177   void *argp1 = 0 ;
18178   int res1 = 0 ;
18179   float val2 ;
18180   int ecode2 = 0 ;
18181   void *argp3 = 0 ;
18182   int res3 = 0 ;
18183   float val4 ;
18184   int ecode4 = 0 ;
18185   
18186   if ((argc < 3) || (argc > 3)) {
18187     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
18188   }
18189   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18190   if (!SWIG_IsOK(res1)) {
18191     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ReceiveControl" "', argument " "1"" of type '" "gCycle *""'"); 
18192   }
18193   arg1 = reinterpret_cast< gCycle * >(argp1);
18194   ecode2 = SWIG_AsVal_float(argv[0], &val2);
18195   if (!SWIG_IsOK(ecode2)) {
18196     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ReceiveControl" "', argument " "2"" of type '" "REAL""'");
18197   } 
18198   arg2 = static_cast< REAL >(val2);
18199   res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_uActionPlayer, 0 |  0 );
18200   if (!SWIG_IsOK(res3)) {
18201     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ReceiveControl" "', argument " "3"" of type '" "uActionPlayer *""'"); 
18202   }
18203   arg3 = reinterpret_cast< uActionPlayer * >(argp3);
18204   ecode4 = SWIG_AsVal_float(argv[2], &val4);
18205   if (!SWIG_IsOK(ecode4)) {
18206     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ReceiveControl" "', argument " "4"" of type '" "REAL""'");
18207   } 
18208   arg4 = static_cast< REAL >(val4);
18209   (arg1)->ReceiveControl(arg2,arg3,arg4);
18210   return Qnil;
18211 fail:
18212   return Qnil;
18213 }
18214 
18215 
18216 SWIGINTERN VALUE
18217 _wrap_GCycle_print_name(int argc, VALUE *argv, VALUE self) {
18218   gCycle *arg1 = (gCycle *) 0 ;
18219   tString *arg2 = 0 ;
18220   void *argp1 = 0 ;
18221   int res1 = 0 ;
18222   void *argp2 = 0 ;
18223   int res2 = 0 ;
18224   
18225   if ((argc < 1) || (argc > 1)) {
18226     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
18227   }
18228   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18229   if (!SWIG_IsOK(res1)) {
18230     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PrintName" "', argument " "1"" of type '" "gCycle const *""'"); 
18231   }
18232   arg1 = reinterpret_cast< gCycle * >(argp1);
18233   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_tString,  0 );
18234   if (!SWIG_IsOK(res2)) {
18235     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PrintName" "', argument " "2"" of type '" "tString &""'"); 
18236   }
18237   if (!argp2) {
18238     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PrintName" "', argument " "2"" of type '" "tString &""'"); 
18239   }
18240   arg2 = reinterpret_cast< tString * >(argp2);
18241   ((gCycle const *)arg1)->PrintName(*arg2);
18242   return Qnil;
18243 fail:
18244   return Qnil;
18245 }
18246 
18247 
18248 SWIGINTERN VALUE
18249 _wrap_GCycle_action_on_quit(int argc, VALUE *argv, VALUE self) {
18250   gCycle *arg1 = (gCycle *) 0 ;
18251   bool result;
18252   void *argp1 = 0 ;
18253   int res1 = 0 ;
18254   VALUE vresult = Qnil;
18255   
18256   if ((argc < 0) || (argc > 0)) {
18257     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
18258   }
18259   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18260   if (!SWIG_IsOK(res1)) {
18261     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActionOnQuit" "', argument " "1"" of type '" "gCycle *""'"); 
18262   }
18263   arg1 = reinterpret_cast< gCycle * >(argp1);
18264   result = (bool)(arg1)->ActionOnQuit();
18265   vresult = SWIG_From_bool(static_cast< bool >(result));
18266   return vresult;
18267 fail:
18268   return Qnil;
18269 }
18270 
18271 
18272 SWIGINTERN VALUE
18273 _wrap_GCycle_creator_descriptor(int argc, VALUE *argv, VALUE self) {
18274   gCycle *arg1 = (gCycle *) 0 ;
18275   nDescriptor *result = 0 ;
18276   void *argp1 = 0 ;
18277   int res1 = 0 ;
18278   VALUE vresult = Qnil;
18279   
18280   if ((argc < 0) || (argc > 0)) {
18281     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
18282   }
18283   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18284   if (!SWIG_IsOK(res1)) {
18285     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreatorDescriptor" "', argument " "1"" of type '" "gCycle const *""'"); 
18286   }
18287   arg1 = reinterpret_cast< gCycle * >(argp1);
18288   {
18289     nDescriptor &_result_ref = ((gCycle const *)arg1)->CreatorDescriptor();
18290     result = (nDescriptor *) &_result_ref;
18291   }
18292   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_nDescriptor, 0 |  0 );
18293   return vresult;
18294 fail:
18295   return Qnil;
18296 }
18297 
18298 
18299 SWIGINTERN VALUE
18300 _wrap_GCycle_sync_is_new(int argc, VALUE *argv, VALUE self) {
18301   gCycle *arg1 = (gCycle *) 0 ;
18302   nMessage *arg2 = 0 ;
18303   bool result;
18304   void *argp1 = 0 ;
18305   int res1 = 0 ;
18306   void *argp2 = 0 ;
18307   int res2 = 0 ;
18308   VALUE vresult = Qnil;
18309   
18310   if ((argc < 1) || (argc > 1)) {
18311     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
18312   }
18313   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18314   if (!SWIG_IsOK(res1)) {
18315     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SyncIsNew" "', argument " "1"" of type '" "gCycle *""'"); 
18316   }
18317   arg1 = reinterpret_cast< gCycle * >(argp1);
18318   res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_nMessage,  0 );
18319   if (!SWIG_IsOK(res2)) {
18320     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SyncIsNew" "', argument " "2"" of type '" "nMessage &""'"); 
18321   }
18322   if (!argp2) {
18323     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SyncIsNew" "', argument " "2"" of type '" "nMessage &""'"); 
18324   }
18325   arg2 = reinterpret_cast< nMessage * >(argp2);
18326   result = (bool)(arg1)->SyncIsNew(*arg2);
18327   vresult = SWIG_From_bool(static_cast< bool >(result));
18328   return vresult;
18329 fail:
18330   return Qnil;
18331 }
18332 
18333 
18334 SWIGINTERN VALUE
18335 _wrap_GCycle_timestep(int argc, VALUE *argv, VALUE self) {
18336   gCycle *arg1 = (gCycle *) 0 ;
18337   REAL arg2 ;
18338   bool result;
18339   void *argp1 = 0 ;
18340   int res1 = 0 ;
18341   float val2 ;
18342   int ecode2 = 0 ;
18343   VALUE vresult = Qnil;
18344   
18345   if ((argc < 1) || (argc > 1)) {
18346     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
18347   }
18348   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18349   if (!SWIG_IsOK(res1)) {
18350     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Timestep" "', argument " "1"" of type '" "gCycle *""'"); 
18351   }
18352   arg1 = reinterpret_cast< gCycle * >(argp1);
18353   ecode2 = SWIG_AsVal_float(argv[0], &val2);
18354   if (!SWIG_IsOK(ecode2)) {
18355     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Timestep" "', argument " "2"" of type '" "REAL""'");
18356   } 
18357   arg2 = static_cast< REAL >(val2);
18358   result = (bool)(arg1)->Timestep(arg2);
18359   vresult = SWIG_From_bool(static_cast< bool >(result));
18360   return vresult;
18361 fail:
18362   return Qnil;
18363 }
18364 
18365 
18366 SWIGINTERN VALUE
18367 _wrap_GCycle_timestep_core__SWIG_0(int argc, VALUE *argv, VALUE self) {
18368   gCycle *arg1 = (gCycle *) 0 ;
18369   REAL arg2 ;
18370   bool arg3 ;
18371   bool result;
18372   void *argp1 = 0 ;
18373   int res1 = 0 ;
18374   float val2 ;
18375   int ecode2 = 0 ;
18376   bool val3 ;
18377   int ecode3 = 0 ;
18378   VALUE vresult = Qnil;
18379   
18380   if ((argc < 2) || (argc > 2)) {
18381     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
18382   }
18383   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18384   if (!SWIG_IsOK(res1)) {
18385     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimestepCore" "', argument " "1"" of type '" "gCycle *""'"); 
18386   }
18387   arg1 = reinterpret_cast< gCycle * >(argp1);
18388   ecode2 = SWIG_AsVal_float(argv[0], &val2);
18389   if (!SWIG_IsOK(ecode2)) {
18390     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimestepCore" "', argument " "2"" of type '" "REAL""'");
18391   } 
18392   arg2 = static_cast< REAL >(val2);
18393   ecode3 = SWIG_AsVal_bool(argv[1], &val3);
18394   if (!SWIG_IsOK(ecode3)) {
18395     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "TimestepCore" "', argument " "3"" of type '" "bool""'");
18396   } 
18397   arg3 = static_cast< bool >(val3);
18398   result = (bool)(arg1)->TimestepCore(arg2,arg3);
18399   vresult = SWIG_From_bool(static_cast< bool >(result));
18400   return vresult;
18401 fail:
18402   return Qnil;
18403 }
18404 
18405 
18406 SWIGINTERN VALUE
18407 _wrap_GCycle_timestep_core__SWIG_1(int argc, VALUE *argv, VALUE self) {
18408   gCycle *arg1 = (gCycle *) 0 ;
18409   REAL arg2 ;
18410   bool result;
18411   void *argp1 = 0 ;
18412   int res1 = 0 ;
18413   float val2 ;
18414   int ecode2 = 0 ;
18415   VALUE vresult = Qnil;
18416   
18417   if ((argc < 1) || (argc > 1)) {
18418     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
18419   }
18420   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18421   if (!SWIG_IsOK(res1)) {
18422     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimestepCore" "', argument " "1"" of type '" "gCycle *""'"); 
18423   }
18424   arg1 = reinterpret_cast< gCycle * >(argp1);
18425   ecode2 = SWIG_AsVal_float(argv[0], &val2);
18426   if (!SWIG_IsOK(ecode2)) {
18427     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimestepCore" "', argument " "2"" of type '" "REAL""'");
18428   } 
18429   arg2 = static_cast< REAL >(val2);
18430   result = (bool)(arg1)->TimestepCore(arg2);
18431   vresult = SWIG_From_bool(static_cast< bool >(result));
18432   return vresult;
18433 fail:
18434   return Qnil;
18435 }
18436 
18437 
18438 SWIGINTERN VALUE _wrap_GCycle_timestep_core(int nargs, VALUE *args, VALUE self) {
18439   int argc;
18440   VALUE argv[4];
18441   int ii;
18442   
18443   argc = nargs + 1;
18444   argv[0] = self;
18445   if (argc > 4) SWIG_fail;
18446   for (ii = 1; (ii < argc); ii++) {
18447     argv[ii] = args[ii-1];
18448   }
18449   if (argc == 2) {
18450     int _v;
18451     void *vptr = 0;
18452     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycle, 0);
18453     _v = SWIG_CheckState(res);
18454     if (_v) {
18455       {
18456         int res = SWIG_AsVal_float(argv[1], NULL);
18457         _v = SWIG_CheckState(res);
18458       }
18459       if (_v) {
18460         return _wrap_GCycle_timestep_core__SWIG_1(nargs, args, self);
18461       }
18462     }
18463   }
18464   if (argc == 3) {
18465     int _v;
18466     void *vptr = 0;
18467     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycle, 0);
18468     _v = SWIG_CheckState(res);
18469     if (_v) {
18470       {
18471         int res = SWIG_AsVal_float(argv[1], NULL);
18472         _v = SWIG_CheckState(res);
18473       }
18474       if (_v) {
18475         {
18476           int res = SWIG_AsVal_bool(argv[2], NULL);
18477           _v = SWIG_CheckState(res);
18478         }
18479         if (_v) {
18480           return _wrap_GCycle_timestep_core__SWIG_0(nargs, args, self);
18481         }
18482       }
18483     }
18484   }
18485   
18486 fail:
18487   rb_raise(rb_eArgError, "No matching function for overloaded 'GCycle_timestep_core'");
18488   return Qnil;
18489 }
18490 
18491 
18492 SWIGINTERN VALUE
18493 _wrap_GCycle_interact_with__SWIG_0(int argc, VALUE *argv, VALUE self) {
18494   gCycle *arg1 = (gCycle *) 0 ;
18495   eGameObject *arg2 = (eGameObject *) 0 ;
18496   REAL arg3 ;
18497   int arg4 ;
18498   void *argp1 = 0 ;
18499   int res1 = 0 ;
18500   void *argp2 = 0 ;
18501   int res2 = 0 ;
18502   float val3 ;
18503   int ecode3 = 0 ;
18504   int val4 ;
18505   int ecode4 = 0 ;
18506   
18507   if ((argc < 3) || (argc > 3)) {
18508     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
18509   }
18510   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18511   if (!SWIG_IsOK(res1)) {
18512     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InteractWith" "', argument " "1"" of type '" "gCycle *""'"); 
18513   }
18514   arg1 = reinterpret_cast< gCycle * >(argp1);
18515   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eGameObject, 0 |  0 );
18516   if (!SWIG_IsOK(res2)) {
18517     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InteractWith" "', argument " "2"" of type '" "eGameObject *""'"); 
18518   }
18519   arg2 = reinterpret_cast< eGameObject * >(argp2);
18520   ecode3 = SWIG_AsVal_float(argv[1], &val3);
18521   if (!SWIG_IsOK(ecode3)) {
18522     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InteractWith" "', argument " "3"" of type '" "REAL""'");
18523   } 
18524   arg3 = static_cast< REAL >(val3);
18525   ecode4 = SWIG_AsVal_int(argv[2], &val4);
18526   if (!SWIG_IsOK(ecode4)) {
18527     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InteractWith" "', argument " "4"" of type '" "int""'");
18528   } 
18529   arg4 = static_cast< int >(val4);
18530   (arg1)->InteractWith(arg2,arg3,arg4);
18531   return Qnil;
18532 fail:
18533   return Qnil;
18534 }
18535 
18536 
18537 SWIGINTERN VALUE
18538 _wrap_GCycle_interact_with__SWIG_1(int argc, VALUE *argv, VALUE self) {
18539   gCycle *arg1 = (gCycle *) 0 ;
18540   eGameObject *arg2 = (eGameObject *) 0 ;
18541   REAL arg3 ;
18542   void *argp1 = 0 ;
18543   int res1 = 0 ;
18544   void *argp2 = 0 ;
18545   int res2 = 0 ;
18546   float val3 ;
18547   int ecode3 = 0 ;
18548   
18549   if ((argc < 2) || (argc > 2)) {
18550     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
18551   }
18552   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18553   if (!SWIG_IsOK(res1)) {
18554     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InteractWith" "', argument " "1"" of type '" "gCycle *""'"); 
18555   }
18556   arg1 = reinterpret_cast< gCycle * >(argp1);
18557   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eGameObject, 0 |  0 );
18558   if (!SWIG_IsOK(res2)) {
18559     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InteractWith" "', argument " "2"" of type '" "eGameObject *""'"); 
18560   }
18561   arg2 = reinterpret_cast< eGameObject * >(argp2);
18562   ecode3 = SWIG_AsVal_float(argv[1], &val3);
18563   if (!SWIG_IsOK(ecode3)) {
18564     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InteractWith" "', argument " "3"" of type '" "REAL""'");
18565   } 
18566   arg3 = static_cast< REAL >(val3);
18567   (arg1)->InteractWith(arg2,arg3);
18568   return Qnil;
18569 fail:
18570   return Qnil;
18571 }
18572 
18573 
18574 SWIGINTERN VALUE _wrap_GCycle_interact_with(int nargs, VALUE *args, VALUE self) {
18575   int argc;
18576   VALUE argv[5];
18577   int ii;
18578   
18579   argc = nargs + 1;
18580   argv[0] = self;
18581   if (argc > 5) SWIG_fail;
18582   for (ii = 1; (ii < argc); ii++) {
18583     argv[ii] = args[ii-1];
18584   }
18585   if (argc == 3) {
18586     int _v;
18587     void *vptr = 0;
18588     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycle, 0);
18589     _v = SWIG_CheckState(res);
18590     if (_v) {
18591       void *vptr = 0;
18592       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eGameObject, 0);
18593       _v = SWIG_CheckState(res);
18594       if (_v) {
18595         {
18596           int res = SWIG_AsVal_float(argv[2], NULL);
18597           _v = SWIG_CheckState(res);
18598         }
18599         if (_v) {
18600           return _wrap_GCycle_interact_with__SWIG_1(nargs, args, self);
18601         }
18602       }
18603     }
18604   }
18605   if (argc == 4) {
18606     int _v;
18607     void *vptr = 0;
18608     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycle, 0);
18609     _v = SWIG_CheckState(res);
18610     if (_v) {
18611       void *vptr = 0;
18612       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eGameObject, 0);
18613       _v = SWIG_CheckState(res);
18614       if (_v) {
18615         {
18616           int res = SWIG_AsVal_float(argv[2], NULL);
18617           _v = SWIG_CheckState(res);
18618         }
18619         if (_v) {
18620           {
18621             int res = SWIG_AsVal_int(argv[3], NULL);
18622             _v = SWIG_CheckState(res);
18623           }
18624           if (_v) {
18625             return _wrap_GCycle_interact_with__SWIG_0(nargs, args, self);
18626           }
18627         }
18628       }
18629     }
18630   }
18631   
18632 fail:
18633   rb_raise(rb_eArgError, "No matching function for overloaded 'GCycle_interact_with'");
18634   return Qnil;
18635 }
18636 
18637 
18638 SWIGINTERN VALUE
18639 _wrap_GCycle_edge_is_dangerous(int argc, VALUE *argv, VALUE self) {
18640   gCycle *arg1 = (gCycle *) 0 ;
18641   eWall *arg2 = (eWall *) 0 ;
18642   REAL arg3 ;
18643   REAL arg4 ;
18644   bool result;
18645   void *argp1 = 0 ;
18646   int res1 = 0 ;
18647   void *argp2 = 0 ;
18648   int res2 = 0 ;
18649   float val3 ;
18650   int ecode3 = 0 ;
18651   float val4 ;
18652   int ecode4 = 0 ;
18653   VALUE vresult = Qnil;
18654   
18655   if ((argc < 3) || (argc > 3)) {
18656     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
18657   }
18658   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18659   if (!SWIG_IsOK(res1)) {
18660     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EdgeIsDangerous" "', argument " "1"" of type '" "gCycle const *""'"); 
18661   }
18662   arg1 = reinterpret_cast< gCycle * >(argp1);
18663   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eWall, 0 |  0 );
18664   if (!SWIG_IsOK(res2)) {
18665     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EdgeIsDangerous" "', argument " "2"" of type '" "eWall const *""'"); 
18666   }
18667   arg2 = reinterpret_cast< eWall * >(argp2);
18668   ecode3 = SWIG_AsVal_float(argv[1], &val3);
18669   if (!SWIG_IsOK(ecode3)) {
18670     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EdgeIsDangerous" "', argument " "3"" of type '" "REAL""'");
18671   } 
18672   arg3 = static_cast< REAL >(val3);
18673   ecode4 = SWIG_AsVal_float(argv[2], &val4);
18674   if (!SWIG_IsOK(ecode4)) {
18675     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EdgeIsDangerous" "', argument " "4"" of type '" "REAL""'");
18676   } 
18677   arg4 = static_cast< REAL >(val4);
18678   result = (bool)((gCycle const *)arg1)->EdgeIsDangerous((eWall const *)arg2,arg3,arg4);
18679   vresult = SWIG_From_bool(static_cast< bool >(result));
18680   return vresult;
18681 fail:
18682   return Qnil;
18683 }
18684 
18685 
18686 SWIGINTERN VALUE
18687 _wrap_GCycle_pass_edge__SWIG_0(int argc, VALUE *argv, VALUE self) {
18688   gCycle *arg1 = (gCycle *) 0 ;
18689   eWall *arg2 = (eWall *) 0 ;
18690   REAL arg3 ;
18691   REAL arg4 ;
18692   int arg5 ;
18693   void *argp1 = 0 ;
18694   int res1 = 0 ;
18695   void *argp2 = 0 ;
18696   int res2 = 0 ;
18697   float val3 ;
18698   int ecode3 = 0 ;
18699   float val4 ;
18700   int ecode4 = 0 ;
18701   int val5 ;
18702   int ecode5 = 0 ;
18703   
18704   if ((argc < 4) || (argc > 4)) {
18705     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
18706   }
18707   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18708   if (!SWIG_IsOK(res1)) {
18709     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PassEdge" "', argument " "1"" of type '" "gCycle *""'"); 
18710   }
18711   arg1 = reinterpret_cast< gCycle * >(argp1);
18712   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eWall, 0 |  0 );
18713   if (!SWIG_IsOK(res2)) {
18714     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PassEdge" "', argument " "2"" of type '" "eWall const *""'"); 
18715   }
18716   arg2 = reinterpret_cast< eWall * >(argp2);
18717   ecode3 = SWIG_AsVal_float(argv[1], &val3);
18718   if (!SWIG_IsOK(ecode3)) {
18719     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PassEdge" "', argument " "3"" of type '" "REAL""'");
18720   } 
18721   arg3 = static_cast< REAL >(val3);
18722   ecode4 = SWIG_AsVal_float(argv[2], &val4);
18723   if (!SWIG_IsOK(ecode4)) {
18724     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PassEdge" "', argument " "4"" of type '" "REAL""'");
18725   } 
18726   arg4 = static_cast< REAL >(val4);
18727   ecode5 = SWIG_AsVal_int(argv[3], &val5);
18728   if (!SWIG_IsOK(ecode5)) {
18729     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PassEdge" "', argument " "5"" of type '" "int""'");
18730   } 
18731   arg5 = static_cast< int >(val5);
18732   (arg1)->PassEdge((eWall const *)arg2,arg3,arg4,arg5);
18733   return Qnil;
18734 fail:
18735   return Qnil;
18736 }
18737 
18738 
18739 SWIGINTERN VALUE
18740 _wrap_GCycle_pass_edge__SWIG_1(int argc, VALUE *argv, VALUE self) {
18741   gCycle *arg1 = (gCycle *) 0 ;
18742   eWall *arg2 = (eWall *) 0 ;
18743   REAL arg3 ;
18744   REAL arg4 ;
18745   void *argp1 = 0 ;
18746   int res1 = 0 ;
18747   void *argp2 = 0 ;
18748   int res2 = 0 ;
18749   float val3 ;
18750   int ecode3 = 0 ;
18751   float val4 ;
18752   int ecode4 = 0 ;
18753   
18754   if ((argc < 3) || (argc > 3)) {
18755     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
18756   }
18757   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18758   if (!SWIG_IsOK(res1)) {
18759     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PassEdge" "', argument " "1"" of type '" "gCycle *""'"); 
18760   }
18761   arg1 = reinterpret_cast< gCycle * >(argp1);
18762   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eWall, 0 |  0 );
18763   if (!SWIG_IsOK(res2)) {
18764     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PassEdge" "', argument " "2"" of type '" "eWall const *""'"); 
18765   }
18766   arg2 = reinterpret_cast< eWall * >(argp2);
18767   ecode3 = SWIG_AsVal_float(argv[1], &val3);
18768   if (!SWIG_IsOK(ecode3)) {
18769     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PassEdge" "', argument " "3"" of type '" "REAL""'");
18770   } 
18771   arg3 = static_cast< REAL >(val3);
18772   ecode4 = SWIG_AsVal_float(argv[2], &val4);
18773   if (!SWIG_IsOK(ecode4)) {
18774     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PassEdge" "', argument " "4"" of type '" "REAL""'");
18775   } 
18776   arg4 = static_cast< REAL >(val4);
18777   (arg1)->PassEdge((eWall const *)arg2,arg3,arg4);
18778   return Qnil;
18779 fail:
18780   return Qnil;
18781 }
18782 
18783 
18784 SWIGINTERN VALUE _wrap_GCycle_pass_edge(int nargs, VALUE *args, VALUE self) {
18785   int argc;
18786   VALUE argv[6];
18787   int ii;
18788   
18789   argc = nargs + 1;
18790   argv[0] = self;
18791   if (argc > 6) SWIG_fail;
18792   for (ii = 1; (ii < argc); ii++) {
18793     argv[ii] = args[ii-1];
18794   }
18795   if (argc == 4) {
18796     int _v;
18797     void *vptr = 0;
18798     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycle, 0);
18799     _v = SWIG_CheckState(res);
18800     if (_v) {
18801       void *vptr = 0;
18802       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eWall, 0);
18803       _v = SWIG_CheckState(res);
18804       if (_v) {
18805         {
18806           int res = SWIG_AsVal_float(argv[2], NULL);
18807           _v = SWIG_CheckState(res);
18808         }
18809         if (_v) {
18810           {
18811             int res = SWIG_AsVal_float(argv[3], NULL);
18812             _v = SWIG_CheckState(res);
18813           }
18814           if (_v) {
18815             return _wrap_GCycle_pass_edge__SWIG_1(nargs, args, self);
18816           }
18817         }
18818       }
18819     }
18820   }
18821   if (argc == 5) {
18822     int _v;
18823     void *vptr = 0;
18824     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycle, 0);
18825     _v = SWIG_CheckState(res);
18826     if (_v) {
18827       void *vptr = 0;
18828       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eWall, 0);
18829       _v = SWIG_CheckState(res);
18830       if (_v) {
18831         {
18832           int res = SWIG_AsVal_float(argv[2], NULL);
18833           _v = SWIG_CheckState(res);
18834         }
18835         if (_v) {
18836           {
18837             int res = SWIG_AsVal_float(argv[3], NULL);
18838             _v = SWIG_CheckState(res);
18839           }
18840           if (_v) {
18841             {
18842               int res = SWIG_AsVal_int(argv[4], NULL);
18843               _v = SWIG_CheckState(res);
18844             }
18845             if (_v) {
18846               return _wrap_GCycle_pass_edge__SWIG_0(nargs, args, self);
18847             }
18848           }
18849         }
18850       }
18851     }
18852   }
18853   
18854 fail:
18855   rb_raise(rb_eArgError, "No matching function for overloaded 'GCycle_pass_edge'");
18856   return Qnil;
18857 }
18858 
18859 
18860 SWIGINTERN VALUE
18861 _wrap_GCycle_pathfinding_modifier(int argc, VALUE *argv, VALUE self) {
18862   gCycle *arg1 = (gCycle *) 0 ;
18863   eWall *arg2 = (eWall *) 0 ;
18864   REAL result;
18865   void *argp1 = 0 ;
18866   int res1 = 0 ;
18867   void *argp2 = 0 ;
18868   int res2 = 0 ;
18869   VALUE vresult = Qnil;
18870   
18871   if ((argc < 1) || (argc > 1)) {
18872     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
18873   }
18874   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18875   if (!SWIG_IsOK(res1)) {
18876     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathfindingModifier" "', argument " "1"" of type '" "gCycle const *""'"); 
18877   }
18878   arg1 = reinterpret_cast< gCycle * >(argp1);
18879   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eWall, 0 |  0 );
18880   if (!SWIG_IsOK(res2)) {
18881     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PathfindingModifier" "', argument " "2"" of type '" "eWall const *""'"); 
18882   }
18883   arg2 = reinterpret_cast< eWall * >(argp2);
18884   result = (REAL)((gCycle const *)arg1)->PathfindingModifier((eWall const *)arg2);
18885   vresult = SWIG_From_float(static_cast< float >(result));
18886   return vresult;
18887 fail:
18888   return Qnil;
18889 }
18890 
18891 
18892 SWIGINTERN VALUE
18893 _wrap_GCycle_act(int argc, VALUE *argv, VALUE self) {
18894   gCycle *arg1 = (gCycle *) 0 ;
18895   uActionPlayer *arg2 = (uActionPlayer *) 0 ;
18896   REAL arg3 ;
18897   bool result;
18898   void *argp1 = 0 ;
18899   int res1 = 0 ;
18900   void *argp2 = 0 ;
18901   int res2 = 0 ;
18902   float val3 ;
18903   int ecode3 = 0 ;
18904   VALUE vresult = Qnil;
18905   
18906   if ((argc < 2) || (argc > 2)) {
18907     rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
18908   }
18909   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18910   if (!SWIG_IsOK(res1)) {
18911     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Act" "', argument " "1"" of type '" "gCycle *""'"); 
18912   }
18913   arg1 = reinterpret_cast< gCycle * >(argp1);
18914   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_uActionPlayer, 0 |  0 );
18915   if (!SWIG_IsOK(res2)) {
18916     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Act" "', argument " "2"" of type '" "uActionPlayer *""'"); 
18917   }
18918   arg2 = reinterpret_cast< uActionPlayer * >(argp2);
18919   ecode3 = SWIG_AsVal_float(argv[1], &val3);
18920   if (!SWIG_IsOK(ecode3)) {
18921     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Act" "', argument " "3"" of type '" "REAL""'");
18922   } 
18923   arg3 = static_cast< REAL >(val3);
18924   result = (bool)(arg1)->Act(arg2,arg3);
18925   vresult = SWIG_From_bool(static_cast< bool >(result));
18926   return vresult;
18927 fail:
18928   return Qnil;
18929 }
18930 
18931 
18932 SWIGINTERN VALUE
18933 _wrap_GCycle_do_turn(int argc, VALUE *argv, VALUE self) {
18934   gCycle *arg1 = (gCycle *) 0 ;
18935   int arg2 ;
18936   bool result;
18937   void *argp1 = 0 ;
18938   int res1 = 0 ;
18939   int val2 ;
18940   int ecode2 = 0 ;
18941   VALUE vresult = Qnil;
18942   
18943   if ((argc < 1) || (argc > 1)) {
18944     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
18945   }
18946   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18947   if (!SWIG_IsOK(res1)) {
18948     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoTurn" "', argument " "1"" of type '" "gCycle *""'"); 
18949   }
18950   arg1 = reinterpret_cast< gCycle * >(argp1);
18951   ecode2 = SWIG_AsVal_int(argv[0], &val2);
18952   if (!SWIG_IsOK(ecode2)) {
18953     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoTurn" "', argument " "2"" of type '" "int""'");
18954   } 
18955   arg2 = static_cast< int >(val2);
18956   result = (bool)(arg1)->DoTurn(arg2);
18957   vresult = SWIG_From_bool(static_cast< bool >(result));
18958   return vresult;
18959 fail:
18960   return Qnil;
18961 }
18962 
18963 
18964 SWIGINTERN VALUE
18965 _wrap_GCycle_drop_wall__SWIG_0(int argc, VALUE *argv, VALUE self) {
18966   gCycle *arg1 = (gCycle *) 0 ;
18967   bool arg2 ;
18968   void *argp1 = 0 ;
18969   int res1 = 0 ;
18970   bool val2 ;
18971   int ecode2 = 0 ;
18972   
18973   if ((argc < 1) || (argc > 1)) {
18974     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
18975   }
18976   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
18977   if (!SWIG_IsOK(res1)) {
18978     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropWall" "', argument " "1"" of type '" "gCycle *""'"); 
18979   }
18980   arg1 = reinterpret_cast< gCycle * >(argp1);
18981   ecode2 = SWIG_AsVal_bool(argv[0], &val2);
18982   if (!SWIG_IsOK(ecode2)) {
18983     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DropWall" "', argument " "2"" of type '" "bool""'");
18984   } 
18985   arg2 = static_cast< bool >(val2);
18986   (arg1)->DropWall(arg2);
18987   return Qnil;
18988 fail:
18989   return Qnil;
18990 }
18991 
18992 
18993 SWIGINTERN VALUE
18994 _wrap_GCycle_drop_wall__SWIG_1(int argc, VALUE *argv, VALUE self) {
18995   gCycle *arg1 = (gCycle *) 0 ;
18996   void *argp1 = 0 ;
18997   int res1 = 0 ;
18998   
18999   if ((argc < 0) || (argc > 0)) {
19000     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
19001   }
19002   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
19003   if (!SWIG_IsOK(res1)) {
19004     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropWall" "', argument " "1"" of type '" "gCycle *""'"); 
19005   }
19006   arg1 = reinterpret_cast< gCycle * >(argp1);
19007   (arg1)->DropWall();
19008   return Qnil;
19009 fail:
19010   return Qnil;
19011 }
19012 
19013 
19014 SWIGINTERN VALUE _wrap_GCycle_drop_wall(int nargs, VALUE *args, VALUE self) {
19015   int argc;
19016   VALUE argv[3];
19017   int ii;
19018   
19019   argc = nargs + 1;
19020   argv[0] = self;
19021   if (argc > 3) SWIG_fail;
19022   for (ii = 1; (ii < argc); ii++) {
19023     argv[ii] = args[ii-1];
19024   }
19025   if (argc == 1) {
19026     int _v;
19027     void *vptr = 0;
19028     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycle, 0);
19029     _v = SWIG_CheckState(res);
19030     if (_v) {
19031       return _wrap_GCycle_drop_wall__SWIG_1(nargs, args, self);
19032     }
19033   }
19034   if (argc == 2) {
19035     int _v;
19036     void *vptr = 0;
19037     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gCycle, 0);
19038     _v = SWIG_CheckState(res);
19039     if (_v) {
19040       {
19041         int res = SWIG_AsVal_bool(argv[1], NULL);
19042         _v = SWIG_CheckState(res);
19043       }
19044       if (_v) {
19045         return _wrap_GCycle_drop_wall__SWIG_0(nargs, args, self);
19046       }
19047     }
19048   }
19049   
19050 fail:
19051   rb_raise(rb_eArgError, "No matching function for overloaded 'GCycle_drop_wall'");
19052   return Qnil;
19053 }
19054 
19055 
19056 SWIGINTERN VALUE
19057 _wrap_GCycle_kill(int argc, VALUE *argv, VALUE self) {
19058   gCycle *arg1 = (gCycle *) 0 ;
19059   void *argp1 = 0 ;
19060   int res1 = 0 ;
19061   
19062   if ((argc < 0) || (argc > 0)) {
19063     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
19064   }
19065   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
19066   if (!SWIG_IsOK(res1)) {
19067     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Kill" "', argument " "1"" of type '" "gCycle *""'"); 
19068   }
19069   arg1 = reinterpret_cast< gCycle * >(argp1);
19070   (arg1)->Kill();
19071   return Qnil;
19072 fail:
19073   return Qnil;
19074 }
19075 
19076 
19077 SWIGINTERN VALUE
19078 _wrap_GCycle_edge(int argc, VALUE *argv, VALUE self) {
19079   gCycle *arg1 = (gCycle *) 0 ;
19080   eTempEdge *result = 0 ;
19081   void *argp1 = 0 ;
19082   int res1 = 0 ;
19083   VALUE vresult = Qnil;
19084   
19085   if ((argc < 0) || (argc > 0)) {
19086     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
19087   }
19088   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
19089   if (!SWIG_IsOK(res1)) {
19090     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Edge" "', argument " "1"" of type '" "gCycle *""'"); 
19091   }
19092   arg1 = reinterpret_cast< gCycle * >(argp1);
19093   result = (eTempEdge *)(arg1)->Edge();
19094   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_eTempEdge, 0 |  0 );
19095   return vresult;
19096 fail:
19097   return Qnil;
19098 }
19099 
19100 
19101 SWIGINTERN VALUE
19102 _wrap_GCycle_current_wall(int argc, VALUE *argv, VALUE self) {
19103   gCycle *arg1 = (gCycle *) 0 ;
19104   gPlayerWall *result = 0 ;
19105   void *argp1 = 0 ;
19106   int res1 = 0 ;
19107   VALUE vresult = Qnil;
19108   
19109   if ((argc < 0) || (argc > 0)) {
19110     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
19111   }
19112   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
19113   if (!SWIG_IsOK(res1)) {
19114     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurrentWall" "', argument " "1"" of type '" "gCycle *""'"); 
19115   }
19116   arg1 = reinterpret_cast< gCycle * >(argp1);
19117   result = (gPlayerWall *)(arg1)->CurrentWall();
19118   vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gPlayerWall, 0 |  0 );
19119   return vresult;
19120 fail:
19121   return Qnil;
19122 }
19123 
19124 
19125 SWIGINTERN VALUE
19126 _wrap_GCycle_cam_pos(int argc, VALUE *argv, VALUE self) {
19127   gCycle *arg1 = (gCycle *) 0 ;
19128   eCoord result;
19129   void *argp1 = 0 ;
19130   int res1 = 0 ;
19131   VALUE vresult = Qnil;
19132   
19133   if ((argc < 0) || (argc > 0)) {
19134     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
19135   }
19136   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
19137   if (!SWIG_IsOK(res1)) {
19138     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CamPos" "', argument " "1"" of type '" "gCycle const *""'"); 
19139   }
19140   arg1 = reinterpret_cast< gCycle * >(argp1);
19141   result = ((gCycle const *)arg1)->CamPos();
19142   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
19143   return vresult;
19144 fail:
19145   return Qnil;
19146 }
19147 
19148 
19149 SWIGINTERN VALUE
19150 _wrap_GCycle_predict_position(int argc, VALUE *argv, VALUE self) {
19151   gCycle *arg1 = (gCycle *) 0 ;
19152   eCoord result;
19153   void *argp1 = 0 ;
19154   int res1 = 0 ;
19155   VALUE vresult = Qnil;
19156   
19157   if ((argc < 0) || (argc > 0)) {
19158     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
19159   }
19160   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
19161   if (!SWIG_IsOK(res1)) {
19162     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PredictPosition" "', argument " "1"" of type '" "gCycle const *""'"); 
19163   }
19164   arg1 = reinterpret_cast< gCycle * >(argp1);
19165   result = ((gCycle const *)arg1)->PredictPosition();
19166   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
19167   return vresult;
19168 fail:
19169   return Qnil;
19170 }
19171 
19172 
19173 SWIGINTERN VALUE
19174 _wrap_GCycle_cam_top(int argc, VALUE *argv, VALUE self) {
19175   gCycle *arg1 = (gCycle *) 0 ;
19176   eCoord result;
19177   void *argp1 = 0 ;
19178   int res1 = 0 ;
19179   VALUE vresult = Qnil;
19180   
19181   if ((argc < 0) || (argc > 0)) {
19182     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
19183   }
19184   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
19185   if (!SWIG_IsOK(res1)) {
19186     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CamTop" "', argument " "1"" of type '" "gCycle const *""'"); 
19187   }
19188   arg1 = reinterpret_cast< gCycle * >(argp1);
19189   result = ((gCycle const *)arg1)->CamTop();
19190   vresult = SWIG_NewPointerObj((new eCoord(static_cast< const eCoord& >(result))), SWIGTYPE_p_eCoord, SWIG_POINTER_OWN |  0 );
19191   return vresult;
19192 fail:
19193   return Qnil;
19194 }
19195 
19196 
19197 SWIGINTERN VALUE
19198 _wrap_GCycle_right_before_death(int argc, VALUE *argv, VALUE self) {
19199   gCycle *arg1 = (gCycle *) 0 ;
19200   int arg2 ;
19201   void *argp1 = 0 ;
19202   int res1 = 0 ;
19203   int val2 ;
19204   int ecode2 = 0 ;
19205   
19206   if ((argc < 1) || (argc > 1)) {
19207     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
19208   }
19209   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gCycle, 0 |  0 );
19210   if (!SWIG_IsOK(res1)) {
19211     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RightBeforeDeath" "', argument " "1"" of type '" "gCycle *""'"); 
19212   }
19213   arg1 = reinterpret_cast< gCycle * >(argp1);
19214   ecode2 = SWIG_AsVal_int(argv[0], &val2);
19215   if (!SWIG_IsOK(ecode2)) {
19216     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RightBeforeDeath" "', argument " "2"" of type '" "int""'");
19217   } 
19218   arg2 = static_cast< int >(val2);
19219   (arg1)->RightBeforeDeath(arg2);
19220   return Qnil;
19221 fail:
19222   return Qnil;
19223 }
19224 
19225 
19226 SWIGINTERN VALUE
19227 _wrap_GCycle_private_settings(int argc, VALUE *argv, VALUE self) {
19228   if ((argc < 0) || (argc > 0)) {
19229     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
19230   }
19231   gCycle::PrivateSettings();
19232   return Qnil;
19233 fail:
19234   return Qnil;
19235 }
19236 
19237 
19238 swig_class cGSensor;
19239 
19240 SWIGINTERN VALUE
19241 _wrap_GSensor_type_set(int argc, VALUE *argv, VALUE self) {
19242   gSensor *arg1 = (gSensor *) 0 ;
19243   gSensorWallType arg2 ;
19244   void *argp1 = 0 ;
19245   int res1 = 0 ;
19246   int val2 ;
19247   int ecode2 = 0 ;
19248   
19249   if ((argc < 1) || (argc > 1)) {
19250     rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
19251   }
19252   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gSensor, 0 |  0 );
19253   if (!SWIG_IsOK(res1)) {
19254     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "type" "', argument " "1"" of type '" "gSensor *""'"); 
19255   }
19256   arg1 = reinterpret_cast< gSensor * >(argp1);
19257   ecode2 = SWIG_AsVal_int(argv[0], &val2);
19258   if (!SWIG_IsOK(ecode2)) {
19259     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "type" "', argument " "2"" of type '" "gSensorWallType""'");
19260   } 
19261   arg2 = static_cast< gSensorWallType >(val2);
19262   if (arg1) (arg1)->type = arg2;
19263   
19264   return Qnil;
19265 fail:
19266   return Qnil;
19267 }
19268 
19269 
19270 SWIGINTERN VALUE
19271 _wrap_GSensor_type_get(int argc, VALUE *argv, VALUE self) {
19272   gSensor *arg1 = (gSensor *) 0 ;
19273   gSensorWallType result;
19274   void *argp1 = 0 ;
19275   int res1 = 0 ;
19276   VALUE vresult = Qnil;
19277   
19278   if ((argc < 0) || (argc > 0)) {
19279     rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
19280   }
19281   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gSensor, 0 |  0 );
19282   if (!SWIG_IsOK(res1)) {
19283     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "type" "', argument " "1"" of type '" "gSensor *""'"); 
19284   }
19285   arg1 = reinterpret_cast< gSensor * >(argp1);
19286   result = (gSensorWallType) ((arg1)->type);
19287   vresult = SWIG_From_int(static_cast< int >(result));
19288   return vresult;
19289 fail:
19290   return Qnil;
19291 }
19292 
19293 
19294 #ifdef HAVE_RB_DEFINE_ALLOC_FUNC
19295 SWIGINTERN VALUE
19296 _wrap_GSensor_allocate(VALUE self) {
19297 #else
19298   SWIGINTERN VALUE
19299   _wrap_GSensor_allocate(int argc, VALUE *argv, VALUE self) {
19300 #endif
19301     
19302     
19303     VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_gSensor);
19304 #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
19305     rb_obj_call_init(vresult, argc, argv);
19306 #endif
19307     return vresult;
19308   }
19309   
19310 
19311 SWIGINTERN VALUE
19312 _wrap_new_GSensor(int argc, VALUE *argv, VALUE self) {
19313   eGameObject *arg1 = (eGameObject *) 0 ;
19314   eCoord *arg2 = 0 ;
19315   eCoord *arg3 = 0 ;
19316   gSensor *result = 0 ;
19317   void *argp1 = 0 ;
19318   int res1 = 0 ;
19319   void *argp2 ;
19320   int res2 = 0 ;
19321   void *argp3 ;
19322   int res3 = 0 ;
19323   const char *classname SWIGUNUSED = "Armagetronad::GSensor";
19324   
19325   if ((argc < 3) || (argc > 3)) {
19326     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
19327   }
19328   res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_eGameObject, 0 |  0 );
19329   if (!SWIG_IsOK(res1)) {
19330     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gSensor" "', argument " "1"" of type '" "eGameObject *""'"); 
19331   }
19332   arg1 = reinterpret_cast< eGameObject * >(argp1);
19333   res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_eCoord,  0 );
19334   if (!SWIG_IsOK(res2)) {
19335     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gSensor" "', argument " "2"" of type '" "eCoord const &""'"); 
19336   }
19337   if (!argp2) {
19338     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gSensor" "', argument " "2"" of type '" "eCoord const &""'"); 
19339   }
19340   arg2 = reinterpret_cast< eCoord * >(argp2);
19341   res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_eCoord,  0 );
19342   if (!SWIG_IsOK(res3)) {
19343     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gSensor" "', argument " "3"" of type '" "eCoord const &""'"); 
19344   }
19345   if (!argp3) {
19346     SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "gSensor" "', argument " "3"" of type '" "eCoord const &""'"); 
19347   }
19348   arg3 = reinterpret_cast< eCoord * >(argp3);
19349   result = (gSensor *)new gSensor(arg1,(eCoord const &)*arg2,(eCoord const &)*arg3);DATA_PTR(self) = result;
19350   
19351   return self;
19352 fail:
19353   return Qnil;
19354 }
19355 
19356 
19357 SWIGINTERN VALUE
19358 _wrap_GSensor_pass_edge__SWIG_0(int argc, VALUE *argv, VALUE self) {
19359   gSensor *arg1 = (gSensor *) 0 ;
19360   eWall *arg2 = (eWall *) 0 ;
19361   REAL arg3 ;
19362   REAL arg4 ;
19363   int arg5 ;
19364   void *argp1 = 0 ;
19365   int res1 = 0 ;
19366   void *argp2 = 0 ;
19367   int res2 = 0 ;
19368   float val3 ;
19369   int ecode3 = 0 ;
19370   float val4 ;
19371   int ecode4 = 0 ;
19372   int val5 ;
19373   int ecode5 = 0 ;
19374   
19375   if ((argc < 4) || (argc > 4)) {
19376     rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
19377   }
19378   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gSensor, 0 |  0 );
19379   if (!SWIG_IsOK(res1)) {
19380     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PassEdge" "', argument " "1"" of type '" "gSensor *""'"); 
19381   }
19382   arg1 = reinterpret_cast< gSensor * >(argp1);
19383   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eWall, 0 |  0 );
19384   if (!SWIG_IsOK(res2)) {
19385     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PassEdge" "', argument " "2"" of type '" "eWall const *""'"); 
19386   }
19387   arg2 = reinterpret_cast< eWall * >(argp2);
19388   ecode3 = SWIG_AsVal_float(argv[1], &val3);
19389   if (!SWIG_IsOK(ecode3)) {
19390     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PassEdge" "', argument " "3"" of type '" "REAL""'");
19391   } 
19392   arg3 = static_cast< REAL >(val3);
19393   ecode4 = SWIG_AsVal_float(argv[2], &val4);
19394   if (!SWIG_IsOK(ecode4)) {
19395     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PassEdge" "', argument " "4"" of type '" "REAL""'");
19396   } 
19397   arg4 = static_cast< REAL >(val4);
19398   ecode5 = SWIG_AsVal_int(argv[3], &val5);
19399   if (!SWIG_IsOK(ecode5)) {
19400     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PassEdge" "', argument " "5"" of type '" "int""'");
19401   } 
19402   arg5 = static_cast< int >(val5);
19403   (arg1)->PassEdge((eWall const *)arg2,arg3,arg4,arg5);
19404   return Qnil;
19405 fail:
19406   return Qnil;
19407 }
19408 
19409 
19410 SWIGINTERN VALUE
19411 _wrap_GSensor_pass_edge__SWIG_1(int argc, VALUE *argv, VALUE self) {
19412   gSensor *arg1 = (gSensor *) 0 ;
19413   eWall *arg2 = (eWall *) 0 ;
19414   REAL arg3 ;
19415   REAL arg4 ;
19416   void *argp1 = 0 ;
19417   int res1 = 0 ;
19418   void *argp2 = 0 ;
19419   int res2 = 0 ;
19420   float val3 ;
19421   int ecode3 = 0 ;
19422   float val4 ;
19423   int ecode4 = 0 ;
19424   
19425   if ((argc < 3) || (argc > 3)) {
19426     rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
19427   }
19428   res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_gSensor, 0 |  0 );
19429   if (!SWIG_IsOK(res1)) {
19430     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PassEdge" "', argument " "1"" of type '" "gSensor *""'"); 
19431   }
19432   arg1 = reinterpret_cast< gSensor * >(argp1);
19433   res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_eWall, 0 |  0 );
19434   if (!SWIG_IsOK(res2)) {
19435     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PassEdge" "', argument " "2"" of type '" "eWall const *""'"); 
19436   }
19437   arg2 = reinterpret_cast< eWall * >(argp2);
19438   ecode3 = SWIG_AsVal_float(argv[1], &val3);
19439   if (!SWIG_IsOK(ecode3)) {
19440     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PassEdge" "', argument " "3"" of type '" "REAL""'");
19441   } 
19442   arg3 = static_cast< REAL >(val3);
19443   ecode4 = SWIG_AsVal_float(argv[2], &val4);
19444   if (!SWIG_IsOK(ecode4)) {
19445     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PassEdge" "', argument " "4"" of type '" "REAL""'");
19446   } 
19447   arg4 = static_cast< REAL >(val4);
19448   (arg1)->PassEdge((eWall const *)arg2,arg3,arg4);
19449   return Qnil;
19450 fail:
19451   return Qnil;
19452 }
19453 
19454 
19455 SWIGINTERN VALUE _wrap_GSensor_pass_edge(int nargs, VALUE *args, VALUE self) {
19456   int argc;
19457   VALUE argv[6];
19458   int ii;
19459   
19460   argc = nargs + 1;
19461   argv[0] = self;
19462   if (argc > 6) SWIG_fail;
19463   for (ii = 1; (ii < argc); ii++) {
19464     argv[ii] = args[ii-1];
19465   }
19466   if (argc == 4) {
19467     int _v;
19468     void *vptr = 0;
19469     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gSensor, 0);
19470     _v = SWIG_CheckState(res);
19471     if (_v) {
19472       void *vptr = 0;
19473       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eWall, 0);
19474       _v = SWIG_CheckState(res);
19475       if (_v) {
19476         {
19477           int res = SWIG_AsVal_float(argv[2], NULL);
19478           _v = SWIG_CheckState(res);
19479         }
19480         if (_v) {
19481           {
19482             int res = SWIG_AsVal_float(argv[3], NULL);
19483             _v = SWIG_CheckState(res);
19484           }
19485           if (_v) {
19486             return _wrap_GSensor_pass_edge__SWIG_1(nargs, args, self);
19487           }
19488         }
19489       }
19490     }
19491   }
19492   if (argc == 5) {
19493     int _v;
19494     void *vptr = 0;
19495     int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_gSensor, 0);
19496     _v = SWIG_CheckState(res);
19497     if (_v) {
19498       void *vptr = 0;
19499       int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_eWall, 0);
19500       _v = SWIG_CheckState(res);
19501       if (_v) {
19502         {
19503           int res = SWIG_AsVal_float(argv[2], NULL);
19504           _v = SWIG_CheckState(res);
19505         }
19506         if (_v) {
19507           {
19508             int res = SWIG_AsVal_float(argv[3], NULL);
19509             _v = SWIG_CheckState(res);
19510           }
19511           if (_v) {
19512             {
19513               int res = SWIG_AsVal_int(argv[4], NULL);
19514               _v = SWIG_CheckState(res);
19515             }
19516             if (_v) {
19517               return _wrap_GSensor_pass_edge__SWIG_0(nargs, args, self);
19518             }
19519           }
19520         }
19521       }
19522     }
19523   }
19524   
19525 fail:
19526   rb_raise(rb_eArgError, "No matching function for overloaded 'GSensor_pass_edge'");
19527   return Qnil;
19528 }
19529 
19530 
19531 SWIGINTERN void
19532 free_gSensor(gSensor *arg1) {
19533     delete arg1;
19534 }
19535 
19536 
19537 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
19538 
19539 static void *_p_tPathResourceTo_p_tPath(void *x) {
19540     return (void *)((tPath *)  ((tPathResource *) x));
19541 }
19542 static void *_p_tPathScriptsTo_p_tPath(void *x) {
19543     return (void *)((tPath *)  ((tPathScripts *) x));
19544 }
19545 static void *_p_gCycleTo_p_eNetGameObject(void *x) {
19546     return (void *)((eNetGameObject *) (gCycleMovement *) ((gCycle *) x));
19547 }
19548 static void *_p_gCycleMovementTo_p_eNetGameObject(void *x) {
19549     return (void *)((eNetGameObject *)  ((gCycleMovement *) x));
19550 }
19551 static void *_p_gCycleTo_p_eGameObject(void *x) {
19552     return (void *)((eGameObject *) (eNetGameObject *)(gCycleMovement *) ((gCycle *) x));
19553 }
19554 static void *_p_eNetGameObjectTo_p_eGameObject(void *x) {
19555     return (void *)((eGameObject *)  ((eNetGameObject *) x));
19556 }
19557 static void *_p_eSensorTo_p_eGameObject(void *x) {
19558     return (void *)((eGameObject *)  ((eSensor *) x));
19559 }
19560 static void *_p_gSensorTo_p_eGameObject(void *x) {
19561     return (void *)((eGameObject *) (eSensor *) ((gSensor *) x));
19562 }
19563 static void *_p_gCycleMovementTo_p_eGameObject(void *x) {
19564     return (void *)((eGameObject *) (eNetGameObject *) ((gCycleMovement *) x));
19565 }
19566 static void *_p_gCycleTo_p_gCycleMovement(void *x) {
19567     return (void *)((gCycleMovement *)  ((gCycle *) x));
19568 }
19569 static void *_p_uMenuItemStringWithHistoryTo_p_uMenuItemString(void *x) {
19570     return (void *)((uMenuItemString *)  ((uMenuItemStringWithHistory *) x));
19571 }
19572 static void *_p_uMenuItemSubmenuTo_p_uMenuItem(void *x) {
19573     return (void *)((uMenuItem *)  ((uMenuItemSubmenu *) x));
19574 }
19575 static void *_p_uMenuItemFunctionIntTo_p_uMenuItem(void *x) {
19576     return (void *)((uMenuItem *) (uMenuItemAction *) ((uMenuItemFunctionInt *) x));
19577 }
19578 static void *_p_uMenuItemIntTo_p_uMenuItem(void *x) {
19579     return (void *)((uMenuItem *)  ((uMenuItemInt *) x));
19580 }
19581 static void *_p_uMenuItemFunctionTo_p_uMenuItem(void *x) {
19582     return (void *)((uMenuItem *) (uMenuItemAction *) ((uMenuItemFunction *) x));
19583 }
19584 static void *_p_uMenuItemExitTo_p_uMenuItem(void *x) {
19585     return (void *)((uMenuItem *)  ((uMenuItemExit *) x));
19586 }
19587 static void *_p_uMenuItemStringTo_p_uMenuItem(void *x) {
19588     return (void *)((uMenuItem *)  ((uMenuItemString *) x));
19589 }
19590 static void *_p_uMenuItemActionTo_p_uMenuItem(void *x) {
19591     return (void *)((uMenuItem *)  ((uMenuItemAction *) x));
19592 }
19593 static void *_p_gCycleTo_p_nNetObject(void *x) {
19594     return (void *)((nNetObject *) (eNetGameObject *)(gCycleMovement *) ((gCycle *) x));
19595 }
19596 static void *_p_eNetGameObjectTo_p_nNetObject(void *x) {
19597     return (void *)((nNetObject *)  ((eNetGameObject *) x));
19598 }
19599 static void *_p_gCycleMovementTo_p_nNetObject(void *x) {
19600     return (void *)((nNetObject *) (eNetGameObject *) ((gCycleMovement *) x));
19601 }
19602 static void *_p_istringstreamTo_p_istream(void *x) {
19603     return (void *)((istream *)  ((istringstream *) x));
19604 }
19605 static void *_p_gSensorTo_p_eSensor(void *x) {
19606     return (void *)((eSensor *)  ((gSensor *) x));
19607 }
19608 static void *_p_tColoredStringTo_p_tString(void *x) {
19609     return (void *)((tString *)  ((tColoredString *) x));
19610 }
19611 static void *_p_uMenuItemFunctionIntTo_p_uMenuItemAction(void *x) {
19612     return (void *)((uMenuItemAction *)  ((uMenuItemFunctionInt *) x));
19613 }
19614 static void *_p_uMenuItemFunctionTo_p_uMenuItemAction(void *x) {
19615     return (void *)((uMenuItemAction *)  ((uMenuItemFunction *) x));
19616 }
19617 static swig_type_info _swigt__p_FUNCPTR = {"_p_FUNCPTR", "FUNCPTR *", 0, 0, (void*)0, 0};
19618 static swig_type_info _swigt__p_SDL_Event = {"_p_SDL_Event", "SDL_Event *", 0, 0, (void*)0, 0};
19619 static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 0, 0, (void*)0, 0};
19620 static swig_type_info _swigt__p_callbackFunc = {"_p_callbackFunc", "callbackFunc *", 0, 0, (void*)0, 0};
19621 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
19622 static swig_type_info _swigt__p_eCamera = {"_p_eCamera", "eCamera *", 0, 0, (void*)0, 0};
19623 static swig_type_info _swigt__p_eCoord = {"_p_eCoord", "eCoord *", 0, 0, (void*)0, 0};
19624 static swig_type_info _swigt__p_eFace = {"_p_eFace", "eFace *", 0, 0, (void*)0, 0};
19625 static swig_type_info _swigt__p_eGameObject = {"_p_eGameObject", "eGameObject *", 0, 0, (void*)0, 0};
19626 static swig_type_info _swigt__p_eGrid = {"_p_eGrid", "eGrid *", 0, 0, (void*)0, 0};
19627 static swig_type_info _swigt__p_eHalfEdge = {"_p_eHalfEdge", "eHalfEdge *", 0, 0, (void*)0, 0};
19628 static swig_type_info _swigt__p_eNetGameObject = {"_p_eNetGameObject", "eNetGameObject *", 0, 0, (void*)0, 0};
19629 static swig_type_info _swigt__p_ePlayerNetID = {"_p_ePlayerNetID", "ePlayerNetID *", 0, 0, (void*)0, 0};
19630 static swig_type_info _swigt__p_eSensor = {"_p_eSensor", "eSensor *", 0, 0, (void*)0, 0};
19631 static swig_type_info _swigt__p_eTeam = {"_p_eTeam", "eTeam *", 0, 0, (void*)0, 0};
19632 static swig_type_info _swigt__p_eTempEdge = {"_p_eTempEdge", "eTempEdge *", 0, 0, (void*)0, 0};
19633 static swig_type_info _swigt__p_eWall = {"_p_eWall", "eWall *", 0, 0, (void*)0, 0};
19634 static swig_type_info _swigt__p_f___void = {"_p_f___void", "void (*)()|tConfItemBase::callbackFunc *", 0, 0, (void*)0, 0};
19635 static swig_type_info _swigt__p_float = {"_p_float", "float *|REAL *", 0, 0, (void*)0, 0};
19636 static swig_type_info _swigt__p_gCycle = {"_p_gCycle", "gCycle *", 0, 0, (void*)0, 0};
19637 static swig_type_info _swigt__p_gCycleMemory = {"_p_gCycleMemory", "gCycleMemory *", 0, 0, (void*)0, 0};
19638 static swig_type_info _swigt__p_gCycleMovement = {"_p_gCycleMovement", "gCycleMovement *", 0, 0, (void*)0, 0};
19639 static swig_type_info _swigt__p_gDestination = {"_p_gDestination", "gDestination *", 0, 0, (void*)0, 0};
19640 static swig_type_info _swigt__p_gPlayerWall = {"_p_gPlayerWall", "gPlayerWall *", 0, 0, (void*)0, 0};
19641 static swig_type_info _swigt__p_gRealColor = {"_p_gRealColor", "gRealColor *", 0, 0, (void*)0, 0};
19642 static swig_type_info _swigt__p_gSensor = {"_p_gSensor", "gSensor *", 0, 0, (void*)0, 0};
19643 static swig_type_info _swigt__p_gSensorWallType = {"_p_gSensorWallType", "enum gSensorWallType *|gSensorWallType *", 0, 0, (void*)0, 0};
19644 static swig_type_info _swigt__p_gSimpleAI = {"_p_gSimpleAI", "gSimpleAI *", 0, 0, (void*)0, 0};
19645 static swig_type_info _swigt__p_gSimpleAIFactory = {"_p_gSimpleAIFactory", "gSimpleAIFactory *", 0, 0, (void*)0, 0};
19646 static swig_type_info _swigt__p_gTextureCycle = {"_p_gTextureCycle", "gTextureCycle *", 0, 0, (void*)0, 0};
19647 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
19648 static swig_type_info _swigt__p_ios_base__openmode = {"_p_ios_base__openmode", "ios_base::openmode *", 0, 0, (void*)0, 0};
19649 static swig_type_info _swigt__p_istream = {"_p_istream", "istream *|std::istream *", 0, 0, (void*)0, 0};
19650 static swig_type_info _swigt__p_istringstream = {"_p_istringstream", "istringstream *", 0, 0, (void*)0, 0};
19651 static swig_type_info _swigt__p_nDescriptor = {"_p_nDescriptor", "nDescriptor *", 0, 0, (void*)0, 0};
19652 static swig_type_info _swigt__p_nMachine = {"_p_nMachine", "nMachine *", 0, 0, (void*)0, 0};
19653 static swig_type_info _swigt__p_nMessage = {"_p_nMessage", "nMessage *", 0, 0, (void*)0, 0};
19654 static swig_type_info _swigt__p_nNetObject = {"_p_nNetObject", "nNetObject *", 0, 0, (void*)0, 0};
19655 static swig_type_info _swigt__p_nNetObjectRegistrar = {"_p_nNetObjectRegistrar", "nNetObjectRegistrar *", 0, 0, (void*)0, 0};
19656 static swig_type_info _swigt__p_nObserver = {"_p_nObserver", "nObserver *", 0, 0, (void*)0, 0};
19657 static swig_type_info _swigt__p_rModel = {"_p_rModel", "rModel *", 0, 0, (void*)0, 0};
19658 static swig_type_info _swigt__p_std__dequeTtString_t = {"_p_std__dequeTtString_t", "std::deque<tString > *", 0, 0, (void*)0, 0};
19659 static swig_type_info _swigt__p_std__fstream = {"_p_std__fstream", "std::fstream *", 0, 0, (void*)0, 0};
19660 static swig_type_info _swigt__p_std__ifstream = {"_p_std__ifstream", "std::ifstream *", 0, 0, (void*)0, 0};
19661 static swig_type_info _swigt__p_std__ios__openmode = {"_p_std__ios__openmode", "std::ios::openmode *", 0, 0, (void*)0, 0};
19662 static swig_type_info _swigt__p_std__ofstream = {"_p_std__ofstream", "std::ofstream *", 0, 0, (void*)0, 0};
19663 static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0};
19664 static swig_type_info _swigt__p_streambuf = {"_p_streambuf", "streambuf *", 0, 0, (void*)0, 0};
19665 static swig_type_info _swigt__p_tArrayTtString_t = {"_p_tArrayTtString_t", "tArray<tString > *", 0, 0, (void*)0, 0};
19666 static swig_type_info _swigt__p_tColoredString = {"_p_tColoredString", "tColoredString *", 0, 0, (void*)0, 0};
19667 static swig_type_info _swigt__p_tConfItemBase = {"_p_tConfItemBase", "tConfItemBase *", 0, 0, (void*)0, 0};
19668 static swig_type_info _swigt__p_tConsole = {"_p_tConsole", "tConsole *", 0, 0, (void*)0, 0};
19669 static swig_type_info _swigt__p_tDirectories = {"_p_tDirectories", "tDirectories *", 0, 0, (void*)0, 0};
19670 static swig_type_info _swigt__p_tOutput = {"_p_tOutput", "tOutput *", 0, 0, (void*)0, 0};
19671 static swig_type_info _swigt__p_tPath = {"_p_tPath", "tPath *", 0, 0, (void*)0, 0};
19672 static swig_type_info _swigt__p_tPathResource = {"_p_tPathResource", "tPathResource *", 0, 0, (void*)0, 0};
19673 static swig_type_info _swigt__p_tPathScripts = {"_p_tPathScripts", "tPathScripts *", 0, 0, (void*)0, 0};
19674 static swig_type_info _swigt__p_tString = {"_p_tString", "tString *", 0, 0, (void*)0, 0};
19675 static swig_type_info _swigt__p_uActionPlayer = {"_p_uActionPlayer", "uActionPlayer *", 0, 0, (void*)0, 0};
19676 static swig_type_info _swigt__p_uAutoCompleter = {"_p_uAutoCompleter", "uAutoCompleter *", 0, 0, (void*)0, 0};
19677 static swig_type_info _swigt__p_uMenu = {"_p_uMenu", "uMenu *", 0, 0, (void*)0, 0};
19678 static swig_type_info _swigt__p_uMenuItem = {"_p_uMenuItem", "uMenuItem *", 0, 0, (void*)0, 0};
19679 static swig_type_info _swigt__p_uMenuItemFunctionInt = {"_p_uMenuItemFunctionInt", 0, 0, 0, 0, 0};
19680 static swig_type_info _swigt__p_uMenuItemStringWithHistory = {"_p_uMenuItemStringWithHistory", 0, 0, 0, 0, 0};
19681 static swig_type_info _swigt__p_uMenuItemFunction = {"_p_uMenuItemFunction", 0, 0, 0, 0, 0};
19682 static swig_type_info _swigt__p_uMenuItemAction = {"_p_uMenuItemAction", "uMenuItemAction *", 0, 0, (void*)0, 0};
19683 static swig_type_info _swigt__p_uMenuItemExit = {"_p_uMenuItemExit", "uMenuItemExit *", 0, 0, (void*)0, 0};
19684 static swig_type_info _swigt__p_uMenuItemInt = {"_p_uMenuItemInt", "uMenuItemInt *", 0, 0, (void*)0, 0};
19685 static swig_type_info _swigt__p_uMenuItemString = {"_p_uMenuItemString", "uMenuItemString *", 0, 0, (void*)0, 0};
19686 static swig_type_info _swigt__p_uMenuItemSubmenu = {"_p_uMenuItemSubmenu", "uMenuItemSubmenu *", 0, 0, (void*)0, 0};
19687 static swig_type_info _swigt__p_uMenuItemToggle = {"_p_uMenuItemToggle", "uMenuItemToggle *", 0, 0, (void*)0, 0};
19688 static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *", 0, 0, (void*)0, 0};
19689 
19690 static swig_type_info *swig_type_initial[] = {
19691   &_swigt__p_FUNCPTR,
19692   &_swigt__p_SDL_Event,
19693   &_swigt__p_bool,
19694   &_swigt__p_callbackFunc,
19695   &_swigt__p_char,
19696   &_swigt__p_eCamera,
19697   &_swigt__p_eCoord,
19698   &_swigt__p_eFace,
19699   &_swigt__p_eGameObject,
19700   &_swigt__p_eGrid,
19701   &_swigt__p_eHalfEdge,
19702   &_swigt__p_eNetGameObject,
19703   &_swigt__p_ePlayerNetID,
19704   &_swigt__p_eSensor,
19705   &_swigt__p_eTeam,
19706   &_swigt__p_eTempEdge,
19707   &_swigt__p_eWall,
19708   &_swigt__p_f___void,
19709   &_swigt__p_float,
19710   &_swigt__p_gCycle,
19711   &_swigt__p_gCycleMemory,
19712   &_swigt__p_gCycleMovement,
19713   &_swigt__p_gDestination,
19714   &_swigt__p_gPlayerWall,
19715   &_swigt__p_gRealColor,
19716   &_swigt__p_gSensor,
19717   &_swigt__p_gSensorWallType,
19718   &_swigt__p_gSimpleAI,
19719   &_swigt__p_gSimpleAIFactory,
19720   &_swigt__p_gTextureCycle,
19721   &_swigt__p_int,
19722   &_swigt__p_ios_base__openmode,
19723   &_swigt__p_istream,
19724   &_swigt__p_istringstream,
19725   &_swigt__p_nDescriptor,
19726   &_swigt__p_nMachine,
19727   &_swigt__p_nMessage,
19728   &_swigt__p_nNetObject,
19729   &_swigt__p_nNetObjectRegistrar,
19730   &_swigt__p_nObserver,
19731   &_swigt__p_rModel,
19732   &_swigt__p_std__dequeTtString_t,
19733   &_swigt__p_std__fstream,
19734   &_swigt__p_std__ifstream,
19735   &_swigt__p_std__ios__openmode,
19736   &_swigt__p_std__ofstream,
19737   &_swigt__p_std__ostream,
19738   &_swigt__p_streambuf,
19739   &_swigt__p_tArrayTtString_t,
19740   &_swigt__p_tColoredString,
19741   &_swigt__p_tConfItemBase,
19742   &_swigt__p_tConsole,
19743   &_swigt__p_tDirectories,
19744   &_swigt__p_tOutput,
19745   &_swigt__p_tPath,
19746   &_swigt__p_tPathResource,
19747   &_swigt__p_tPathScripts,
19748   &_swigt__p_tString,
19749   &_swigt__p_uActionPlayer,
19750   &_swigt__p_uAutoCompleter,
19751   &_swigt__p_uMenu,
19752   &_swigt__p_uMenuItem,
19753   &_swigt__p_uMenuItemAction,
19754   &_swigt__p_uMenuItemExit,
19755   &_swigt__p_uMenuItemFunction,
19756   &_swigt__p_uMenuItemFunctionInt,
19757   &_swigt__p_uMenuItemInt,
19758   &_swigt__p_uMenuItemString,
19759   &_swigt__p_uMenuItemStringWithHistory,
19760   &_swigt__p_uMenuItemSubmenu,
19761   &_swigt__p_uMenuItemToggle,
19762   &_swigt__p_unsigned_short,
19763 };
19764 
19765 static swig_cast_info _swigc__p_FUNCPTR[] = {  {&_swigt__p_FUNCPTR, 0, 0, 0},{0, 0, 0, 0}};
19766 static swig_cast_info _swigc__p_SDL_Event[] = {  {&_swigt__p_SDL_Event, 0, 0, 0},{0, 0, 0, 0}};
19767 static swig_cast_info _swigc__p_bool[] = {  {&_swigt__p_bool, 0, 0, 0},{0, 0, 0, 0}};
19768 static swig_cast_info _swigc__p_callbackFunc[] = {  {&_swigt__p_callbackFunc, 0, 0, 0},{0, 0, 0, 0}};
19769 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
19770 static swig_cast_info _swigc__p_eCamera[] = {  {&_swigt__p_eCamera, 0, 0, 0},{0, 0, 0, 0}};
19771 static swig_cast_info _swigc__p_eCoord[] = {  {&_swigt__p_eCoord, 0, 0, 0},{0, 0, 0, 0}};
19772 static swig_cast_info _swigc__p_eFace[] = {  {&_swigt__p_eFace, 0, 0, 0},{0, 0, 0, 0}};
19773 static swig_cast_info _swigc__p_eGameObject[] = {  {&_swigt__p_gCycle, _p_gCycleTo_p_eGameObject, 0, 0},  {&_swigt__p_eGameObject, 0, 0, 0},  {&_swigt__p_eNetGameObject, _p_eNetGameObjectTo_p_eGameObject, 0, 0},  {&_swigt__p_eSensor, _p_eSensorTo_p_eGameObject, 0, 0},  {&_swigt__p_gSensor, _p_gSensorTo_p_eGameObject, 0, 0},  {&_swigt__p_gCycleMovement, _p_gCycleMovementTo_p_eGameObject, 0, 0},{0, 0, 0, 0}};
19774 static swig_cast_info _swigc__p_eGrid[] = {  {&_swigt__p_eGrid, 0, 0, 0},{0, 0, 0, 0}};
19775 static swig_cast_info _swigc__p_eHalfEdge[] = {  {&_swigt__p_eHalfEdge, 0, 0, 0},{0, 0, 0, 0}};
19776 static swig_cast_info _swigc__p_eNetGameObject[] = {  {&_swigt__p_gCycle, _p_gCycleTo_p_eNetGameObject, 0, 0},  {&_swigt__p_eNetGameObject, 0, 0, 0},  {&_swigt__p_gCycleMovement, _p_gCycleMovementTo_p_eNetGameObject, 0, 0},{0, 0, 0, 0}};
19777 static swig_cast_info _swigc__p_ePlayerNetID[] = {  {&_swigt__p_ePlayerNetID, 0, 0, 0},{0, 0, 0, 0}};
19778 static swig_cast_info _swigc__p_eSensor[] = {  {&_swigt__p_eSensor, 0, 0, 0},  {&_swigt__p_gSensor, _p_gSensorTo_p_eSensor, 0, 0},{0, 0, 0, 0}};
19779 static swig_cast_info _swigc__p_eTeam[] = {  {&_swigt__p_eTeam, 0, 0, 0},{0, 0, 0, 0}};
19780 static swig_cast_info _swigc__p_eTempEdge[] = {  {&_swigt__p_eTempEdge, 0, 0, 0},{0, 0, 0, 0}};
19781 static swig_cast_info _swigc__p_eWall[] = {  {&_swigt__p_eWall, 0, 0, 0},{0, 0, 0, 0}};
19782 static swig_cast_info _swigc__p_f___void[] = {  {&_swigt__p_f___void, 0, 0, 0},{0, 0, 0, 0}};
19783 static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
19784 static swig_cast_info _swigc__p_gCycle[] = {  {&_swigt__p_gCycle, 0, 0, 0},{0, 0, 0, 0}};
19785 static swig_cast_info _swigc__p_gCycleMemory[] = {  {&_swigt__p_gCycleMemory, 0, 0, 0},{0, 0, 0, 0}};
19786 static swig_cast_info _swigc__p_gCycleMovement[] = {  {&_swigt__p_gCycle, _p_gCycleTo_p_gCycleMovement, 0, 0},  {&_swigt__p_gCycleMovement, 0, 0, 0},{0, 0, 0, 0}};
19787 static swig_cast_info _swigc__p_gDestination[] = {  {&_swigt__p_gDestination, 0, 0, 0},{0, 0, 0, 0}};
19788 static swig_cast_info _swigc__p_gPlayerWall[] = {  {&_swigt__p_gPlayerWall, 0, 0, 0},{0, 0, 0, 0}};
19789 static swig_cast_info _swigc__p_gRealColor[] = {  {&_swigt__p_gRealColor, 0, 0, 0},{0, 0, 0, 0}};
19790 static swig_cast_info _swigc__p_gSensor[] = {  {&_swigt__p_gSensor, 0, 0, 0},{0, 0, 0, 0}};
19791 static swig_cast_info _swigc__p_gSensorWallType[] = {  {&_swigt__p_gSensorWallType, 0, 0, 0},{0, 0, 0, 0}};
19792 static swig_cast_info _swigc__p_gSimpleAI[] = {  {&_swigt__p_gSimpleAI, 0, 0, 0},{0, 0, 0, 0}};
19793 static swig_cast_info _swigc__p_gSimpleAIFactory[] = {  {&_swigt__p_gSimpleAIFactory, 0, 0, 0},{0, 0, 0, 0}};
19794 static swig_cast_info _swigc__p_gTextureCycle[] = {  {&_swigt__p_gTextureCycle, 0, 0, 0},{0, 0, 0, 0}};
19795 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
19796 static swig_cast_info _swigc__p_ios_base__openmode[] = {  {&_swigt__p_ios_base__openmode, 0, 0, 0},{0, 0, 0, 0}};
19797 static swig_cast_info _swigc__p_istream[] = {  {&_swigt__p_istream, 0, 0, 0},  {&_swigt__p_istringstream, _p_istringstreamTo_p_istream, 0, 0},{0, 0, 0, 0}};
19798 static swig_cast_info _swigc__p_istringstream[] = {  {&_swigt__p_istringstream, 0, 0, 0},{0, 0, 0, 0}};
19799 static swig_cast_info _swigc__p_nDescriptor[] = {  {&_swigt__p_nDescriptor, 0, 0, 0},{0, 0, 0, 0}};
19800 static swig_cast_info _swigc__p_nMachine[] = {  {&_swigt__p_nMachine, 0, 0, 0},{0, 0, 0, 0}};
19801 static swig_cast_info _swigc__p_nMessage[] = {  {&_swigt__p_nMessage, 0, 0, 0},{0, 0, 0, 0}};
19802 static swig_cast_info _swigc__p_nNetObject[] = {  {&_swigt__p_gCycle, _p_gCycleTo_p_nNetObject, 0, 0},  {&_swigt__p_nNetObject, 0, 0, 0},  {&_swigt__p_eNetGameObject, _p_eNetGameObjectTo_p_nNetObject, 0, 0},  {&_swigt__p_gCycleMovement, _p_gCycleMovementTo_p_nNetObject, 0, 0},{0, 0, 0, 0}};
19803 static swig_cast_info _swigc__p_nNetObjectRegistrar[] = {  {&_swigt__p_nNetObjectRegistrar, 0, 0, 0},{0, 0, 0, 0}};
19804 static swig_cast_info _swigc__p_nObserver[] = {  {&_swigt__p_nObserver, 0, 0, 0},{0, 0, 0, 0}};
19805 static swig_cast_info _swigc__p_rModel[] = {  {&_swigt__p_rModel, 0, 0, 0},{0, 0, 0, 0}};
19806 static swig_cast_info _swigc__p_std__dequeTtString_t[] = {  {&_swigt__p_std__dequeTtString_t, 0, 0, 0},{0, 0, 0, 0}};
19807 static swig_cast_info _swigc__p_std__fstream[] = {  {&_swigt__p_std__fstream, 0, 0, 0},{0, 0, 0, 0}};
19808 static swig_cast_info _swigc__p_std__ifstream[] = {  {&_swigt__p_std__ifstream, 0, 0, 0},{0, 0, 0, 0}};
19809 static swig_cast_info _swigc__p_std__ios__openmode[] = {  {&_swigt__p_std__ios__openmode, 0, 0, 0},{0, 0, 0, 0}};
19810 static swig_cast_info _swigc__p_std__ofstream[] = {  {&_swigt__p_std__ofstream, 0, 0, 0},{0, 0, 0, 0}};
19811 static swig_cast_info _swigc__p_std__ostream[] = {  {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}};
19812 static swig_cast_info _swigc__p_streambuf[] = {  {&_swigt__p_streambuf, 0, 0, 0},{0, 0, 0, 0}};
19813 static swig_cast_info _swigc__p_tArrayTtString_t[] = {  {&_swigt__p_tArrayTtString_t, 0, 0, 0},{0, 0, 0, 0}};
19814 static swig_cast_info _swigc__p_tColoredString[] = {  {&_swigt__p_tColoredString, 0, 0, 0},{0, 0, 0, 0}};
19815 static swig_cast_info _swigc__p_tConfItemBase[] = {  {&_swigt__p_tConfItemBase, 0, 0, 0},{0, 0, 0, 0}};
19816 static swig_cast_info _swigc__p_tConsole[] = {  {&_swigt__p_tConsole, 0, 0, 0},{0, 0, 0, 0}};
19817 static swig_cast_info _swigc__p_tDirectories[] = {  {&_swigt__p_tDirectories, 0, 0, 0},{0, 0, 0, 0}};
19818 static swig_cast_info _swigc__p_tOutput[] = {  {&_swigt__p_tOutput, 0, 0, 0},{0, 0, 0, 0}};
19819 static swig_cast_info _swigc__p_tPath[] = {  {&_swigt__p_tPathResource, _p_tPathResourceTo_p_tPath, 0, 0},  {&_swigt__p_tPath, 0, 0, 0},  {&_swigt__p_tPathScripts, _p_tPathScriptsTo_p_tPath, 0, 0},{0, 0, 0, 0}};
19820 static swig_cast_info _swigc__p_tPathResource[] = {  {&_swigt__p_tPathResource, 0, 0, 0},{0, 0, 0, 0}};
19821 static swig_cast_info _swigc__p_tPathScripts[] = {  {&_swigt__p_tPathScripts, 0, 0, 0},{0, 0, 0, 0}};
19822 static swig_cast_info _swigc__p_tString[] = {  {&_swigt__p_tString, 0, 0, 0},  {&_swigt__p_tColoredString, _p_tColoredStringTo_p_tString, 0, 0},{0, 0, 0, 0}};
19823 static swig_cast_info _swigc__p_uActionPlayer[] = {  {&_swigt__p_uActionPlayer, 0, 0, 0},{0, 0, 0, 0}};
19824 static swig_cast_info _swigc__p_uAutoCompleter[] = {  {&_swigt__p_uAutoCompleter, 0, 0, 0},{0, 0, 0, 0}};
19825 static swig_cast_info _swigc__p_uMenu[] = {  {&_swigt__p_uMenu, 0, 0, 0},{0, 0, 0, 0}};
19826 static swig_cast_info _swigc__p_uMenuItemFunctionInt[] = {{&_swigt__p_uMenuItemFunctionInt, 0, 0, 0},{0, 0, 0, 0}};
19827 static swig_cast_info _swigc__p_uMenuItemStringWithHistory[] = {{&_swigt__p_uMenuItemStringWithHistory, 0, 0, 0},{0, 0, 0, 0}};
19828 static swig_cast_info _swigc__p_uMenuItemFunction[] = {{&_swigt__p_uMenuItemFunction, 0, 0, 0},{0, 0, 0, 0}};
19829 static swig_cast_info _swigc__p_uMenuItem[] = {  {&_swigt__p_uMenuItemSubmenu, _p_uMenuItemSubmenuTo_p_uMenuItem, 0, 0},  {&_swigt__p_uMenuItemFunctionInt, _p_uMenuItemFunctionIntTo_p_uMenuItem, 0, 0},  {&_swigt__p_uMenuItemStringWithHistory, 0, 0, 0},  {&_swigt__p_uMenuItemInt, _p_uMenuItemIntTo_p_uMenuItem, 0, 0},  {&_swigt__p_uMenuItemFunction, _p_uMenuItemFunctionTo_p_uMenuItem, 0, 0},  {&_swigt__p_uMenuItemExit, _p_uMenuItemExitTo_p_uMenuItem, 0, 0},  {&_swigt__p_uMenuItem, 0, 0, 0},  {&_swigt__p_uMenuItemString, _p_uMenuItemStringTo_p_uMenuItem, 0, 0},  {&_swigt__p_uMenuItemAction, _p_uMenuItemActionTo_p_uMenuItem, 0, 0},{0, 0, 0, 0}};
19830 static swig_cast_info _swigc__p_uMenuItemAction[] = {  {&_swigt__p_uMenuItemFunctionInt, _p_uMenuItemFunctionIntTo_p_uMenuItemAction, 0, 0},  {&_swigt__p_uMenuItemFunction, _p_uMenuItemFunctionTo_p_uMenuItemAction, 0, 0},  {&_swigt__p_uMenuItemAction, 0, 0, 0},{0, 0, 0, 0}};
19831 static swig_cast_info _swigc__p_uMenuItemExit[] = {  {&_swigt__p_uMenuItemExit, 0, 0, 0},{0, 0, 0, 0}};
19832 static swig_cast_info _swigc__p_uMenuItemInt[] = {  {&_swigt__p_uMenuItemInt, 0, 0, 0},{0, 0, 0, 0}};
19833 static swig_cast_info _swigc__p_uMenuItemString[] = {  {&_swigt__p_uMenuItemStringWithHistory, _p_uMenuItemStringWithHistoryTo_p_uMenuItemString, 0, 0},  {&_swigt__p_uMenuItemString, 0, 0, 0},{0, 0, 0, 0}};
19834 static swig_cast_info _swigc__p_uMenuItemSubmenu[] = {  {&_swigt__p_uMenuItemSubmenu, 0, 0, 0},{0, 0, 0, 0}};
19835 static swig_cast_info _swigc__p_uMenuItemToggle[] = {  {&_swigt__p_uMenuItemToggle, 0, 0, 0},{0, 0, 0, 0}};
19836 static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
19837 
19838 static swig_cast_info *swig_cast_initial[] = {
19839   _swigc__p_FUNCPTR,
19840   _swigc__p_SDL_Event,
19841   _swigc__p_bool,
19842   _swigc__p_callbackFunc,
19843   _swigc__p_char,
19844   _swigc__p_eCamera,
19845   _swigc__p_eCoord,
19846   _swigc__p_eFace,
19847   _swigc__p_eGameObject,
19848   _swigc__p_eGrid,
19849   _swigc__p_eHalfEdge,
19850   _swigc__p_eNetGameObject,
19851   _swigc__p_ePlayerNetID,
19852   _swigc__p_eSensor,
19853   _swigc__p_eTeam,
19854   _swigc__p_eTempEdge,
19855   _swigc__p_eWall,
19856   _swigc__p_f___void,
19857   _swigc__p_float,
19858   _swigc__p_gCycle,
19859   _swigc__p_gCycleMemory,
19860   _swigc__p_gCycleMovement,
19861   _swigc__p_gDestination,
19862   _swigc__p_gPlayerWall,
19863   _swigc__p_gRealColor,
19864   _swigc__p_gSensor,
19865   _swigc__p_gSensorWallType,
19866   _swigc__p_gSimpleAI,
19867   _swigc__p_gSimpleAIFactory,
19868   _swigc__p_gTextureCycle,
19869   _swigc__p_int,
19870   _swigc__p_ios_base__openmode,
19871   _swigc__p_istream,
19872   _swigc__p_istringstream,
19873   _swigc__p_nDescriptor,
19874   _swigc__p_nMachine,
19875   _swigc__p_nMessage,
19876   _swigc__p_nNetObject,
19877   _swigc__p_nNetObjectRegistrar,
19878   _swigc__p_nObserver,
19879   _swigc__p_rModel,
19880   _swigc__p_std__dequeTtString_t,
19881   _swigc__p_std__fstream,
19882   _swigc__p_std__ifstream,
19883   _swigc__p_std__ios__openmode,
19884   _swigc__p_std__ofstream,
19885   _swigc__p_std__ostream,
19886   _swigc__p_streambuf,
19887   _swigc__p_tArrayTtString_t,
19888   _swigc__p_tColoredString,
19889   _swigc__p_tConfItemBase,
19890   _swigc__p_tConsole,
19891   _swigc__p_tDirectories,
19892   _swigc__p_tOutput,
19893   _swigc__p_tPath,
19894   _swigc__p_tPathResource,
19895   _swigc__p_tPathScripts,
19896   _swigc__p_tString,
19897   _swigc__p_uActionPlayer,
19898   _swigc__p_uAutoCompleter,
19899   _swigc__p_uMenu,
19900   _swigc__p_uMenuItem,
19901   _swigc__p_uMenuItemAction,
19902   _swigc__p_uMenuItemExit,
19903   _swigc__p_uMenuItemFunction,
19904   _swigc__p_uMenuItemFunctionInt,
19905   _swigc__p_uMenuItemInt,
19906   _swigc__p_uMenuItemString,
19907   _swigc__p_uMenuItemStringWithHistory,
19908   _swigc__p_uMenuItemSubmenu,
19909   _swigc__p_uMenuItemToggle,
19910   _swigc__p_unsigned_short,
19911 };
19912 
19913 
19914 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
19915 
19916 /* -----------------------------------------------------------------------------
19917  * Type initialization:
19918  * This problem is tough by the requirement that no dynamic 
19919  * memory is used. Also, since swig_type_info structures store pointers to 
19920  * swig_cast_info structures and swig_cast_info structures store pointers back
19921  * to swig_type_info structures, we need some lookup code at initialization. 
19922  * The idea is that swig generates all the structures that are needed. 
19923  * The runtime then collects these partially filled structures. 
19924  * The SWIG_InitializeModule function takes these initial arrays out of 
19925  * swig_module, and does all the lookup, filling in the swig_module.types
19926  * array with the correct data and linking the correct swig_cast_info
19927  * structures together.
19928  *
19929  * The generated swig_type_info structures are assigned staticly to an initial 
19930  * array. We just loop through that array, and handle each type individually.
19931  * First we lookup if this type has been already loaded, and if so, use the
19932  * loaded structure instead of the generated one. Then we have to fill in the
19933  * cast linked list. The cast data is initially stored in something like a
19934  * two-dimensional array. Each row corresponds to a type (there are the same
19935  * number of rows as there are in the swig_type_initial array). Each entry in
19936  * a column is one of the swig_cast_info structures for that type.
19937  * The cast_initial array is actually an array of arrays, because each row has
19938  * a variable number of columns. So to actually build the cast linked list,
19939  * we find the array of casts associated with the type, and loop through it 
19940  * adding the casts to the list. The one last trick we need to do is making
19941  * sure the type pointer in the swig_cast_info struct is correct.
19942  *
19943  * First off, we lookup the cast->type name to see if it is already loaded. 
19944  * There are three cases to handle:
19945  *  1) If the cast->type has already been loaded AND the type we are adding
19946  *     casting info to has not been loaded (it is in this module), THEN we
19947  *     replace the cast->type pointer with the type pointer that has already
19948  *     been loaded.
19949  *  2) If BOTH types (the one we are adding casting info to, and the 
19950  *     cast->type) are loaded, THEN the cast info has already been loaded by
19951  *     the previous module so we just ignore it.
19952  *  3) Finally, if cast->type has not already been loaded, then we add that
19953  *     swig_cast_info to the linked list (because the cast->type) pointer will
19954  *     be correct.
19955  * ----------------------------------------------------------------------------- */
19956 
19957 #ifdef __cplusplus
19958 extern "C" {
19959 #if 0
19960 } /* c-mode */
19961 #endif
19962 #endif
19963 
19964 #if 0
19965 #define SWIGRUNTIME_DEBUG
19966 #endif
19967 
19968 
19969 SWIGRUNTIME void
19970 SWIG_InitializeModule(void *clientdata) {
19971   size_t i;
19972   swig_module_info *module_head, *iter;
19973   int found;
19974 
19975   clientdata = clientdata;
19976 
19977   /* check to see if the circular list has been setup, if not, set it up */
19978   if (swig_module.next==0) {
19979     /* Initialize the swig_module */
19980     swig_module.type_initial = swig_type_initial;
19981     swig_module.cast_initial = swig_cast_initial;
19982     swig_module.next = &swig_module;
19983   }
19984 
19985   /* Try and load any already created modules */
19986   module_head = SWIG_GetModule(clientdata);
19987   if (!module_head) {
19988     /* This is the first module loaded for this interpreter */
19989     /* so set the swig module into the interpreter */
19990     SWIG_SetModule(clientdata, &swig_module);
19991     module_head = &swig_module;
19992   } else {
19993     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
19994     found=0;
19995     iter=module_head;
19996     do {
19997       if (iter==&swig_module) {
19998         found=1;
19999         break;
20000       }
20001       iter=iter->next;
20002     } while (iter!= module_head);
20003 
20004     /* if the is found in the list, then all is done and we may leave */
20005     if (found) return;
20006     /* otherwise we must add out module into the list */
20007     swig_module.next = module_head->next;
20008     module_head->next = &swig_module;
20009   }
20010 
20011   /* Now work on filling in swig_module.types */
20012 #ifdef SWIGRUNTIME_DEBUG
20013   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
20014 #endif
20015   for (i = 0; i < swig_module.size; ++i) {
20016     swig_type_info *type = 0;
20017     swig_type_info *ret;
20018     swig_cast_info *cast;
20019   
20020 #ifdef SWIGRUNTIME_DEBUG
20021     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
20022 #endif
20023 
20024     /* if there is another module already loaded */
20025     if (swig_module.next != &swig_module) {
20026       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
20027     }
20028     if (type) {
20029       /* Overwrite clientdata field */
20030 #ifdef SWIGRUNTIME_DEBUG
20031       printf("SWIG_InitializeModule: found type %s\n", type->name);
20032 #endif
20033       if (swig_module.type_initial[i]->clientdata) {
20034         type->clientdata = swig_module.type_initial[i]->clientdata;
20035 #ifdef SWIGRUNTIME_DEBUG
20036       printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
20037 #endif
20038       }
20039     } else {
20040       type = swig_module.type_initial[i];
20041     }
20042 
20043     /* Insert casting types */
20044     cast = swig_module.cast_initial[i];
20045     while (cast->type) {
20046     
20047       /* Don't need to add information already in the list */
20048       ret = 0;
20049 #ifdef SWIGRUNTIME_DEBUG
20050       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
20051 #endif
20052       if (swig_module.next != &swig_module) {
20053         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
20054 #ifdef SWIGRUNTIME_DEBUG
20055         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
20056 #endif
20057       }
20058       if (ret) {
20059         if (type == swig_module.type_initial[i]) {
20060 #ifdef SWIGRUNTIME_DEBUG
20061           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
20062 #endif
20063           cast->type = ret;
20064           ret = 0;
20065         } else {
20066           /* Check for casting already in the list */
20067           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
20068 #ifdef SWIGRUNTIME_DEBUG
20069           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
20070 #endif
20071           if (!ocast) ret = 0;
20072         }
20073       }
20074 
20075       if (!ret) {
20076 #ifdef SWIGRUNTIME_DEBUG
20077         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
20078 #endif
20079         if (type->cast) {
20080           type->cast->prev = cast;
20081           cast->next = type->cast;
20082         }
20083         type->cast = cast;
20084       }
20085       cast++;
20086     }
20087     /* Set entry in modules->types array equal to the type */
20088     swig_module.types[i] = type;
20089   }
20090   swig_module.types[i] = 0;
20091 
20092 #ifdef SWIGRUNTIME_DEBUG
20093   printf("**** SWIG_InitializeModule: Cast List ******\n");
20094   for (i = 0; i < swig_module.size; ++i) {
20095     int j = 0;
20096     swig_cast_info *cast = swig_module.cast_initial[i];
20097     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
20098     while (cast->type) {
20099       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
20100       cast++;
20101       ++j;
20102     }
20103   printf("---- Total casts: %d\n",j);
20104   }
20105   printf("**** SWIG_InitializeModule: Cast List ******\n");
20106 #endif
20107 }
20108 
20109 /* This function will propagate the clientdata field of type to
20110 * any new swig_type_info structures that have been added into the list
20111 * of equivalent types.  It is like calling
20112 * SWIG_TypeClientData(type, clientdata) a second time.
20113 */
20114 SWIGRUNTIME void
20115 SWIG_PropagateClientData(void) {
20116   size_t i;
20117   swig_cast_info *equiv;
20118   static int init_run = 0;
20119 
20120   if (init_run) return;
20121   init_run = 1;
20122 
20123   for (i = 0; i < swig_module.size; i++) {
20124     if (swig_module.types[i]->clientdata) {
20125       equiv = swig_module.types[i]->cast;
20126       while (equiv) {
20127         if (!equiv->converter) {
20128           if (equiv->type && !equiv->type->clientdata)
20129             SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
20130         }
20131         equiv = equiv->next;
20132       }
20133     }
20134   }
20135 }
20136 
20137 #ifdef __cplusplus
20138 #if 0
20139 { /* c-mode */
20140 #endif
20141 }
20142 #endif
20143 
20144 
20145 #ifdef __cplusplus
20146 extern "C"
20147 #endif
20148 SWIGEXPORT void Init_armagetronad(void) {
20149   size_t i;
20150   
20151   SWIG_InitRuntime();
20152   mArmagetronad = rb_define_module("Armagetronad");
20153   
20154   SWIG_InitializeModule(0);
20155   for (i = 0; i < swig_module.size; i++) {
20156     SWIG_define_class(swig_module.types[i]);
20157   }
20158   
20159   SWIG_RubyInitializeTrackings();
20160   
20161   cIstream.klass = rb_define_class_under(mArmagetronad, "Istream", rb_cObject);
20162   SWIG_TypeClientData(SWIGTYPE_p_istream, (void *) &cIstream);
20163   rb_define_alloc_func(cIstream.klass, _wrap_Istream_allocate);
20164   rb_define_method(cIstream.klass, "initialize", VALUEFUNC(_wrap_new_Istream), -1);
20165   cIstream.mark = 0;
20166   cIstream.destroy = (void (*)(void *)) free_istream;
20167   cIstream.trackObjects = 0;
20168   
20169   cIstringstream.klass = rb_define_class_under(mArmagetronad, "Istringstream", ((swig_class *) SWIGTYPE_p_istream->clientdata)->klass);
20170   SWIG_TypeClientData(SWIGTYPE_p_istringstream, (void *) &cIstringstream);
20171   rb_define_alloc_func(cIstringstream.klass, _wrap_Istringstream_allocate);
20172   rb_define_method(cIstringstream.klass, "initialize", VALUEFUNC(_wrap_new_Istringstream), -1);
20173   cIstringstream.mark = 0;
20174   cIstringstream.destroy = (void (*)(void *)) free_istringstream;
20175   cIstringstream.trackObjects = 0;
20176   rb_define_module_function(mArmagetronad, "disown_TConfItemBase", VALUEFUNC(_wrap_disown_TConfItemBase), -1);
20177   
20178   cTConfItemBase.klass = rb_define_class_under(mArmagetronad, "TConfItemBase", rb_cObject);
20179   SWIG_TypeClientData(SWIGTYPE_p_tConfItemBase, (void *) &cTConfItemBase);
20180   rb_define_alloc_func(cTConfItemBase.klass, _wrap_TConfItemBase_allocate);
20181   rb_define_method(cTConfItemBase.klass, "initialize", VALUEFUNC(_wrap_new_TConfItemBase), -1);
20182   rb_define_singleton_method(cTConfItemBase.klass, "load_all", VALUEFUNC(_wrap_TConfItemBase_load_all), -1);
20183   rb_define_singleton_method(cTConfItemBase.klass, "load_line", VALUEFUNC(_wrap_TConfItemBase_load_line), -1);
20184   rb_define_singleton_method(cTConfItemBase.klass, "find_config_item", VALUEFUNC(_wrap_TConfItemBase_find_config_item), -1);
20185   rb_define_singleton_method(cTConfItemBase.klass, "load_string", VALUEFUNC(_wrap_TConfItemBase_load_string), -1);
20186   rb_define_method(cTConfItemBase.klass, "read_val", VALUEFUNC(_wrap_TConfItemBase_read_val), -1);
20187   rb_define_method(cTConfItemBase.klass, "write_val", VALUEFUNC(_wrap_TConfItemBase_write_val), -1);
20188   cTConfItemBase.mark = 0;
20189   cTConfItemBase.destroy = (void (*)(void *)) free_tConfItemBase;
20190   cTConfItemBase.trackObjects = 0;
20191   
20192   cTOutput.klass = rb_define_class_under(mArmagetronad, "TOutput", rb_cObject);
20193   SWIG_TypeClientData(SWIGTYPE_p_tOutput, (void *) &cTOutput);
20194   rb_define_alloc_func(cTOutput.klass, _wrap_TOutput_allocate);
20195   rb_define_method(cTOutput.klass, "initialize", VALUEFUNC(_wrap_new_TOutput), -1);
20196   rb_define_method(cTOutput.klass, "add_literal", VALUEFUNC(_wrap_TOutput_add_literal), -1);
20197   rb_define_method(cTOutput.klass, "add_locale", VALUEFUNC(_wrap_TOutput_add_locale), -1);
20198   rb_define_method(cTOutput.klass, "add_space", VALUEFUNC(_wrap_TOutput_add_space), -1);
20199   rb_define_method(cTOutput.klass, "set_template_parameter_string", VALUEFUNC(_wrap_TOutput_set_template_parameter_string), -1);
20200   rb_define_method(cTOutput.klass, "set_template_parameter_float", VALUEFUNC(_wrap_TOutput_set_template_parameter_float), -1);
20201   rb_define_method(cTOutput.klass, "clear", VALUEFUNC(_wrap_TOutput_clear), -1);
20202   rb_define_method(cTOutput.klass, "append", VALUEFUNC(_wrap_TOutput_append), -1);
20203   rb_define_method(cTOutput.klass, "is_empty", VALUEFUNC(_wrap_TOutput_is_empty), -1);
20204   cTOutput.mark = 0;
20205   cTOutput.destroy = (void (*)(void *)) free_tOutput;
20206   cTOutput.trackObjects = 0;
20207   rb_define_module_function(mArmagetronad, "disown_TPath", VALUEFUNC(_wrap_disown_TPath), -1);
20208   
20209   cTPath.klass = rb_define_class_under(mArmagetronad, "TPath", rb_cObject);
20210   SWIG_TypeClientData(SWIGTYPE_p_tPath, (void *) &cTPath);
20211   rb_define_alloc_func(cTPath.klass, _wrap_TPath_allocate);
20212   rb_define_method(cTPath.klass, "initialize", VALUEFUNC(_wrap_new_TPath), -1);
20213   rb_define_method(cTPath.klass, "open", VALUEFUNC(_wrap_TPath_open), -1);
20214   rb_define_method(cTPath.klass, "get_read_path", VALUEFUNC(_wrap_TPath_get_read_path), -1);
20215   rb_define_method(cTPath.klass, "get_write_path", VALUEFUNC(_wrap_TPath_get_write_path), -1);
20216   rb_define_singleton_method(cTPath.klass, "is_valid_path", VALUEFUNC(_wrap_TPath_is_valid_path), -1);
20217   rb_define_method(cTPath.klass, "get_paths", VALUEFUNC(_wrap_TPath_get_paths), -1);
20218   rb_define_protected_method(cTPath.klass, "paths", VALUEFUNC(_wrap_TPath_paths), -1);
20219   cTPath.mark = 0;
20220   cTPath.destroy = (void (*)(void *)) free_tPath;
20221   cTPath.trackObjects = 0;
20222   
20223   cTPathResource.klass = rb_define_class_under(mArmagetronad, "TPathResource", ((swig_class *) SWIGTYPE_p_tPath->clientdata)->klass);
20224   SWIG_TypeClientData(SWIGTYPE_p_tPathResource, (void *) &cTPathResource);
20225   rb_define_alloc_func(cTPathResource.klass, _wrap_TPathResource_allocate);
20226   rb_define_method(cTPathResource.klass, "initialize", VALUEFUNC(_wrap_new_TPathResource), -1);
20227   rb_define_method(cTPathResource.klass, "get_write_path", VALUEFUNC(_wrap_TPathResource_get_write_path), -1);
20228   rb_define_singleton_method(cTPathResource.klass, "get_dir_path", VALUEFUNC(_wrap_TPathResource_get_dir_path), -1);
20229   cTPathResource.mark = 0;
20230   cTPathResource.destroy = (void (*)(void *)) free_tPathResource;
20231   cTPathResource.trackObjects = 0;
20232   
20233   cTPathScripts.klass = rb_define_class_under(mArmagetronad, "TPathScripts", ((swig_class *) SWIGTYPE_p_tPath->clientdata)->klass);
20234   SWIG_TypeClientData(SWIGTYPE_p_tPathScripts, (void *) &cTPathScripts);
20235   rb_define_alloc_func(cTPathScripts.klass, _wrap_TPathScripts_allocate);
20236   rb_define_method(cTPathScripts.klass, "initialize", VALUEFUNC(_wrap_new_TPathScripts), -1);
20237   rb_define_singleton_method(cTPathScripts.klass, "get_dir_path", VALUEFUNC(_wrap_TPathScripts_get_dir_path), -1);
20238   cTPathScripts.mark = 0;
20239   cTPathScripts.destroy = (void (*)(void *)) free_tPathScripts;
20240   cTPathScripts.trackObjects = 0;
20241   
20242   cTDirectories.klass = rb_define_class_under(mArmagetronad, "TDirectories", rb_cObject);
20243   SWIG_TypeClientData(SWIGTYPE_p_tDirectories, (void *) &cTDirectories);
20244   rb_define_alloc_func(cTDirectories.klass, _wrap_TDirectories_allocate);
20245   rb_define_method(cTDirectories.klass, "initialize", VALUEFUNC(_wrap_new_TDirectories), -1);
20246   rb_define_const(cTDirectories.klass, "EGetFilesAllFiles", SWIG_From_int(static_cast< int >(tDirectories::eGetFilesAllFiles)));
20247   rb_define_const(cTDirectories.klass, "EGetFilesFilesOnly", SWIG_From_int(static_cast< int >(tDirectories::eGetFilesFilesOnly)));
20248   rb_define_const(cTDirectories.klass, "EGetFilesDirsOnly", SWIG_From_int(static_cast< int >(tDirectories::eGetFilesDirsOnly)));
20249   rb_define_singleton_method(cTDirectories.klass, "data", VALUEFUNC(_wrap_TDirectories_data), -1);
20250   rb_define_singleton_method(cTDirectories.klass, "music", VALUEFUNC(_wrap_TDirectories_music), -1);
20251   rb_define_singleton_method(cTDirectories.klass, "config", VALUEFUNC(_wrap_TDirectories_config), -1);
20252   rb_define_singleton_method(cTDirectories.klass, "var", VALUEFUNC(_wrap_TDirectories_var), -1);
20253   rb_define_singleton_method(cTDirectories.klass, "screenshot", VALUEFUNC(_wrap_TDirectories_screenshot), -1);
20254   rb_define_singleton_method(cTDirectories.klass, "resource", VALUEFUNC(_wrap_TDirectories_resource), -1);
20255   rb_define_singleton_method(cTDirectories.klass, "scripts", VALUEFUNC(_wrap_TDirectories_scripts), -1);
20256   rb_define_singleton_method(cTDirectories.klass, "set_data", VALUEFUNC(_wrap_TDirectories_set_data), -1);
20257   rb_define_singleton_method(cTDirectories.klass, "set_user_data", VALUEFUNC(_wrap_TDirectories_set_user_data), -1);
20258   rb_define_singleton_method(cTDirectories.klass, "set_config", VALUEFUNC(_wrap_TDirectories_set_config), -1);
20259   rb_define_singleton_method(cTDirectories.klass, "set_user_config", VALUEFUNC(_wrap_TDirectories_set_user_config), -1);
20260   rb_define_singleton_method(cTDirectories.klass, "set_var", VALUEFUNC(_wrap_TDirectories_set_var), -1);
20261   rb_define_singleton_method(cTDirectories.klass, "set_screenshot", VALUEFUNC(_wrap_TDirectories_set_screenshot), -1);
20262   rb_define_singleton_method(cTDirectories.klass, "set_resource", VALUEFUNC(_wrap_TDirectories_set_resource), -1);
20263   rb_define_singleton_method(cTDirectories.klass, "set_auto_resource", VALUEFUNC(_wrap_TDirectories_set_auto_resource), -1);
20264   rb_define_singleton_method(cTDirectories.klass, "set_included_resource", VALUEFUNC(_wrap_TDirectories_set_included_resource), -1);
20265   rb_define_singleton_method(cTDirectories.klass, "get_files", VALUEFUNC(_wrap_TDirectories_get_files), -1);
20266   rb_define_singleton_method(cTDirectories.klass, "file_matches_wildcard", VALUEFUNC(_wrap_TDirectories_file_matches_wildcard), -1);
20267   rb_define_singleton_method(cTDirectories.klass, "file_name_to_menu_name", VALUEFUNC(_wrap_TDirectories_file_name_to_menu_name), -1);
20268   rb_define_singleton_method(cTDirectories.klass, "get_spec_list", VALUEFUNC(_wrap_TDirectories_get_spec_list), -1);
20269   rb_define_singleton_method(cTDirectories.klass, "sort_files", VALUEFUNC(_wrap_TDirectories_sort_files), -1);
20270   cTDirectories.mark = 0;
20271   cTDirectories.destroy = (void (*)(void *)) free_tDirectories;
20272   cTDirectories.trackObjects = 0;
20273   
20274   cTString.klass = rb_define_class_under(mArmagetronad, "TString", rb_cObject);
20275   SWIG_TypeClientData(SWIGTYPE_p_tString, (void *) &cTString);
20276   rb_define_alloc_func(cTString.klass, _wrap_TString_allocate);
20277   rb_define_method(cTString.klass, "initialize", VALUEFUNC(_wrap_new_TString), -1);
20278   cTString.mark = 0;
20279   cTString.destroy = (void (*)(void *)) free_tString;
20280   cTString.trackObjects = 0;
20281   
20282   cTColoredString.klass = rb_define_class_under(mArmagetronad, "TColoredString", ((swig_class *) SWIGTYPE_p_tString->clientdata)->klass);
20283   SWIG_TypeClientData(SWIGTYPE_p_tColoredString, (void *) &cTColoredString);
20284   rb_define_alloc_func(cTColoredString.klass, _wrap_TColoredString_allocate);
20285   rb_define_method(cTColoredString.klass, "initialize", VALUEFUNC(_wrap_new_TColoredString), -1);
20286   cTColoredString.mark = 0;
20287   cTColoredString.destroy = (void (*)(void *)) free_tColoredString;
20288   cTColoredString.trackObjects = 0;
20289   rb_define_module_function(mArmagetronad, "disown_NNetObject", VALUEFUNC(_wrap_disown_NNetObject), -1);
20290   
20291   cNNetObject.klass = rb_define_class_under(mArmagetronad, "NNetObject", rb_cObject);
20292   SWIG_TypeClientData(SWIGTYPE_p_nNetObject, (void *) &cNNetObject);
20293   rb_define_alloc_func(cNNetObject.klass, _wrap_NNetObject_allocate);
20294   rb_define_method(cNNetObject.klass, "initialize", VALUEFUNC(_wrap_new_NNetObject), -1);
20295   rb_define_singleton_method(cNNetObject.klass, "do_debug_print", VALUEFUNC(_wrap_NNetObject_do_debug_print), -1);
20296   rb_define_singleton_method(cNNetObject.klass, "object_dangerous", VALUEFUNC(_wrap_NNetObject_object_dangerous), -1);
20297   rb_define_method(cNNetObject.klass, "add_ref", VALUEFUNC(_wrap_NNetObject_add_ref), -1);
20298   rb_define_method(cNNetObject.klass, "release", VALUEFUNC(_wrap_NNetObject_release), -1);
20299   rb_define_method(cNNetObject.klass, "get_refcount", VALUEFUNC(_wrap_NNetObject_get_refcount), -1);
20300   rb_define_method(cNNetObject.klass, "release_ownership", VALUEFUNC(_wrap_NNetObject_release_ownership), -1);
20301   rb_define_method(cNNetObject.klass, "take_ownership", VALUEFUNC(_wrap_NNetObject_take_ownership), -1);
20302   rb_define_method(cNNetObject.klass, "owned", VALUEFUNC(_wrap_NNetObject_owned), -1);
20303   rb_define_method(cNNetObject.klass, "get_observer", VALUEFUNC(_wrap_NNetObject_get_observer), -1);
20304   rb_define_method(cNNetObject.klass, "dump", VALUEFUNC(_wrap_NNetObject_dump), -1);
20305   rb_define_method(cNNetObject.klass, "id", VALUEFUNC(_wrap_NNetObject_id), -1);
20306   rb_define_method(cNNetObject.klass, "owner", VALUEFUNC(_wrap_NNetObject_owner), -1);
20307   rb_define_method(cNNetObject.klass, "get_machine", VALUEFUNC(_wrap_NNetObject_get_machine), -1);
20308   rb_define_method(cNNetObject.klass, "creator_descriptor", VALUEFUNC(_wrap_NNetObject_creator_descriptor), -1);
20309   rb_define_method(cNNetObject.klass, "init_after_creation", VALUEFUNC(_wrap_NNetObject_init_after_creation), -1);
20310   rb_define_method(cNNetObject.klass, "register", VALUEFUNC(_wrap_NNetObject_register), -1);
20311   rb_define_protected_method(cNNetObject.klass, "do_get_machine", VALUEFUNC(_wrap_NNetObject_do_get_machine), -1);
20312   rb_define_method(cNNetObject.klass, "action_on_quit", VALUEFUNC(_wrap_NNetObject_action_on_quit), -1);
20313   rb_define_method(cNNetObject.klass, "action_on_delete", VALUEFUNC(_wrap_NNetObject_action_on_delete), -1);
20314   rb_define_method(cNNetObject.klass, "broadcast_existence", VALUEFUNC(_wrap_NNetObject_broadcast_existence), -1);
20315   rb_define_method(cNNetObject.klass, "print_name", VALUEFUNC(_wrap_NNetObject_print_name), -1);
20316   rb_define_method(cNNetObject.klass, "has_been_transmitted", VALUEFUNC(_wrap_NNetObject_has_been_transmitted), -1);
20317   rb_define_method(cNNetObject.klass, "sync_requested", VALUEFUNC(_wrap_NNetObject_sync_requested), -1);
20318   rb_define_method(cNNetObject.klass, "clear_to_transmit", VALUEFUNC(_wrap_NNetObject_clear_to_transmit), -1);
20319   rb_define_method(cNNetObject.klass, "write_sync", VALUEFUNC(_wrap_NNetObject_write_sync), -1);
20320   rb_define_method(cNNetObject.klass, "read_sync", VALUEFUNC(_wrap_NNetObject_read_sync), -1);
20321   rb_define_method(cNNetObject.klass, "sync_is_new", VALUEFUNC(_wrap_NNetObject_sync_is_new), -1);
20322   rb_define_method(cNNetObject.klass, "write_create", VALUEFUNC(_wrap_NNetObject_write_create), -1);
20323   rb_define_method(cNNetObject.klass, "receive_control_net", VALUEFUNC(_wrap_NNetObject_receive_control_net), -1);
20324   rb_define_method(cNNetObject.klass, "accept_client_sync", VALUEFUNC(_wrap_NNetObject_accept_client_sync), -1);
20325   rb_define_method(cNNetObject.klass, "get_id", VALUEFUNC(_wrap_NNetObject_get_id), -1);
20326   rb_define_method(cNNetObject.klass, "request_sync", VALUEFUNC(_wrap_NNetObject_request_sync), -1);
20327   rb_define_singleton_method(cNNetObject.klass, "sync_all", VALUEFUNC(_wrap_NNetObject_sync_all), -1);
20328   rb_define_singleton_method(cNNetObject.klass, "clear_all", VALUEFUNC(_wrap_NNetObject_clear_all), -1);
20329   rb_define_singleton_method(cNNetObject.klass, "clear_all_deleted", VALUEFUNC(_wrap_NNetObject_clear_all_deleted), -1);
20330   rb_define_singleton_method(cNNetObject.klass, "clear_knows", VALUEFUNC(_wrap_NNetObject_clear_knows), -1);
20331   rb_define_singleton_method(cNNetObject.klass, "relabel_on_connect", VALUEFUNC(_wrap_NNetObject_relabel_on_connect), -1);
20332   cNNetObject.mark = 0;
20333   cNNetObject.trackObjects = 0;
20334   
20335   cUMenu.klass = rb_define_class_under(mArmagetronad, "UMenu", rb_cObject);
20336   SWIG_TypeClientData(SWIGTYPE_p_uMenu, (void *) &cUMenu);
20337   rb_define_alloc_func(cUMenu.klass, _wrap_UMenu_allocate);
20338   rb_define_method(cUMenu.klass, "initialize", VALUEFUNC(_wrap_new_UMenu), -1);
20339   rb_define_singleton_method(cUMenu.klass, "wrap", VALUEFUNC(UMenu_wrap_get), 0);
20340   rb_define_singleton_method(cUMenu.klass, "wrap=", VALUEFUNC(UMenu_wrap_set), 1);
20341   rb_define_singleton_method(cUMenu.klass, "quickexit", VALUEFUNC(UMenu_quickexit_get), 0);
20342   rb_define_singleton_method(cUMenu.klass, "quickexit=", VALUEFUNC(UMenu_quickexit_set), 1);
20343   rb_define_singleton_method(cUMenu.klass, "exitToMain", VALUEFUNC(UMenu_exitToMain_get), 0);
20344   rb_define_singleton_method(cUMenu.klass, "exitToMain=", VALUEFUNC(UMenu_exitToMain_set), 1);
20345   rb_define_method(cUMenu.klass, "title=", VALUEFUNC(_wrap_UMenu_title_set), -1);
20346   rb_define_method(cUMenu.klass, "title", VALUEFUNC(_wrap_UMenu_title_get), -1);
20347   rb_define_method(cUMenu.klass, "idle_func", VALUEFUNC(_wrap_UMenu_idle_func), -1);
20348   rb_define_singleton_method(cUMenu.klass, "set_idle", VALUEFUNC(_wrap_UMenu_set_idle), -1);
20349   rb_define_method(cUMenu.klass, "set_center", VALUEFUNC(_wrap_UMenu_set_center), -1);
20350   rb_define_method(cUMenu.klass, "set_top", VALUEFUNC(_wrap_UMenu_set_top), -1);
20351   rb_define_method(cUMenu.klass, "set_bot", VALUEFUNC(_wrap_UMenu_set_bot), -1);
20352   rb_define_method(cUMenu.klass, "set_selected", VALUEFUNC(_wrap_UMenu_set_selected), -1);
20353   rb_define_method(cUMenu.klass, "num_items", VALUEFUNC(_wrap_UMenu_num_items), -1);
20354   rb_define_method(cUMenu.klass, "item", VALUEFUNC(_wrap_UMenu_item), -1);
20355   rb_define_method(cUMenu.klass, "add_item", VALUEFUNC(_wrap_UMenu_add_item), -1);
20356   rb_define_method(cUMenu.klass, "remove_item", VALUEFUNC(_wrap_UMenu_remove_item), -1);
20357   rb_define_method(cUMenu.klass, "enter", VALUEFUNC(_wrap_UMenu_enter), -1);
20358   rb_define_method(cUMenu.klass, "reverse_items", VALUEFUNC(_wrap_UMenu_reverse_items), -1);
20359   rb_define_singleton_method(cUMenu.klass, "generic_background", VALUEFUNC(_wrap_UMenu_generic_background), -1);
20360   rb_define_method(cUMenu.klass, "exit", VALUEFUNC(_wrap_UMenu_exit), -1);
20361   rb_define_method(cUMenu.klass, "request_space_below", VALUEFUNC(_wrap_UMenu_request_space_below), -1);
20362   rb_define_singleton_method(cUMenu.klass, "message", VALUEFUNC(_wrap_UMenu_message), -1);
20363   rb_define_singleton_method(cUMenu.klass, "menu_active", VALUEFUNC(_wrap_UMenu_menu_active), -1);
20364   cUMenu.mark = 0;
20365   cUMenu.destroy = (void (*)(void *)) free_uMenu;
20366   cUMenu.trackObjects = 0;
20367   
20368   cUMenuItem.klass = rb_define_class_under(mArmagetronad, "UMenuItem", rb_cObject);
20369   SWIG_TypeClientData(SWIGTYPE_p_uMenuItem, (void *) &cUMenuItem);
20370   rb_define_alloc_func(cUMenuItem.klass, _wrap_UMenuItem_allocate);
20371   rb_define_method(cUMenuItem.klass, "initialize", VALUEFUNC(_wrap_new_UMenuItem), -1);
20372   rb_define_method(cUMenuItem.klass, "help", VALUEFUNC(_wrap_UMenuItem_help), -1);
20373   rb_define_method(cUMenuItem.klass, "render", VALUEFUNC(_wrap_UMenuItem_render), -1);
20374   rb_define_method(cUMenuItem.klass, "render_background", VALUEFUNC(_wrap_UMenuItem_render_background), -1);
20375   rb_define_method(cUMenuItem.klass, "left_right", VALUEFUNC(_wrap_UMenuItem_left_right), -1);
20376   rb_define_method(cUMenuItem.klass, "left_right_release", VALUEFUNC(_wrap_UMenuItem_left_right_release), -1);
20377   rb_define_method(cUMenuItem.klass, "enter", VALUEFUNC(_wrap_UMenuItem_enter), -1);
20378   rb_define_method(cUMenuItem.klass, "event", VALUEFUNC(_wrap_UMenuItem_event), -1);
20379   rb_define_method(cUMenuItem.klass, "space_right", VALUEFUNC(_wrap_UMenuItem_space_right), -1);
20380   rb_define_method(cUMenuItem.klass, "get_id", VALUEFUNC(_wrap_UMenuItem_get_id), -1);
20381   rb_define_method(cUMenuItem.klass, "is_selectable", VALUEFUNC(_wrap_UMenuItem_is_selectable), -1);
20382   cUMenuItem.mark = 0;
20383   cUMenuItem.destroy = (void (*)(void *)) free_uMenuItem;
20384   cUMenuItem.trackObjects = 0;
20385   
20386   cUMenuItemExit.klass = rb_define_class_under(mArmagetronad, "UMenuItemExit", ((swig_class *) SWIGTYPE_p_uMenuItem->clientdata)->klass);
20387   SWIG_TypeClientData(SWIGTYPE_p_uMenuItemExit, (void *) &cUMenuItemExit);
20388   rb_define_alloc_func(cUMenuItemExit.klass, _wrap_UMenuItemExit_allocate);
20389   rb_define_method(cUMenuItemExit.klass, "initialize", VALUEFUNC(_wrap_new_UMenuItemExit), -1);
20390   rb_define_method(cUMenuItemExit.klass, "render", VALUEFUNC(_wrap_UMenuItemExit_render), -1);
20391   rb_define_method(cUMenuItemExit.klass, "enter", VALUEFUNC(_wrap_UMenuItemExit_enter), -1);
20392   cUMenuItemExit.mark = 0;
20393   cUMenuItemExit.destroy = (void (*)(void *)) free_uMenuItemExit;
20394   cUMenuItemExit.trackObjects = 0;
20395   
20396   cUMenuItemToggle.klass = rb_define_class_under(mArmagetronad, "UMenuItemToggle", rb_cObject);
20397   SWIG_TypeClientData(SWIGTYPE_p_uMenuItemToggle, (void *) &cUMenuItemToggle);
20398   rb_define_alloc_func(cUMenuItemToggle.klass, _wrap_UMenuItemToggle_allocate);
20399   rb_define_method(cUMenuItemToggle.klass, "initialize", VALUEFUNC(_wrap_new_UMenuItemToggle), -1);
20400   rb_define_method(cUMenuItemToggle.klass, "left_right", VALUEFUNC(_wrap_UMenuItemToggle_left_right), -1);
20401   rb_define_method(cUMenuItemToggle.klass, "enter", VALUEFUNC(_wrap_UMenuItemToggle_enter), -1);
20402   cUMenuItemToggle.mark = 0;
20403   cUMenuItemToggle.destroy = (void (*)(void *)) free_uMenuItemToggle;
20404   cUMenuItemToggle.trackObjects = 0;
20405   
20406   cUMenuItemInt.klass = rb_define_class_under(mArmagetronad, "UMenuItemInt", ((swig_class *) SWIGTYPE_p_uMenuItem->clientdata)->klass);
20407   SWIG_TypeClientData(SWIGTYPE_p_uMenuItemInt, (void *) &cUMenuItemInt);
20408   rb_define_alloc_func(cUMenuItemInt.klass, _wrap_UMenuItemInt_allocate);
20409   rb_define_method(cUMenuItemInt.klass, "initialize", VALUEFUNC(_wrap_new_UMenuItemInt), -1);
20410   rb_define_method(cUMenuItemInt.klass, "left_right", VALUEFUNC(_wrap_UMenuItemInt_left_right), -1);
20411   rb_define_method(cUMenuItemInt.klass, "render", VALUEFUNC(_wrap_UMenuItemInt_render), -1);
20412   cUMenuItemInt.mark = 0;
20413   cUMenuItemInt.destroy = (void (*)(void *)) free_uMenuItemInt;
20414   cUMenuItemInt.trackObjects = 0;
20415   
20416   cUMenuItemString.klass = rb_define_class_under(mArmagetronad, "UMenuItemString", ((swig_class *) SWIGTYPE_p_uMenuItem->clientdata)->klass);
20417   SWIG_TypeClientData(SWIGTYPE_p_uMenuItemString, (void *) &cUMenuItemString);
20418   rb_define_alloc_func(cUMenuItemString.klass, _wrap_UMenuItemString_allocate);
20419   rb_define_method(cUMenuItemString.klass, "initialize", VALUEFUNC(_wrap_new_UMenuItemString), -1);
20420   rb_define_method(cUMenuItemString.klass, "render", VALUEFUNC(_wrap_UMenuItemString_render), -1);
20421   rb_define_method(cUMenuItemString.klass, "event", VALUEFUNC(_wrap_UMenuItemString_event), -1);
20422   rb_define_method(cUMenuItemString.klass, "my_menu", VALUEFUNC(_wrap_UMenuItemString_my_menu), -1);
20423   cUMenuItemString.mark = 0;
20424   cUMenuItemString.destroy = (void (*)(void *)) free_uMenuItemString;
20425   cUMenuItemString.trackObjects = 0;
20426   
20427   cUAutoCompleter.klass = rb_define_class_under(mArmagetronad, "UAutoCompleter", rb_cObject);
20428   SWIG_TypeClientData(SWIGTYPE_p_uAutoCompleter, (void *) &cUAutoCompleter);
20429   rb_define_alloc_func(cUAutoCompleter.klass, _wrap_UAutoCompleter_allocate);
20430   rb_define_method(cUAutoCompleter.klass, "initialize", VALUEFUNC(_wrap_new_UAutoCompleter), -1);
20431   rb_define_method(cUAutoCompleter.klass, "complete", VALUEFUNC(_wrap_UAutoCompleter_complete), -1);
20432   rb_define_method(cUAutoCompleter.klass, "set_ignorecase", VALUEFUNC(_wrap_UAutoCompleter_set_ignorecase), -1);
20433   cUAutoCompleter.mark = 0;
20434   cUAutoCompleter.destroy = (void (*)(void *)) free_uAutoCompleter;
20435   cUAutoCompleter.trackObjects = 0;
20436   
20437   cUMenuItemSubmenu.klass = rb_define_class_under(mArmagetronad, "UMenuItemSubmenu", ((swig_class *) SWIGTYPE_p_uMenuItem->clientdata)->klass);
20438   SWIG_TypeClientData(SWIGTYPE_p_uMenuItemSubmenu, (void *) &cUMenuItemSubmenu);
20439   rb_define_alloc_func(cUMenuItemSubmenu.klass, _wrap_UMenuItemSubmenu_allocate);
20440   rb_define_method(cUMenuItemSubmenu.klass, "initialize", VALUEFUNC(_wrap_new_UMenuItemSubmenu), -1);
20441   rb_define_method(cUMenuItemSubmenu.klass, "render", VALUEFUNC(_wrap_UMenuItemSubmenu_render), -1);
20442   rb_define_method(cUMenuItemSubmenu.klass, "enter", VALUEFUNC(_wrap_UMenuItemSubmenu_enter), -1);
20443   cUMenuItemSubmenu.mark = 0;
20444   cUMenuItemSubmenu.destroy = (void (*)(void *)) free_uMenuItemSubmenu;
20445   cUMenuItemSubmenu.trackObjects = 0;
20446   rb_define_module_function(mArmagetronad, "disown_UMenuItemAction", VALUEFUNC(_wrap_disown_UMenuItemAction), -1);
20447   
20448   cUMenuItemAction.klass = rb_define_class_under(mArmagetronad, "UMenuItemAction", ((swig_class *) SWIGTYPE_p_uMenuItem->clientdata)->klass);
20449   SWIG_TypeClientData(SWIGTYPE_p_uMenuItemAction, (void *) &cUMenuItemAction);
20450   rb_define_alloc_func(cUMenuItemAction.klass, _wrap_UMenuItemAction_allocate);
20451   rb_define_method(cUMenuItemAction.klass, "initialize", VALUEFUNC(_wrap_new_UMenuItemAction), -1);
20452   rb_define_method(cUMenuItemAction.klass, "render", VALUEFUNC(_wrap_UMenuItemAction_render), -1);
20453   rb_define_method(cUMenuItemAction.klass, "enter", VALUEFUNC(_wrap_UMenuItemAction_enter), -1);
20454   cUMenuItemAction.mark = 0;
20455   cUMenuItemAction.destroy = (void (*)(void *)) free_uMenuItemAction;
20456   cUMenuItemAction.trackObjects = 0;
20457   
20458   cEGameObject.klass = rb_define_class_under(mArmagetronad, "EGameObject", rb_cObject);
20459   SWIG_TypeClientData(SWIGTYPE_p_eGameObject, (void *) &cEGameObject);
20460   rb_define_alloc_func(cEGameObject.klass, _wrap_EGameObject_allocate);
20461   rb_define_method(cEGameObject.klass, "initialize", VALUEFUNC(_wrap_new_EGameObject), -1);
20462   rb_define_singleton_method(cEGameObject.klass, "get_max_lazy_lag", VALUEFUNC(_wrap_EGameObject_get_max_lazy_lag), -1);
20463   rb_define_singleton_method(cEGameObject.klass, "set_max_lazy_lag", VALUEFUNC(_wrap_EGameObject_set_max_lazy_lag), -1);
20464   rb_define_method(cEGameObject.klass, "team", VALUEFUNC(_wrap_EGameObject_team), -1);
20465   rb_define_method(cEGameObject.klass, "grid", VALUEFUNC(_wrap_EGameObject_grid), -1);
20466   rb_define_method(cEGameObject.klass, "current_face", VALUEFUNC(_wrap_EGameObject_current_face), -1);
20467   rb_define_method(cEGameObject.klass, "add_ref", VALUEFUNC(_wrap_EGameObject_add_ref), -1);
20468   rb_define_method(cEGameObject.klass, "release", VALUEFUNC(_wrap_EGameObject_release), -1);
20469   rb_define_method(cEGameObject.klass, "add_to_list", VALUEFUNC(_wrap_EGameObject_add_to_list), -1);
20470   rb_define_method(cEGameObject.klass, "remove_from_list", VALUEFUNC(_wrap_EGameObject_remove_from_list), -1);
20471   rb_define_method(cEGameObject.klass, "remove_from_lists_all", VALUEFUNC(_wrap_EGameObject_remove_from_lists_all), -1);
20472   rb_define_method(cEGameObject.klass, "remove_from_game", VALUEFUNC(_wrap_EGameObject_remove_from_game), -1);
20473   rb_define_method(cEGameObject.klass, "goid", VALUEFUNC(_wrap_EGameObject_goid), -1);
20474   rb_define_method(cEGameObject.klass, "last_time", VALUEFUNC(_wrap_EGameObject_last_time), -1);
20475   rb_define_method(cEGameObject.klass, "next_interesting_time", VALUEFUNC(_wrap_EGameObject_next_interesting_time), -1);
20476   rb_define_method(cEGameObject.klass, "position", VALUEFUNC(_wrap_EGameObject_position), -1);
20477   rb_define_method(cEGameObject.klass, "direction", VALUEFUNC(_wrap_EGameObject_direction), -1);
20478   rb_define_method(cEGameObject.klass, "last_direction", VALUEFUNC(_wrap_EGameObject_last_direction), -1);
20479   rb_define_method(cEGameObject.klass, "death_time", VALUEFUNC(_wrap_EGameObject_death_time), -1);
20480   rb_define_method(cEGameObject.klass, "speed", VALUEFUNC(_wrap_EGameObject_speed), -1);
20481   rb_define_method(cEGameObject.klass, "predict_position", VALUEFUNC(_wrap_EGameObject_predict_position), -1);
20482   rb_define_method(cEGameObject.klass, "interact_with", VALUEFUNC(_wrap_EGameObject_interact_with), -1);
20483   rb_define_method(cEGameObject.klass, "pass_edge", VALUEFUNC(_wrap_EGameObject_pass_edge), -1);
20484   rb_define_method(cEGameObject.klass, "pathfinding_modifier", VALUEFUNC(_wrap_EGameObject_pathfinding_modifier), -1);
20485   rb_define_method(cEGameObject.klass, "move", VALUEFUNC(_wrap_EGameObject_move), -1);
20486   rb_define_method(cEGameObject.klass, "find_current_face", VALUEFUNC(_wrap_EGameObject_find_current_face), -1);
20487   rb_define_method(cEGameObject.klass, "timestep", VALUEFUNC(_wrap_EGameObject_timestep), -1);
20488   rb_define_method(cEGameObject.klass, "edge_is_dangerous", VALUEFUNC(_wrap_EGameObject_edge_is_dangerous), -1);
20489   rb_define_method(cEGameObject.klass, "kill", VALUEFUNC(_wrap_EGameObject_kill), -1);
20490   rb_define_method(cEGameObject.klass, "alive", VALUEFUNC(_wrap_EGameObject_alive), -1);
20491   rb_define_method(cEGameObject.klass, "render", VALUEFUNC(_wrap_EGameObject_render), -1);
20492   rb_define_method(cEGameObject.klass, "render_cockpit_fixed_before", VALUEFUNC(_wrap_EGameObject_render_cockpit_fixed_before), -1);
20493   rb_define_method(cEGameObject.klass, "render_cockpit_fixed_after", VALUEFUNC(_wrap_EGameObject_render_cockpit_fixed_after), -1);
20494   rb_define_method(cEGameObject.klass, "render_cockpit_virtual", VALUEFUNC(_wrap_EGameObject_render_cockpit_virtual), -1);
20495   rb_define_method(cEGameObject.klass, "cam_dir", VALUEFUNC(_wrap_EGameObject_cam_dir), -1);
20496   rb_define_method(cEGameObject.klass, "cam_rise", VALUEFUNC(_wrap_EGameObject_cam_rise), -1);
20497   rb_define_method(cEGameObject.klass, "cam_pos", VALUEFUNC(_wrap_EGameObject_cam_pos), -1);
20498   rb_define_method(cEGameObject.klass, "cam_z", VALUEFUNC(_wrap_EGameObject_cam_z), -1);
20499   rb_define_method(cEGameObject.klass, "cam_top", VALUEFUNC(_wrap_EGameObject_cam_top), -1);
20500   rb_define_method(cEGameObject.klass, "lag", VALUEFUNC(_wrap_EGameObject_lag), -1);
20501   rb_define_method(cEGameObject.klass, "lag_threshold", VALUEFUNC(_wrap_EGameObject_lag_threshold), -1);
20502   rb_define_method(cEGameObject.klass, "act", VALUEFUNC(_wrap_EGameObject_act), -1);
20503   rb_define_singleton_method(cEGameObject.klass, "s_timestep", VALUEFUNC(_wrap_EGameObject_s_timestep), -1);
20504   rb_define_singleton_method(cEGameObject.klass, "render_all", VALUEFUNC(_wrap_EGameObject_render_all), -1);
20505   rb_define_singleton_method(cEGameObject.klass, "delete_all", VALUEFUNC(_wrap_EGameObject_delete_all), -1);
20506   cEGameObject.mark = 0;
20507   cEGameObject.destroy = (void (*)(void *)) free_eGameObject;
20508   cEGameObject.trackObjects = 0;
20509   
20510   cENetGameObject.klass = rb_define_class_under(mArmagetronad, "ENetGameObject", ((swig_class *) SWIGTYPE_p_eGameObject->clientdata)->klass);
20511   SWIG_TypeClientData(SWIGTYPE_p_eNetGameObject, (void *) &cENetGameObject);
20512   rb_undef_alloc_func(cENetGameObject.klass);
20513   rb_define_method(cENetGameObject.klass, "action_on_quit", VALUEFUNC(_wrap_ENetGameObject_action_on_quit), -1);
20514   rb_define_method(cENetGameObject.klass, "action_on_delete", VALUEFUNC(_wrap_ENetGameObject_action_on_delete), -1);
20515   rb_define_method(cENetGameObject.klass, "init_after_creation", VALUEFUNC(_wrap_ENetGameObject_init_after_creation), -1);
20516   rb_define_method(cENetGameObject.klass, "remove_from_game", VALUEFUNC(_wrap_ENetGameObject_remove_from_game), -1);
20517   rb_define_method(cENetGameObject.klass, "write_create", VALUEFUNC(_wrap_ENetGameObject_write_create), -1);
20518   rb_define_method(cENetGameObject.klass, "write_sync", VALUEFUNC(_wrap_ENetGameObject_write_sync), -1);
20519   rb_define_method(cENetGameObject.klass, "read_sync", VALUEFUNC(_wrap_ENetGameObject_read_sync), -1);
20520   rb_define_method(cENetGameObject.klass, "clear_to_transmit", VALUEFUNC(_wrap_ENetGameObject_clear_to_transmit), -1);
20521   rb_define_method(cENetGameObject.klass, "sync_is_new", VALUEFUNC(_wrap_ENetGameObject_sync_is_new), -1);
20522   rb_define_method(cENetGameObject.klass, "add_ref", VALUEFUNC(_wrap_ENetGameObject_add_ref), -1);
20523   rb_define_method(cENetGameObject.klass, "release", VALUEFUNC(_wrap_ENetGameObject_release), -1);
20524   rb_define_method(cENetGameObject.klass, "send_control", VALUEFUNC(_wrap_ENetGameObject_send_control), -1);
20525   rb_define_method(cENetGameObject.klass, "receive_control", VALUEFUNC(_wrap_ENetGameObject_receive_control), -1);
20526   rb_define_method(cENetGameObject.klass, "timestep", VALUEFUNC(_wrap_ENetGameObject_timestep), -1);
20527   rb_define_method(cENetGameObject.klass, "player", VALUEFUNC(_wrap_ENetGameObject_player), -1);
20528   rb_define_method(cENetGameObject.klass, "clientside_action", VALUEFUNC(_wrap_ENetGameObject_clientside_action), -1);
20529   rb_define_method(cENetGameObject.klass, "lag", VALUEFUNC(_wrap_ENetGameObject_lag), -1);
20530   rb_define_method(cENetGameObject.klass, "lag_threshold", VALUEFUNC(_wrap_ENetGameObject_lag_threshold), -1);
20531   cENetGameObject.mark = 0;
20532   cENetGameObject.trackObjects = 0;
20533   
20534   cESensor.klass = rb_define_class_under(mArmagetronad, "ESensor", ((swig_class *) SWIGTYPE_p_eGameObject->clientdata)->klass);
20535   SWIG_TypeClientData(SWIGTYPE_p_eSensor, (void *) &cESensor);
20536   rb_define_alloc_func(cESensor.klass, _wrap_ESensor_allocate);
20537   rb_define_method(cESensor.klass, "initialize", VALUEFUNC(_wrap_new_ESensor), -1);
20538   rb_define_method(cESensor.klass, "hit=", VALUEFUNC(_wrap_ESensor_hit_set), -1);
20539   rb_define_method(cESensor.klass, "hit", VALUEFUNC(_wrap_ESensor_hit_get), -1);
20540   rb_define_method(cESensor.klass, "ehit=", VALUEFUNC(_wrap_ESensor_ehit_set), -1);
20541   rb_define_method(cESensor.klass, "ehit", VALUEFUNC(_wrap_ESensor_ehit_get), -1);
20542   rb_define_method(cESensor.klass, "lr=", VALUEFUNC(_wrap_ESensor_lr_set), -1);
20543   rb_define_method(cESensor.klass, "lr", VALUEFUNC(_wrap_ESensor_lr_get), -1);
20544   rb_define_method(cESensor.klass, "before_hit=", VALUEFUNC(_wrap_ESensor_before_hit_set), -1);
20545   rb_define_method(cESensor.klass, "before_hit", VALUEFUNC(_wrap_ESensor_before_hit_get), -1);
20546   rb_define_method(cESensor.klass, "pass_edge", VALUEFUNC(_wrap_ESensor_pass_edge), -1);
20547   rb_define_method(cESensor.klass, "detect", VALUEFUNC(_wrap_ESensor_detect), -1);
20548   rb_define_method(cESensor.klass, "set_current_face", VALUEFUNC(_wrap_ESensor_set_current_face), -1);
20549   rb_define_method(cESensor.klass, "set_inverse_speed", VALUEFUNC(_wrap_ESensor_set_inverse_speed), -1);
20550   rb_define_method(cESensor.klass, "get_inverse_speed", VALUEFUNC(_wrap_ESensor_get_inverse_speed), -1);
20551   cESensor.mark = 0;
20552   cESensor.destroy = (void (*)(void *)) free_eSensor;
20553   cESensor.trackObjects = 0;
20554   rb_define_module_function(mArmagetronad, "disown_GSimpleAI", VALUEFUNC(_wrap_disown_GSimpleAI), -1);
20555   
20556   cGSimpleAI.klass = rb_define_class_under(mArmagetronad, "GSimpleAI", rb_cObject);
20557   SWIG_TypeClientData(SWIGTYPE_p_gSimpleAI, (void *) &cGSimpleAI);
20558   rb_define_alloc_func(cGSimpleAI.klass, _wrap_GSimpleAI_allocate);
20559   rb_define_method(cGSimpleAI.klass, "initialize", VALUEFUNC(_wrap_new_GSimpleAI), -1);
20560   rb_define_method(cGSimpleAI.klass, "think", VALUEFUNC(_wrap_GSimpleAI_think), -1);
20561   rb_define_method(cGSimpleAI.klass, "object", VALUEFUNC(_wrap_GSimpleAI_object), -1);
20562   rb_define_method(cGSimpleAI.klass, "set_object", VALUEFUNC(_wrap_GSimpleAI_set_object), -1);
20563   rb_define_protected_method(cGSimpleAI.klass, "do_think", VALUEFUNC(_wrap_GSimpleAI_do_think), -1);
20564   cGSimpleAI.mark = 0;
20565   cGSimpleAI.destroy = (void (*)(void *)) free_gSimpleAI;
20566   cGSimpleAI.trackObjects = 0;
20567   rb_define_module_function(mArmagetronad, "disown_GSimpleAIFactory", VALUEFUNC(_wrap_disown_GSimpleAIFactory), -1);
20568   
20569   cGSimpleAIFactory.klass = rb_define_class_under(mArmagetronad, "GSimpleAIFactory", rb_cObject);
20570   SWIG_TypeClientData(SWIGTYPE_p_gSimpleAIFactory, (void *) &cGSimpleAIFactory);
20571   rb_define_alloc_func(cGSimpleAIFactory.klass, _wrap_GSimpleAIFactory_allocate);
20572   rb_define_method(cGSimpleAIFactory.klass, "initialize", VALUEFUNC(_wrap_new_GSimpleAIFactory), -1);
20573   rb_define_method(cGSimpleAIFactory.klass, "create", VALUEFUNC(_wrap_GSimpleAIFactory_create), -1);
20574   rb_define_singleton_method(cGSimpleAIFactory.klass, "get", VALUEFUNC(_wrap_GSimpleAIFactory_get), -1);
20575   rb_define_singleton_method(cGSimpleAIFactory.klass, "set", VALUEFUNC(_wrap_GSimpleAIFactory_set), -1);
20576   rb_define_protected_method(cGSimpleAIFactory.klass, "do_create", VALUEFUNC(_wrap_GSimpleAIFactory_do_create), -1);
20577   cGSimpleAIFactory.mark = 0;
20578   cGSimpleAIFactory.destroy = (void (*)(void *)) free_gSimpleAIFactory;
20579   cGSimpleAIFactory.trackObjects = 0;
20580   
20581   cGCycleMovement.klass = rb_define_class_under(mArmagetronad, "GCycleMovement", ((swig_class *) SWIGTYPE_p_eNetGameObject->clientdata)->klass);
20582   SWIG_TypeClientData(SWIGTYPE_p_gCycleMovement, (void *) &cGCycleMovement);
20583   rb_undef_alloc_func(cGCycleMovement.klass);
20584   rb_define_singleton_method(cGCycleMovement.klass, "rubber_speed", VALUEFUNC(_wrap_GCycleMovement_rubber_speed), -1);
20585   rb_define_singleton_method(cGCycleMovement.klass, "speed_multiplier", VALUEFUNC(_wrap_GCycleMovement_speed_multiplier), -1);
20586   rb_define_singleton_method(cGCycleMovement.klass, "set_speed_multiplier", VALUEFUNC(_wrap_GCycleMovement_set_speed_multiplier), -1);
20587   rb_define_singleton_method(cGCycleMovement.klass, "maximal_speed", VALUEFUNC(_wrap_GCycleMovement_maximal_speed), -1);
20588   rb_define_method(cGCycleMovement.klass, "winding_number", VALUEFUNC(_wrap_GCycleMovement_winding_number), -1);
20589   rb_define_method(cGCycleMovement.klass, "set_winding_number_wrapped", VALUEFUNC(_wrap_GCycleMovement_set_winding_number_wrapped), -1);
20590   rb_define_method(cGCycleMovement.klass, "direction", VALUEFUNC(_wrap_GCycleMovement_direction), -1);
20591   rb_define_method(cGCycleMovement.klass, "last_direction", VALUEFUNC(_wrap_GCycleMovement_last_direction), -1);
20592   rb_define_method(cGCycleMovement.klass, "speed", VALUEFUNC(_wrap_GCycleMovement_speed), -1);
20593   rb_define_method(cGCycleMovement.klass, "alive", VALUEFUNC(_wrap_GCycleMovement_alive), -1);
20594   rb_define_method(cGCycleMovement.klass, "vulnerable", VALUEFUNC(_wrap_GCycleMovement_vulnerable), -1);
20595   rb_define_method(cGCycleMovement.klass, "spawn_direction", VALUEFUNC(_wrap_GCycleMovement_spawn_direction), -1);
20596   rb_define_method(cGCycleMovement.klass, "can_make_turn", VALUEFUNC(_wrap_GCycleMovement_can_make_turn), -1);
20597   rb_define_method(cGCycleMovement.klass, "get_distance_since_last_turn", VALUEFUNC(_wrap_GCycleMovement_get_distance_since_last_turn), -1);
20598   rb_define_method(cGCycleMovement.klass, "get_turn_delay", VALUEFUNC(_wrap_GCycleMovement_get_turn_delay), -1);
20599   rb_define_method(cGCycleMovement.klass, "get_turn_delay_db", VALUEFUNC(_wrap_GCycleMovement_get_turn_delay_db), -1);
20600   rb_define_method(cGCycleMovement.klass, "get_next_turn", VALUEFUNC(_wrap_GCycleMovement_get_next_turn), -1);
20601   rb_define_method(cGCycleMovement.klass, "advance_destination", VALUEFUNC(_wrap_GCycleMovement_advance_destination), -1);
20602   rb_define_method(cGCycleMovement.klass, "add_destination", VALUEFUNC(_wrap_GCycleMovement_add_destination), -1);
20603   rb_define_method(cGCycleMovement.klass, "get_current_destination", VALUEFUNC(_wrap_GCycleMovement_get_current_destination), -1);
20604   rb_define_method(cGCycleMovement.klass, "notify_new_destination", VALUEFUNC(_wrap_GCycleMovement_notify_new_destination), -1);
20605   rb_define_method(cGCycleMovement.klass, "is_destination_used", VALUEFUNC(_wrap_GCycleMovement_is_destination_used), -1);
20606   rb_define_method(cGCycleMovement.klass, "drop_temp_wall", VALUEFUNC(_wrap_GCycleMovement_drop_temp_wall), -1);
20607   rb_define_method(cGCycleMovement.klass, "edge_is_dangerous", VALUEFUNC(_wrap_GCycleMovement_edge_is_dangerous), -1);
20608   rb_define_method(cGCycleMovement.klass, "turn", VALUEFUNC(_wrap_GCycleMovement_turn), -1);
20609   rb_define_method(cGCycleMovement.klass, "move_safely", VALUEFUNC(_wrap_GCycleMovement_move_safely), -1);
20610   rb_define_method(cGCycleMovement.klass, "timestep", VALUEFUNC(_wrap_GCycleMovement_timestep), -1);
20611   rb_define_method(cGCycleMovement.klass, "next_interesting_time", VALUEFUNC(_wrap_GCycleMovement_next_interesting_time), -1);
20612   rb_define_method(cGCycleMovement.klass, "add_ref", VALUEFUNC(_wrap_GCycleMovement_add_ref), -1);
20613   rb_define_method(cGCycleMovement.klass, "remove_from_game", VALUEFUNC(_wrap_GCycleMovement_remove_from_game), -1);
20614   rb_define_method(cGCycleMovement.klass, "get_max_space_ahead", VALUEFUNC(_wrap_GCycleMovement_get_max_space_ahead), -1);
20615   rb_define_method(cGCycleMovement.klass, "get_distance", VALUEFUNC(_wrap_GCycleMovement_get_distance), -1);
20616   rb_define_method(cGCycleMovement.klass, "get_rubber", VALUEFUNC(_wrap_GCycleMovement_get_rubber), -1);
20617   rb_define_method(cGCycleMovement.klass, "get_turns", VALUEFUNC(_wrap_GCycleMovement_get_turns), -1);
20618   rb_define_method(cGCycleMovement.klass, "get_braking", VALUEFUNC(_wrap_GCycleMovement_get_braking), -1);
20619   rb_define_method(cGCycleMovement.klass, "get_braking_reservoir", VALUEFUNC(_wrap_GCycleMovement_get_braking_reservoir), -1);
20620   rb_define_method(cGCycleMovement.klass, "get_rubber_malus", VALUEFUNC(_wrap_GCycleMovement_get_rubber_malus), -1);
20621   rb_define_singleton_method(cGCycleMovement.klass, "rubber_malus_active", VALUEFUNC(_wrap_GCycleMovement_rubber_malus_active), -1);
20622   rb_define_method(cGCycleMovement.klass, "get_last_turn_pos", VALUEFUNC(_wrap_GCycleMovement_get_last_turn_pos), -1);
20623   rb_define_method(cGCycleMovement.klass, "get_last_turn_time", VALUEFUNC(_wrap_GCycleMovement_get_last_turn_time), -1);
20624   rb_define_method(cGCycleMovement.klass, "get_acceleration", VALUEFUNC(_wrap_GCycleMovement_get_acceleration), -1);
20625   rb_define_method(cGCycleMovement.klass, "set_rubber", VALUEFUNC(_wrap_GCycleMovement_set_rubber), -1);
20626   rb_define_method(cGCycleMovement.klass, "set_braking_reservoir", VALUEFUNC(_wrap_GCycleMovement_set_braking_reservoir), -1);
20627   cGCycleMovement.mark = 0;
20628   cGCycleMovement.destroy = (void (*)(void *)) free_gCycleMovement;
20629   cGCycleMovement.trackObjects = 0;
20630   
20631   cGCycle.klass = rb_define_class_under(mArmagetronad, "GCycle", ((swig_class *) SWIGTYPE_p_gCycleMovement->clientdata)->klass);
20632   SWIG_TypeClientData(SWIGTYPE_p_gCycle, (void *) &cGCycle);
20633   rb_define_alloc_func(cGCycle.klass, _wrap_GCycle_allocate);
20634   rb_define_method(cGCycle.klass, "initialize", VALUEFUNC(_wrap_new_GCycle), -1);
20635   rb_define_method(cGCycle.klass, "lastGoodPosition_=", VALUEFUNC(_wrap_GCycle_lastGoodPosition__set), -1);
20636   rb_define_method(cGCycle.klass, "lastGoodPosition_", VALUEFUNC(_wrap_GCycle_lastGoodPosition__get), -1);
20637   rb_define_method(cGCycle.klass, "skew=", VALUEFUNC(_wrap_GCycle_skew_set), -1);
20638   rb_define_method(cGCycle.klass, "skew", VALUEFUNC(_wrap_GCycle_skew_get), -1);
20639   rb_define_method(cGCycle.klass, "skewDot=", VALUEFUNC(_wrap_GCycle_skewDot_set), -1);
20640   rb_define_method(cGCycle.klass, "skewDot", VALUEFUNC(_wrap_GCycle_skewDot_get), -1);
20641   rb_define_method(cGCycle.klass, "mp=", VALUEFUNC(_wrap_GCycle_mp_set), -1);
20642   rb_define_method(cGCycle.klass, "mp", VALUEFUNC(_wrap_GCycle_mp_get), -1);
20643   rb_define_method(cGCycle.klass, "body=", VALUEFUNC(_wrap_GCycle_body_set), -1);
20644   rb_define_method(cGCycle.klass, "body", VALUEFUNC(_wrap_GCycle_body_get), -1);
20645   rb_define_method(cGCycle.klass, "front=", VALUEFUNC(_wrap_GCycle_front_set), -1);
20646   rb_define_method(cGCycle.klass, "front", VALUEFUNC(_wrap_GCycle_front_get), -1);
20647   rb_define_method(cGCycle.klass, "rear=", VALUEFUNC(_wrap_GCycle_rear_set), -1);
20648   rb_define_method(cGCycle.klass, "rear", VALUEFUNC(_wrap_GCycle_rear_get), -1);
20649   rb_define_method(cGCycle.klass, "customModel=", VALUEFUNC(_wrap_GCycle_customModel_set), -1);
20650   rb_define_method(cGCycle.klass, "customModel", VALUEFUNC(_wrap_GCycle_customModel_get), -1);
20651   rb_define_method(cGCycle.klass, "wheelTex=", VALUEFUNC(_wrap_GCycle_wheelTex_set), -1);
20652   rb_define_method(cGCycle.klass, "wheelTex", VALUEFUNC(_wrap_GCycle_wheelTex_get), -1);
20653   rb_define_method(cGCycle.klass, "bodyTex=", VALUEFUNC(_wrap_GCycle_bodyTex_set), -1);
20654   rb_define_method(cGCycle.klass, "bodyTex", VALUEFUNC(_wrap_GCycle_bodyTex_get), -1);
20655   rb_define_method(cGCycle.klass, "customTexture=", VALUEFUNC(_wrap_GCycle_customTexture_set), -1);
20656   rb_define_method(cGCycle.klass, "customTexture", VALUEFUNC(_wrap_GCycle_customTexture_get), -1);
20657   rb_define_method(cGCycle.klass, "rotationFrontWheel=", VALUEFUNC(_wrap_GCycle_rotationFrontWheel_set), -1);
20658   rb_define_method(cGCycle.klass, "rotationFrontWheel", VALUEFUNC(_wrap_GCycle_rotationFrontWheel_get), -1);
20659   rb_define_method(cGCycle.klass, "rotationRearWheel=", VALUEFUNC(_wrap_GCycle_rotationRearWheel_set), -1);
20660   rb_define_method(cGCycle.klass, "rotationRearWheel", VALUEFUNC(_wrap_GCycle_rotationRearWheel_get), -1);
20661   rb_define_method(cGCycle.klass, "heightFrontWheel=", VALUEFUNC(_wrap_GCycle_heightFrontWheel_set), -1);
20662   rb_define_method(cGCycle.klass, "heightFrontWheel", VALUEFUNC(_wrap_GCycle_heightFrontWheel_get), -1);
20663   rb_define_method(cGCycle.klass, "heightRearWheel=", VALUEFUNC(_wrap_GCycle_heightRearWheel_set), -1);
20664   rb_define_method(cGCycle.klass, "heightRearWheel", VALUEFUNC(_wrap_GCycle_heightRearWheel_get), -1);
20665   rb_define_method(cGCycle.klass, "memory=", VALUEFUNC(_wrap_GCycle_memory_set), -1);
20666   rb_define_method(cGCycle.klass, "memory", VALUEFUNC(_wrap_GCycle_memory_get), -1);
20667   rb_define_method(cGCycle.klass, "color_=", VALUEFUNC(_wrap_GCycle_color__set), -1);
20668   rb_define_method(cGCycle.klass, "color_", VALUEFUNC(_wrap_GCycle_color__get), -1);
20669   rb_define_method(cGCycle.klass, "trailColor_=", VALUEFUNC(_wrap_GCycle_trailColor__set), -1);
20670   rb_define_method(cGCycle.klass, "trailColor_", VALUEFUNC(_wrap_GCycle_trailColor__get), -1);
20671   rb_define_method(cGCycle.klass, "correctPosSmooth=", VALUEFUNC(_wrap_GCycle_correctPosSmooth_set), -1);
20672   rb_define_method(cGCycle.klass, "correctPosSmooth", VALUEFUNC(_wrap_GCycle_correctPosSmooth_get), -1);
20673   rb_define_method(cGCycle.klass, "predictPosition_=", VALUEFUNC(_wrap_GCycle_predictPosition__set), -1);
20674   rb_define_method(cGCycle.klass, "predictPosition_", VALUEFUNC(_wrap_GCycle_predictPosition__get), -1);
20675   rb_define_method(cGCycle.klass, "correctDistanceSmooth=", VALUEFUNC(_wrap_GCycle_correctDistanceSmooth_set), -1);
20676   rb_define_method(cGCycle.klass, "correctDistanceSmooth", VALUEFUNC(_wrap_GCycle_correctDistanceSmooth_get), -1);
20677   rb_define_method(cGCycle.klass, "die", VALUEFUNC(_wrap_GCycle_die), -1);
20678   rb_define_method(cGCycle.klass, "kill_at", VALUEFUNC(_wrap_GCycle_kill_at), -1);
20679   rb_define_method(cGCycle.klass, "winding_number", VALUEFUNC(_wrap_GCycle_winding_number), -1);
20680   rb_define_method(cGCycle.klass, "vulnerable", VALUEFUNC(_wrap_GCycle_vulnerable), -1);
20681   rb_define_method(cGCycle.klass, "init_after_creation", VALUEFUNC(_wrap_GCycle_init_after_creation), -1);
20682   rb_define_singleton_method(cGCycle.klass, "set_walls_stay_up_delay", VALUEFUNC(_wrap_GCycle_set_walls_stay_up_delay), -1);
20683   rb_define_singleton_method(cGCycle.klass, "set_walls_length", VALUEFUNC(_wrap_GCycle_set_walls_length), -1);
20684   rb_define_singleton_method(cGCycle.klass, "set_explosion_radius", VALUEFUNC(_wrap_GCycle_set_explosion_radius), -1);
20685   rb_define_singleton_method(cGCycle.klass, "walls_stay_up_delay", VALUEFUNC(_wrap_GCycle_walls_stay_up_delay), -1);
20686   rb_define_singleton_method(cGCycle.klass, "walls_length", VALUEFUNC(_wrap_GCycle_walls_length), -1);
20687   rb_define_method(cGCycle.klass, "max_walls_length", VALUEFUNC(_wrap_GCycle_max_walls_length), -1);
20688   rb_define_method(cGCycle.klass, "this_walls_length", VALUEFUNC(_wrap_GCycle_this_walls_length), -1);
20689   rb_define_method(cGCycle.klass, "wall_end_speed", VALUEFUNC(_wrap_GCycle_wall_end_speed), -1);
20690   rb_define_singleton_method(cGCycle.klass, "explosion_radius", VALUEFUNC(_wrap_GCycle_explosion_radius), -1);
20691   rb_define_method(cGCycle.klass, "is_me", VALUEFUNC(_wrap_GCycle_is_me), -1);
20692   rb_define_method(cGCycle.klass, "write_create", VALUEFUNC(_wrap_GCycle_write_create), -1);
20693   rb_define_method(cGCycle.klass, "write_sync", VALUEFUNC(_wrap_GCycle_write_sync), -1);
20694   rb_define_method(cGCycle.klass, "read_sync", VALUEFUNC(_wrap_GCycle_read_sync), -1);
20695   rb_define_method(cGCycle.klass, "request_sync_owner", VALUEFUNC(_wrap_GCycle_request_sync_owner), -1);
20696   rb_define_method(cGCycle.klass, "request_sync_all", VALUEFUNC(_wrap_GCycle_request_sync_all), -1);
20697   rb_define_method(cGCycle.klass, "sync_enemy", VALUEFUNC(_wrap_GCycle_sync_enemy), -1);
20698   rb_define_method(cGCycle.klass, "receive_control", VALUEFUNC(_wrap_GCycle_receive_control), -1);
20699   rb_define_method(cGCycle.klass, "print_name", VALUEFUNC(_wrap_GCycle_print_name), -1);
20700   rb_define_method(cGCycle.klass, "action_on_quit", VALUEFUNC(_wrap_GCycle_action_on_quit), -1);
20701   rb_define_method(cGCycle.klass, "creator_descriptor", VALUEFUNC(_wrap_GCycle_creator_descriptor), -1);
20702   rb_define_method(cGCycle.klass, "sync_is_new", VALUEFUNC(_wrap_GCycle_sync_is_new), -1);
20703   rb_define_method(cGCycle.klass, "timestep", VALUEFUNC(_wrap_GCycle_timestep), -1);
20704   rb_define_method(cGCycle.klass, "timestep_core", VALUEFUNC(_wrap_GCycle_timestep_core), -1);
20705   rb_define_method(cGCycle.klass, "interact_with", VALUEFUNC(_wrap_GCycle_interact_with), -1);
20706   rb_define_method(cGCycle.klass, "edge_is_dangerous", VALUEFUNC(_wrap_GCycle_edge_is_dangerous), -1);
20707   rb_define_method(cGCycle.klass, "pass_edge", VALUEFUNC(_wrap_GCycle_pass_edge), -1);
20708   rb_define_method(cGCycle.klass, "pathfinding_modifier", VALUEFUNC(_wrap_GCycle_pathfinding_modifier), -1);
20709   rb_define_method(cGCycle.klass, "act", VALUEFUNC(_wrap_GCycle_act), -1);
20710   rb_define_method(cGCycle.klass, "do_turn", VALUEFUNC(_wrap_GCycle_do_turn), -1);
20711   rb_define_method(cGCycle.klass, "drop_wall", VALUEFUNC(_wrap_GCycle_drop_wall), -1);
20712   rb_define_method(cGCycle.klass, "kill", VALUEFUNC(_wrap_GCycle_kill), -1);
20713   rb_define_method(cGCycle.klass, "edge", VALUEFUNC(_wrap_GCycle_edge), -1);
20714   rb_define_method(cGCycle.klass, "current_wall", VALUEFUNC(_wrap_GCycle_current_wall), -1);
20715   rb_define_method(cGCycle.klass, "cam_pos", VALUEFUNC(_wrap_GCycle_cam_pos), -1);
20716   rb_define_method(cGCycle.klass, "predict_position", VALUEFUNC(_wrap_GCycle_predict_position), -1);
20717   rb_define_method(cGCycle.klass, "cam_top", VALUEFUNC(_wrap_GCycle_cam_top), -1);
20718   rb_define_method(cGCycle.klass, "right_before_death", VALUEFUNC(_wrap_GCycle_right_before_death), -1);
20719   rb_define_singleton_method(cGCycle.klass, "private_settings", VALUEFUNC(_wrap_GCycle_private_settings), -1);
20720   cGCycle.mark = 0;
20721   cGCycle.trackObjects = 0;
20722   rb_define_const(mArmagetronad, "GSENSOR_NONE", SWIG_From_int(static_cast< int >(gSENSOR_NONE)));
20723   rb_define_const(mArmagetronad, "GSENSOR_RIM", SWIG_From_int(static_cast< int >(gSENSOR_RIM)));
20724   rb_define_const(mArmagetronad, "GSENSOR_ENEMY", SWIG_From_int(static_cast< int >(gSENSOR_ENEMY)));
20725   rb_define_const(mArmagetronad, "GSENSOR_TEAMMATE", SWIG_From_int(static_cast< int >(gSENSOR_TEAMMATE)));
20726   rb_define_const(mArmagetronad, "GSENSOR_SELF", SWIG_From_int(static_cast< int >(gSENSOR_SELF)));
20727   
20728   cGSensor.klass = rb_define_class_under(mArmagetronad, "GSensor", ((swig_class *) SWIGTYPE_p_eSensor->clientdata)->klass);
20729   SWIG_TypeClientData(SWIGTYPE_p_gSensor, (void *) &cGSensor);
20730   rb_define_alloc_func(cGSensor.klass, _wrap_GSensor_allocate);
20731   rb_define_method(cGSensor.klass, "initialize", VALUEFUNC(_wrap_new_GSensor), -1);
20732   rb_define_method(cGSensor.klass, "type=", VALUEFUNC(_wrap_GSensor_type_set), -1);
20733   rb_define_method(cGSensor.klass, "type", VALUEFUNC(_wrap_GSensor_type_get), -1);
20734   rb_define_method(cGSensor.klass, "pass_edge", VALUEFUNC(_wrap_GSensor_pass_edge), -1);
20735   cGSensor.mark = 0;
20736   cGSensor.destroy = (void (*)(void *)) free_gSensor;
20737   cGSensor.trackObjects = 0;
20738 }
20739
Generated on Sat Mar 15 22:55:55 2008 for Armagetron Advanced by  doxygen 1.5.4