# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_kiki', [dirname(__file__)])
        except ImportError:
            import _kiki
            return _kiki
        if fp is not None:
            try:
                _mod = imp.load_module('_kiki', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _kiki = swig_import_helper()
    del swig_import_helper
else:
    import _kiki
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


class KikiPos(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiPos, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KikiPos, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _kiki.KikiPos_x_set
    __swig_getmethods__["x"] = _kiki.KikiPos_x_get
    if _newclass:x = _swig_property(_kiki.KikiPos_x_get, _kiki.KikiPos_x_set)
    __swig_setmethods__["y"] = _kiki.KikiPos_y_set
    __swig_getmethods__["y"] = _kiki.KikiPos_y_get
    if _newclass:y = _swig_property(_kiki.KikiPos_y_get, _kiki.KikiPos_y_set)
    __swig_setmethods__["z"] = _kiki.KikiPos_z_set
    __swig_getmethods__["z"] = _kiki.KikiPos_z_get
    if _newclass:z = _swig_property(_kiki.KikiPos_z_get, _kiki.KikiPos_z_set)
    def __init__(self, *args): 
        this = _kiki.new_KikiPos(*args)
        try: self.this.append(this)
        except: self.this = this
    def __sub__(self, *args): return _kiki.KikiPos___sub__(self, *args)
    def __add__(self, *args): return _kiki.KikiPos___add__(self, *args)
    def __iadd__(self, *args): return _kiki.KikiPos___iadd__(self, *args)
    def __isub__(self, *args): return _kiki.KikiPos___isub__(self, *args)
    def getString(self): return _kiki.KikiPos_getString(self)
    def __eq__(self, *args): return _kiki.KikiPos___eq__(self, *args)
    def __ne__(self, *args): return _kiki.KikiPos___ne__(self, *args)
    def __str__(self): return _kiki.KikiPos___str__(self)
    __swig_destroy__ = _kiki.delete_KikiPos
    __del__ = lambda self : None;
KikiPos_swigregister = _kiki.KikiPos_swigregister
KikiPos_swigregister(KikiPos)

class KVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KVector, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def reset(self): return _kiki.KVector_reset(self)
    def normalize(self): return _kiki.KVector_normalize(self)
    def __iadd__(self, *args): return _kiki.KVector___iadd__(self, *args)
    def __isub__(self, *args): return _kiki.KVector___isub__(self, *args)
    def __imul__(self, *args): return _kiki.KVector___imul__(self, *args)
    def __idiv__(self, *args): return _kiki.KVector___idiv__(self, *args)
    def cross(self, *args): return _kiki.KVector_cross(self, *args)
    def __sub__(self, *args): return _kiki.KVector___sub__(self, *args)
    def __add__(self, *args): return _kiki.KVector___add__(self, *args)
    def __mul__(self, *args): return _kiki.KVector___mul__(self, *args)
    def __div__(self, *args): return _kiki.KVector___div__(self, *args)
    def perpendicular(self, *args): return _kiki.KVector_perpendicular(self, *args)
    def parallel(self, *args): return _kiki.KVector_parallel(self, *args)
    def reflect(self, *args): return _kiki.KVector_reflect(self, *args)
    def normal(self): return _kiki.KVector_normal(self)
    def length(self): return _kiki.KVector_length(self)
    def angle(self, *args): return _kiki.KVector_angle(self, *args)
    def xyangle(self, *args): return _kiki.KVector_xyangle(self, *args)
    def xyperp(self): return _kiki.KVector_xyperp(self)
    def round(self): return _kiki.KVector_round(self)
    def glVertex(self): return _kiki.KVector_glVertex(self)
    def __getitem__(self, *args): return _kiki.KVector___getitem__(self, *args)
    def __str__(self): return _kiki.KVector___str__(self)
    __swig_destroy__ = _kiki.delete_KVector
    __del__ = lambda self : None;
KVector_swigregister = _kiki.KVector_swigregister
KVector_swigregister(KVector)

class KQuaternion(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KQuaternion, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KQuaternion, name)
    __repr__ = _swig_repr
    __swig_setmethods__["w"] = _kiki.KQuaternion_w_set
    __swig_getmethods__["w"] = _kiki.KQuaternion_w_get
    if _newclass:w = _swig_property(_kiki.KQuaternion_w_get, _kiki.KQuaternion_w_set)
    __swig_setmethods__["x"] = _kiki.KQuaternion_x_set
    __swig_getmethods__["x"] = _kiki.KQuaternion_x_get
    if _newclass:x = _swig_property(_kiki.KQuaternion_x_get, _kiki.KQuaternion_x_set)
    __swig_setmethods__["y"] = _kiki.KQuaternion_y_set
    __swig_getmethods__["y"] = _kiki.KQuaternion_y_get
    if _newclass:y = _swig_property(_kiki.KQuaternion_y_get, _kiki.KQuaternion_y_set)
    __swig_setmethods__["z"] = _kiki.KQuaternion_z_set
    __swig_getmethods__["z"] = _kiki.KQuaternion_z_get
    if _newclass:z = _swig_property(_kiki.KQuaternion_z_get, _kiki.KQuaternion_z_set)
    def __init__(self, *args): 
        this = _kiki.new_KQuaternion(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["rotationAroundVector"] = lambda x: _kiki.KQuaternion_rotationAroundVector
    if _newclass:rotationAroundVector = staticmethod(_kiki.KQuaternion_rotationAroundVector)
    def rotate(self, *args): return _kiki.KQuaternion_rotate(self, *args)
    def normalize(self): return _kiki.KQuaternion_normalize(self)
    def invert(self): return _kiki.KQuaternion_invert(self)
    def conjugate(self): return _kiki.KQuaternion_conjugate(self)
    def getNormal(self): return _kiki.KQuaternion_getNormal(self)
    def getConjugate(self): return _kiki.KQuaternion_getConjugate(self)
    def getInverse(self): return _kiki.KQuaternion_getInverse(self)
    def length(self): return _kiki.KQuaternion_length(self)
    def glRotate(self): return _kiki.KQuaternion_glRotate(self)
    def slerp(self, *args): return _kiki.KQuaternion_slerp(self, *args)
    def __mul__(self, *args): return _kiki.KQuaternion___mul__(self, *args)
    def __str__(self): return _kiki.KQuaternion___str__(self)
    __swig_destroy__ = _kiki.delete_KQuaternion
    __del__ = lambda self : None;
KQuaternion_swigregister = _kiki.KQuaternion_swigregister
KQuaternion_swigregister(KQuaternion)

def KQuaternion_rotationAroundVector(*args):
  return _kiki.KQuaternion_rotationAroundVector(*args)
KQuaternion_rotationAroundVector = _kiki.KQuaternion_rotationAroundVector

class KColor(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KColor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KColor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KColor(*args)
        try: self.this.append(this)
        except: self.this = this
    def setValues(self, *args): return _kiki.KColor_setValues(self, *args)
    def setRed(self, *args): return _kiki.KColor_setRed(self, *args)
    def setGreen(self, *args): return _kiki.KColor_setGreen(self, *args)
    def setBlue(self, *args): return _kiki.KColor_setBlue(self, *args)
    def setAlpha(self, *args): return _kiki.KColor_setAlpha(self, *args)
    def getRed(self): return _kiki.KColor_getRed(self)
    def getGreen(self): return _kiki.KColor_getGreen(self)
    def getBlue(self): return _kiki.KColor_getBlue(self)
    def getAlpha(self): return _kiki.KColor_getAlpha(self)
    def glColor(self): return _kiki.KColor_glColor(self)
    def __str__(self): return _kiki.KColor___str__(self)
    __swig_destroy__ = _kiki.delete_KColor
    __del__ = lambda self : None;
KColor_swigregister = _kiki.KColor_swigregister
KColor_swigregister(KColor)

class KProjection(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KProjection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KProjection, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def focusOn(self, *args): return _kiki.KProjection_focusOn(self, *args)
    def setFov(self, *args): return _kiki.KProjection_setFov(self, *args)
    def getFov(self): return _kiki.KProjection_getFov(self)
    def setViewport(self, *args): return _kiki.KProjection_setViewport(self, *args)
    def setPosition(self, *args): return _kiki.KProjection_setPosition(self, *args)
KProjection_swigregister = _kiki.KProjection_swigregister
KProjection_swigregister(KProjection)

class KKey(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KKey, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KKey, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KKey(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_setmethods__["name"] = _kiki.KKey_name_set
    __swig_getmethods__["name"] = _kiki.KKey_name_get
    if _newclass:name = _swig_property(_kiki.KKey_name_get, _kiki.KKey_name_set)
    def getUnmodifiedName(self): return _kiki.KKey_getUnmodifiedName(self)
    def getModifierName(self): return _kiki.KKey_getModifierName(self)
KKey_swigregister = _kiki.KKey_swigregister
KKey_swigregister(KKey)

class KikiAction(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiAction, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KikiAction, name)
    __repr__ = _swig_repr
    ONCE = _kiki.KikiAction_ONCE
    CONTINUOUS = _kiki.KikiAction_CONTINUOUS
    REPEAT = _kiki.KikiAction_REPEAT
    def __init__(self, *args): 
        this = _kiki.new_KikiAction(*args)
        try: self.this.append(this)
        except: self.this = this
    def getId(self): return _kiki.KikiAction_getId(self)
    def getName(self): return _kiki.KikiAction_getName(self)
    def getRelativeTime(self): return _kiki.KikiAction_getRelativeTime(self)
    def getRelativeDelta(self): return _kiki.KikiAction_getRelativeDelta(self)
    def getDuration(self): return _kiki.KikiAction_getDuration(self)
    def setDuration(self, *args): return _kiki.KikiAction_setDuration(self, *args)
KikiAction_swigregister = _kiki.KikiAction_swigregister
KikiAction_swigregister(KikiAction)

class KikiPyAction(KikiAction):
    __swig_setmethods__ = {}
    for _s in [KikiAction]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiPyAction, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiAction]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiPyAction, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KikiPyAction(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _kiki.delete_KikiPyAction
    __del__ = lambda self : None;
    def __init__(self,*args):
        self.this = apply (_kiki.new_KikiPyAction, (self,) + args)
        self.thisown = 1

KikiPyAction_swigregister = _kiki.KikiPyAction_swigregister
KikiPyAction_swigregister(KikiPyAction)

class KikiEvent(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiEvent, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KikiEvent, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KikiEvent(*args)
        try: self.this.append(this)
        except: self.this = this
    def addAction(self, *args): return _kiki.KikiEvent_addAction(self, *args)
    def removeAction(self, *args): return _kiki.KikiEvent_removeAction(self, *args)
    def removeAllActions(self): return _kiki.KikiEvent_removeAllActions(self)
    def removeActionsOfObject(self, *args): return _kiki.KikiEvent_removeActionsOfObject(self, *args)
    def removeActionWithName(self, *args): return _kiki.KikiEvent_removeActionWithName(self, *args)
    def triggerActions(self): return _kiki.KikiEvent_triggerActions(self)
    def getTime(self): return _kiki.KikiEvent_getTime(self)
KikiEvent_swigregister = _kiki.KikiEvent_swigregister
KikiEvent_swigregister(KikiEvent)

class KikiActionObject(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiActionObject, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KikiActionObject, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def addAction(self, *args): return _kiki.KikiActionObject_addAction(self, *args)
    def removeAction(self, *args): return _kiki.KikiActionObject_removeAction(self, *args)
    def startTimedAction(self, *args): return _kiki.KikiActionObject_startTimedAction(self, *args)
    def startTimer(self, *args): return _kiki.KikiActionObject_startTimer(self, *args)
    def getActionWithName(self, *args): return _kiki.KikiActionObject_getActionWithName(self, *args)
    def getActionWithId(self, *args): return _kiki.KikiActionObject_getActionWithId(self, *args)
    def addEventWithName(self, *args): return _kiki.KikiActionObject_addEventWithName(self, *args)
    def getEventWithName(self, *args): return _kiki.KikiActionObject_getEventWithName(self, *args)
    def getEventWithId(self, *args): return _kiki.KikiActionObject_getEventWithId(self, *args)
    def getClassName(self): return _kiki.KikiActionObject_getClassName(self)
KikiActionObject_swigregister = _kiki.KikiActionObject_swigregister
KikiActionObject_swigregister(KikiActionObject)

class KikiObject(KikiActionObject):
    __swig_setmethods__ = {}
    for _s in [KikiActionObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiObject, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiActionObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiObject, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def setName(self, *args): return _kiki.KikiObject_setName(self, *args)
    def getName(self): return _kiki.KikiObject_getName(self)
    def getPos(self): return _kiki.KikiObject_getPos(self)
    def setPosition(self, *args): return _kiki.KikiObject_setPosition(self, *args)
    def getPosition(self): return _kiki.KikiObject_getPosition(self)
    def setOrientation(self, *args): return _kiki.KikiObject_setOrientation(self, *args)
    def getOrientation(self): return _kiki.KikiObject_getOrientation(self)
    def setCurrentOrientation(self, *args): return _kiki.KikiObject_setCurrentOrientation(self, *args)
    def getCurrentOrientation(self): return _kiki.KikiObject_getCurrentOrientation(self)
    def isSpaceEgoistic(self): return _kiki.KikiObject_isSpaceEgoistic(self)
    def getClassName(self): return _kiki.KikiObject_getClassName(self)
KikiObject_swigregister = _kiki.KikiObject_swigregister
KikiObject_swigregister(KikiObject)

class KikiBotStatus(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiBotStatus, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KikiBotStatus, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getMoves(self): return _kiki.KikiBotStatus_getMoves(self)
    def setMoves(self, *args): return _kiki.KikiBotStatus_setMoves(self, *args)
    def addMoves(self, *args): return _kiki.KikiBotStatus_addMoves(self, *args)
    def getMinMoves(self): return _kiki.KikiBotStatus_getMinMoves(self)
    def setMinMoves(self, *args): return _kiki.KikiBotStatus_setMinMoves(self, *args)
KikiBotStatus_swigregister = _kiki.KikiBotStatus_swigregister
KikiBotStatus_swigregister(KikiBotStatus)

class KikiBotFume(KikiObject):
    __swig_setmethods__ = {}
    for _s in [KikiObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiBotFume, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiBotFume, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiBotFume_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiBotFume_setObjectColor)
KikiBotFume_swigregister = _kiki.KikiBotFume_swigregister
KikiBotFume_swigregister(KikiBotFume)

def KikiBotFume_setObjectColor(*args):
  return _kiki.KikiBotFume_setObjectColor(*args)
KikiBotFume_setObjectColor = _kiki.KikiBotFume_setObjectColor

class KikiBot(KikiObject):
    __swig_setmethods__ = {}
    for _s in [KikiObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiBot, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiBot, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def isDead(self): return _kiki.KikiBot_isDead(self)
    def getDown(self): return _kiki.KikiBot_getDown(self)
    def getUp(self): return _kiki.KikiBot_getUp(self)
    def getDir(self): return _kiki.KikiBot_getDir(self)
    def setMove(self, *args): return _kiki.KikiBot_setMove(self, *args)
    def getStatus(self): return _kiki.KikiBot_getStatus(self)
KikiBot_swigregister = _kiki.KikiBot_swigregister
KikiBot_swigregister(KikiBot)

class KikiStatusDisplay(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiStatusDisplay, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KikiStatusDisplay, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def show(self): return _kiki.KikiStatusDisplay_show(self)
    def hide(self): return _kiki.KikiStatusDisplay_hide(self)
KikiStatusDisplay_swigregister = _kiki.KikiStatusDisplay_swigregister
KikiStatusDisplay_swigregister(KikiStatusDisplay)

class KikiPlayback(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiPlayback, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KikiPlayback, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["start"] = lambda x: _kiki.KikiPlayback_start
    if _newclass:start = staticmethod(_kiki.KikiPlayback_start)
    __swig_getmethods__["stop"] = lambda x: _kiki.KikiPlayback_stop
    if _newclass:stop = staticmethod(_kiki.KikiPlayback_stop)
KikiPlayback_swigregister = _kiki.KikiPlayback_swigregister
KikiPlayback_swigregister(KikiPlayback)

def KikiPlayback_start(*args):
  return _kiki.KikiPlayback_start(*args)
KikiPlayback_start = _kiki.KikiPlayback_start

def KikiPlayback_stop():
  return _kiki.KikiPlayback_stop()
KikiPlayback_stop = _kiki.KikiPlayback_stop

class KikiPlayer(KikiBot):
    __swig_setmethods__ = {}
    for _s in [KikiBot]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiPlayer, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiBot]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiPlayer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def die(self): return _kiki.KikiPlayer_die(self)
    def reborn(self): return _kiki.KikiPlayer_reborn(self)
    def reset(self): return _kiki.KikiPlayer_reset(self)
    def startRecorder(self, *args): return _kiki.KikiPlayer_startRecorder(self, *args)
    def saveRecorder(self): return _kiki.KikiPlayer_saveRecorder(self)
    def getProjection(self): return _kiki.KikiPlayer_getProjection(self)
    def handleKey(self, *args): return _kiki.KikiPlayer_handleKey(self, *args)
    def handleKeyRelease(self, *args): return _kiki.KikiPlayer_handleKeyRelease(self, *args)
    def recordKeyForAction(self, *args): return _kiki.KikiPlayer_recordKeyForAction(self, *args)
    __swig_getmethods__["getActionForKey"] = lambda x: _kiki.KikiPlayer_getActionForKey
    if _newclass:getActionForKey = staticmethod(_kiki.KikiPlayer_getActionForKey)
    __swig_getmethods__["getKeyForAction"] = lambda x: _kiki.KikiPlayer_getKeyForAction
    if _newclass:getKeyForAction = staticmethod(_kiki.KikiPlayer_getKeyForAction)
    __swig_getmethods__["setKeyForAction"] = lambda x: _kiki.KikiPlayer_setKeyForAction
    if _newclass:setKeyForAction = staticmethod(_kiki.KikiPlayer_setKeyForAction)
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiPlayer_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiPlayer_setObjectColor)
KikiPlayer_swigregister = _kiki.KikiPlayer_swigregister
KikiPlayer_swigregister(KikiPlayer)

def KikiPlayer_getActionForKey(*args):
  return _kiki.KikiPlayer_getActionForKey(*args)
KikiPlayer_getActionForKey = _kiki.KikiPlayer_getActionForKey

def KikiPlayer_getKeyForAction(*args):
  return _kiki.KikiPlayer_getKeyForAction(*args)
KikiPlayer_getKeyForAction = _kiki.KikiPlayer_getKeyForAction

def KikiPlayer_setKeyForAction(*args):
  return _kiki.KikiPlayer_setKeyForAction(*args)
KikiPlayer_setKeyForAction = _kiki.KikiPlayer_setKeyForAction

def KikiPlayer_setObjectColor(*args):
  return _kiki.KikiPlayer_setObjectColor(*args)
KikiPlayer_setObjectColor = _kiki.KikiPlayer_setObjectColor

class KikiMutant(KikiBot):
    __swig_setmethods__ = {}
    for _s in [KikiBot]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiMutant, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiBot]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiMutant, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _kiki.new_KikiMutant()
        try: self.this.append(this)
        except: self.this = this
    def die(self): return _kiki.KikiMutant_die(self)
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiMutant_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiMutant_setObjectColor)
KikiMutant_swigregister = _kiki.KikiMutant_swigregister
KikiMutant_swigregister(KikiMutant)

def KikiMutant_setObjectColor(*args):
  return _kiki.KikiMutant_setObjectColor(*args)
KikiMutant_setObjectColor = _kiki.KikiMutant_setObjectColor

class KikiSound(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiSound, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KikiSound, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def toggleMute(self): return _kiki.KikiSound_toggleMute(self)
    def setMute(self, *args): return _kiki.KikiSound_setMute(self, *args)
    def isMute(self): return _kiki.KikiSound_isMute(self)
    def setSoundVolume(self, *args): return _kiki.KikiSound_setSoundVolume(self, *args)
    def getSoundVolume(self): return _kiki.KikiSound_getSoundVolume(self)
    def playSound(self, *args): return _kiki.KikiSound_playSound(self, *args)
    def playSoundAtPos(self, *args): return _kiki.KikiSound_playSoundAtPos(self, *args)
KikiSound_swigregister = _kiki.KikiSound_swigregister
KikiSound_swigregister(KikiSound)

class KikiWorld(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiWorld, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KikiWorld, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    CAMERA_INSIDE = _kiki.KikiWorld_CAMERA_INSIDE
    CAMERA_BEHIND = _kiki.KikiWorld_CAMERA_BEHIND
    CAMERA_FOLLOW = _kiki.KikiWorld_CAMERA_FOLLOW
    def setSize(self, *args): return _kiki.KikiWorld_setSize(self, *args)
    def getSize(self): return _kiki.KikiWorld_getSize(self)
    def setName(self, *args): return _kiki.KikiWorld_setName(self, *args)
    def getName(self): return _kiki.KikiWorld_getName(self)
    def init(self): return _kiki.KikiWorld_init(self)
    def setDisplayShadows(self, *args): return _kiki.KikiWorld_setDisplayShadows(self, *args)
    def setDisplayRaster(self, *args): return _kiki.KikiWorld_setDisplayRaster(self, *args)
    def setDisplayBorder(self, *args): return _kiki.KikiWorld_setDisplayBorder(self, *args)
    def setRasterSize(self, *args): return _kiki.KikiWorld_setRasterSize(self, *args)
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiWorld_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiWorld_setObjectColor)
    def changeCameraMode(self): return _kiki.KikiWorld_changeCameraMode(self)
    def getCameraMode(self): return _kiki.KikiWorld_getCameraMode(self)
    def setCameraMode(self, *args): return _kiki.KikiWorld_setCameraMode(self, *args)
    def getProjection(self): return _kiki.KikiWorld_getProjection(self)
    def addObjectAtPos(self, *args): return _kiki.KikiWorld_addObjectAtPos(self, *args)
    def setObjectAtPos(self, *args): return _kiki.KikiWorld_setObjectAtPos(self, *args)
    def unsetObject(self, *args): return _kiki.KikiWorld_unsetObject(self, *args)
    def removeObject(self, *args): return _kiki.KikiWorld_removeObject(self, *args)
    def deleteObject(self, *args): return _kiki.KikiWorld_deleteObject(self, *args)
    def deleteAllObjects(self): return _kiki.KikiWorld_deleteAllObjects(self)
    def deleteObjectsWithClassName(self, *args): return _kiki.KikiWorld_deleteObjectsWithClassName(self, *args)
    def getObjectWithName(self, *args): return _kiki.KikiWorld_getObjectWithName(self, *args)
    def moveObjectToPos(self, *args): return _kiki.KikiWorld_moveObjectToPos(self, *args)
    def objectWillMoveToPos(self, *args): return _kiki.KikiWorld_objectWillMoveToPos(self, *args)
    def objectMovedFromPos(self, *args): return _kiki.KikiWorld_objectMovedFromPos(self, *args)
    def getBotAtPos(self, *args): return _kiki.KikiWorld_getBotAtPos(self, *args)
    def getOccupantAtPos(self, *args): return _kiki.KikiWorld_getOccupantAtPos(self, *args)
    def getRealOccupantAtPos(self, *args): return _kiki.KikiWorld_getRealOccupantAtPos(self, *args)
    def getNearestValidPos(self, *args): return _kiki.KikiWorld_getNearestValidPos(self, *args)
    def isInvalidPos(self, *args): return _kiki.KikiWorld_isInvalidPos(self, *args)
    def isValidPos(self, *args): return _kiki.KikiWorld_isValidPos(self, *args)
    def isUnoccupiedPos(self, *args): return _kiki.KikiWorld_isUnoccupiedPos(self, *args)
    def isOccupiedPos(self, *args): return _kiki.KikiWorld_isOccupiedPos(self, *args)
    def posToIndex(self, *args): return _kiki.KikiWorld_posToIndex(self, *args)
    def indexToPos(self, *args): return _kiki.KikiWorld_indexToPos(self, *args)
    def getPickedPos(self): return _kiki.KikiWorld_getPickedPos(self)
KikiWorld_swigregister = _kiki.KikiWorld_swigregister
KikiWorld_swigregister(KikiWorld)

def KikiWorld_setObjectColor(*args):
  return _kiki.KikiWorld_setObjectColor(*args)
KikiWorld_setObjectColor = _kiki.KikiWorld_setObjectColor

class KEventHandler(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KEventHandler, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KEventHandler, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def quit(self): return _kiki.KEventHandler_quit(self)
    __swig_getmethods__["getMouseState"] = lambda x: _kiki.KEventHandler_getMouseState
    if _newclass:getMouseState = staticmethod(_kiki.KEventHandler_getMouseState)
    __swig_getmethods__["getMousePos"] = lambda x: _kiki.KEventHandler_getMousePos
    if _newclass:getMousePos = staticmethod(_kiki.KEventHandler_getMousePos)
    __swig_getmethods__["getMouseDelta"] = lambda x: _kiki.KEventHandler_getMouseDelta
    if _newclass:getMouseDelta = staticmethod(_kiki.KEventHandler_getMouseDelta)
    __swig_getmethods__["getScreenSize"] = lambda x: _kiki.KEventHandler_getScreenSize
    if _newclass:getScreenSize = staticmethod(_kiki.KEventHandler_getScreenSize)
    __swig_getmethods__["setScreenSize"] = lambda x: _kiki.KEventHandler_setScreenSize
    if _newclass:setScreenSize = staticmethod(_kiki.KEventHandler_setScreenSize)
    __swig_getmethods__["getFullscreen"] = lambda x: _kiki.KEventHandler_getFullscreen
    if _newclass:getFullscreen = staticmethod(_kiki.KEventHandler_getFullscreen)
    __swig_getmethods__["setFullscreen"] = lambda x: _kiki.KEventHandler_setFullscreen
    if _newclass:setFullscreen = staticmethod(_kiki.KEventHandler_setFullscreen)
    __swig_getmethods__["getTime"] = lambda x: _kiki.KEventHandler_getTime
    if _newclass:getTime = staticmethod(_kiki.KEventHandler_getTime)
    def setWireframeMode(self, *args): return _kiki.KEventHandler_setWireframeMode(self, *args)
    def setDisplayFps(self, *args): return _kiki.KEventHandler_setDisplayFps(self, *args)
    def getDisplayFps(self): return _kiki.KEventHandler_getDisplayFps(self)
KEventHandler_swigregister = _kiki.KEventHandler_swigregister
KEventHandler_swigregister(KEventHandler)

def KEventHandler_getMouseState():
  return _kiki.KEventHandler_getMouseState()
KEventHandler_getMouseState = _kiki.KEventHandler_getMouseState

def KEventHandler_getMousePos():
  return _kiki.KEventHandler_getMousePos()
KEventHandler_getMousePos = _kiki.KEventHandler_getMousePos

def KEventHandler_getMouseDelta():
  return _kiki.KEventHandler_getMouseDelta()
KEventHandler_getMouseDelta = _kiki.KEventHandler_getMouseDelta

def KEventHandler_getScreenSize():
  return _kiki.KEventHandler_getScreenSize()
KEventHandler_getScreenSize = _kiki.KEventHandler_getScreenSize

def KEventHandler_setScreenSize(*args):
  return _kiki.KEventHandler_setScreenSize(*args)
KEventHandler_setScreenSize = _kiki.KEventHandler_setScreenSize

def KEventHandler_getFullscreen():
  return _kiki.KEventHandler_getFullscreen()
KEventHandler_getFullscreen = _kiki.KEventHandler_getFullscreen

def KEventHandler_setFullscreen(*args):
  return _kiki.KEventHandler_setFullscreen(*args)
KEventHandler_setFullscreen = _kiki.KEventHandler_setFullscreen

def KEventHandler_getTime():
  return _kiki.KEventHandler_getTime()
KEventHandler_getTime = _kiki.KEventHandler_getTime

class KikiController(KEventHandler,KikiActionObject):
    __swig_setmethods__ = {}
    for _s in [KEventHandler,KikiActionObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiController, name, value)
    __swig_getmethods__ = {}
    for _s in [KEventHandler,KikiActionObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiController, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["gui"] = _kiki.KikiController_gui_set
    __swig_getmethods__["gui"] = _kiki.KikiController_gui_get
    if _newclass:gui = _swig_property(_kiki.KikiController_gui_get, _kiki.KikiController_gui_set)
    __swig_setmethods__["sound"] = _kiki.KikiController_sound_set
    __swig_getmethods__["sound"] = _kiki.KikiController_sound_get
    if _newclass:sound = _swig_property(_kiki.KikiController_sound_get, _kiki.KikiController_sound_set)
    __swig_setmethods__["world"] = _kiki.KikiController_world_set
    __swig_getmethods__["world"] = _kiki.KikiController_world_get
    if _newclass:world = _swig_property(_kiki.KikiController_world_get, _kiki.KikiController_world_set)
    __swig_setmethods__["player"] = _kiki.KikiController_player_set
    __swig_getmethods__["player"] = _kiki.KikiController_player_get
    if _newclass:player = _swig_property(_kiki.KikiController_player_get, _kiki.KikiController_player_set)
    __swig_setmethods__["python"] = _kiki.KikiController_python_set
    __swig_getmethods__["python"] = _kiki.KikiController_python_get
    if _newclass:python = _swig_property(_kiki.KikiController_python_get, _kiki.KikiController_python_set)
    __swig_setmethods__["player_status"] = _kiki.KikiController_player_status_set
    __swig_getmethods__["player_status"] = _kiki.KikiController_player_status_get
    if _newclass:player_status = _swig_property(_kiki.KikiController_player_status_get, _kiki.KikiController_player_status_set)
    __swig_setmethods__["timer_event"] = _kiki.KikiController_timer_event_set
    __swig_getmethods__["timer_event"] = _kiki.KikiController_timer_event_get
    if _newclass:timer_event = _swig_property(_kiki.KikiController_timer_event_get, _kiki.KikiController_timer_event_set)
    def getPlayer(self): return _kiki.KikiController_getPlayer(self)
    def unmapMsTime(self, *args): return _kiki.KikiController_unmapMsTime(self, *args)
    def mapMsTime(self, *args): return _kiki.KikiController_mapMsTime(self, *args)
    def setSpeed(self, *args): return _kiki.KikiController_setSpeed(self, *args)
    def getSpeed(self): return _kiki.KikiController_getSpeed(self)
    def getKikiHome(self): return _kiki.KikiController_getKikiHome(self)
    def setGamma(self, *args): return _kiki.KikiController_setGamma(self, *args)
    def getGamma(self): return _kiki.KikiController_getGamma(self)
    def changeScreenSize(self, *args): return _kiki.KikiController_changeScreenSize(self, *args)
    def displayText(self, *args): return _kiki.KikiController_displayText(self, *args)
    def getLocalizedString(self, *args): return _kiki.KikiController_getLocalizedString(self, *args)
    def isDebugVersion(self): return _kiki.KikiController_isDebugVersion(self)
KikiController_swigregister = _kiki.KikiController_swigregister
KikiController_swigregister(KikiController)


def replaceTabs(*args):
  return _kiki.replaceTabs(*args)
replaceTabs = _kiki.replaceTabs
class KWindow(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KWindow, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KWindow, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def isVisible(self): return _kiki.KWindow_isVisible(self)
    def setVisibility(self, *args): return _kiki.KWindow_setVisibility(self, *args)
    def toggleVisibility(self): return _kiki.KWindow_toggleVisibility(self)
    def maximize(self): return _kiki.KWindow_maximize(self)
    def show(self): return _kiki.KWindow_show(self)
    def hide(self): return _kiki.KWindow_hide(self)
    def close(self): return _kiki.KWindow_close(self)
    def setSize(self, *args): return _kiki.KWindow_setSize(self, *args)
    def setPosition(self, *args): return _kiki.KWindow_setPosition(self, *args)
KWindow_swigregister = _kiki.KWindow_swigregister
KWindow_swigregister(KWindow)
kiki = _kiki.kiki

class KikiText(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiText, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KikiText, name)
    __repr__ = _swig_repr
    base_color = _kiki.KikiText_base_color
    bright_color = _kiki.KikiText_bright_color
    dark_color = _kiki.KikiText_dark_color
    def __init__(self, arg0 = "", center = True, colorIndex = 0): 
        this = _kiki.new_KikiText(arg0, center, colorIndex)
        try: self.this.append(this)
        except: self.this = this
    def setText(self, *args): return _kiki.KikiText_setText(self, *args)
    def getText(self): return _kiki.KikiText_getText(self)
    def clear(self): return _kiki.KikiText_clear(self)
    def isEmpty(self): return _kiki.KikiText_isEmpty(self)
    def addText(self, *args): return _kiki.KikiText_addText(self, *args)
    def getColor(self): return _kiki.KikiText_getColor(self)
    def setColor(self, *args): return _kiki.KikiText_setColor(self, *args)
    def setAlpha(self, *args): return _kiki.KikiText_setAlpha(self, *args)
    def isAnimated(self): return _kiki.KikiText_isAnimated(self)
    def setAnimated(self, *args): return _kiki.KikiText_setAnimated(self, *args)
    def isCentered(self): return _kiki.KikiText_isCentered(self)
    def setCentered(self, *args): return _kiki.KikiText_setCentered(self, *args)
    def getWidth(self): return _kiki.KikiText_getWidth(self)
    def getHeight(self): return _kiki.KikiText_getHeight(self)
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiText_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiText_setObjectColor)
KikiText_swigregister = _kiki.KikiText_swigregister
KikiText_swigregister(KikiText)

def KikiText_setObjectColor(*args):
  return _kiki.KikiText_setObjectColor(*args)
KikiText_setObjectColor = _kiki.KikiText_setObjectColor

class KikiGUI(KWindow):
    __swig_setmethods__ = {}
    for _s in [KWindow]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiGUI, name, value)
    __swig_getmethods__ = {}
    for _s in [KWindow]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiGUI, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
KikiGUI_swigregister = _kiki.KikiGUI_swigregister
KikiGUI_swigregister(KikiGUI)

class KikiScreenText(KikiText,KikiActionObject):
    __swig_setmethods__ = {}
    for _s in [KikiText,KikiActionObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiScreenText, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiText,KikiActionObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiScreenText, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _kiki.new_KikiScreenText()
        try: self.this.append(this)
        except: self.this = this
    def addText(self, *args): return _kiki.KikiScreenText_addText(self, *args)
    def setText(self, *args): return _kiki.KikiScreenText_setText(self, *args)
    def show(self): return _kiki.KikiScreenText_show(self)
    def getProjection(self): return _kiki.KikiScreenText_getProjection(self)
KikiScreenText_swigregister = _kiki.KikiScreenText_swigregister
KikiScreenText_swigregister(KikiScreenText)

class KikiMenu(KikiScreenText):
    __swig_setmethods__ = {}
    for _s in [KikiScreenText]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiMenu, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiScreenText]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiMenu, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KikiMenu(*args)
        try: self.this.append(this)
        except: self.this = this
    def addItem(self, *args): return _kiki.KikiMenu_addItem(self, *args)
    def setCurrentIndex(self, *args): return _kiki.KikiMenu_setCurrentIndex(self, *args)
    def setEscapeActive(self, active = True): return _kiki.KikiMenu_setEscapeActive(self, active)
    __swig_setmethods__["circular"] = _kiki.KikiMenu_circular_set
    __swig_getmethods__["circular"] = _kiki.KikiMenu_circular_get
    if _newclass:circular = _swig_property(_kiki.KikiMenu_circular_get, _kiki.KikiMenu_circular_set)
KikiMenu_swigregister = _kiki.KikiMenu_swigregister
KikiMenu_swigregister(KikiMenu)

class KikiColumnMenu(KikiMenu):
    __swig_setmethods__ = {}
    for _s in [KikiMenu]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiColumnMenu, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiMenu]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiColumnMenu, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KikiColumnMenu(*args)
        try: self.this.append(this)
        except: self.this = this
KikiColumnMenu_swigregister = _kiki.KikiColumnMenu_swigregister
KikiColumnMenu_swigregister(KikiColumnMenu)

class KikiScrollMenu(KikiColumnMenu):
    __swig_setmethods__ = {}
    for _s in [KikiColumnMenu]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiScrollMenu, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiColumnMenu]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiScrollMenu, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KikiScrollMenu(*args)
        try: self.this.append(this)
        except: self.this = this
    def getCurrentIndex(self): return _kiki.KikiScrollMenu_getCurrentIndex(self)
    def addItem(self, *args): return _kiki.KikiScrollMenu_addItem(self, *args)
KikiScrollMenu_swigregister = _kiki.KikiScrollMenu_swigregister
KikiScrollMenu_swigregister(KikiScrollMenu)

class KikiPageText(KikiScreenText):
    __swig_setmethods__ = {}
    for _s in [KikiScreenText]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiPageText, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiScreenText]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiPageText, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KikiPageText(*args)
        try: self.this.append(this)
        except: self.this = this
KikiPageText_swigregister = _kiki.KikiPageText_swigregister
KikiPageText_swigregister(KikiPageText)

class KikiFace(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiFace, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KikiFace, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    PX = _kiki.KikiFace_PX
    X = _kiki.KikiFace_X
    PY = _kiki.KikiFace_PY
    Y = _kiki.KikiFace_Y
    PZ = _kiki.KikiFace_PZ
    Z = _kiki.KikiFace_Z
    NX = _kiki.KikiFace_NX
    NY = _kiki.KikiFace_NY
    NZ = _kiki.KikiFace_NZ
KikiFace_swigregister = _kiki.KikiFace_swigregister
KikiFace_swigregister(KikiFace)

class KikiWire(KikiObject):
    __swig_setmethods__ = {}
    for _s in [KikiObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiWire, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiWire, name)
    __repr__ = _swig_repr
    UP = _kiki.KikiWire_UP
    RIGHT = _kiki.KikiWire_RIGHT
    DOWN = _kiki.KikiWire_DOWN
    VERTICAL = _kiki.KikiWire_VERTICAL
    LEFT = _kiki.KikiWire_LEFT
    HORIZONTAL = _kiki.KikiWire_HORIZONTAL
    ALL = _kiki.KikiWire_ALL
    def __init__(self, *args): 
        this = _kiki.new_KikiWire(*args)
        try: self.this.append(this)
        except: self.this = this
    def setActive(self, active = True): return _kiki.KikiWire_setActive(self, active)
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiWire_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiWire_setObjectColor)
KikiWire_swigregister = _kiki.KikiWire_swigregister
KikiWire_swigregister(KikiWire)

def KikiWire_setObjectColor(*args):
  return _kiki.KikiWire_setObjectColor(*args)
KikiWire_setObjectColor = _kiki.KikiWire_setObjectColor


def kikiObjectToWire(*args):
  return _kiki.kikiObjectToWire(*args)
kikiObjectToWire = _kiki.kikiObjectToWire
class KikiGear(KikiObject,KikiFace):
    __swig_setmethods__ = {}
    for _s in [KikiObject,KikiFace]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiGear, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiObject,KikiFace]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiGear, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KikiGear(*args)
        try: self.this.append(this)
        except: self.this = this
    def setActive(self, active = True): return _kiki.KikiGear_setActive(self, active)
    def updateActive(self): return _kiki.KikiGear_updateActive(self)
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiGear_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiGear_setObjectColor)
KikiGear_swigregister = _kiki.KikiGear_swigregister
KikiGear_swigregister(KikiGear)

def KikiGear_setObjectColor(*args):
  return _kiki.KikiGear_setObjectColor(*args)
KikiGear_setObjectColor = _kiki.KikiGear_setObjectColor


def kikiObjectToGear(*args):
  return _kiki.kikiObjectToGear(*args)
kikiObjectToGear = _kiki.kikiObjectToGear
class KikiValve(KikiObject,KikiFace):
    __swig_setmethods__ = {}
    for _s in [KikiObject,KikiFace]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiValve, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiObject,KikiFace]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiValve, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KikiValve(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiValve_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiValve_setObjectColor)
KikiValve_swigregister = _kiki.KikiValve_swigregister
KikiValve_swigregister(KikiValve)

def KikiValve_setObjectColor(*args):
  return _kiki.KikiValve_setObjectColor(*args)
KikiValve_setObjectColor = _kiki.KikiValve_setObjectColor


def kikiObjectToValve(*args):
  return _kiki.kikiObjectToValve(*args)
kikiObjectToValve = _kiki.kikiObjectToValve
class KikiMotorCylinder(KikiObject):
    __swig_setmethods__ = {}
    for _s in [KikiObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiMotorCylinder, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiMotorCylinder, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KikiMotorCylinder(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiMotorCylinder_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiMotorCylinder_setObjectColor)
KikiMotorCylinder_swigregister = _kiki.KikiMotorCylinder_swigregister
KikiMotorCylinder_swigregister(KikiMotorCylinder)

def KikiMotorCylinder_setObjectColor(*args):
  return _kiki.KikiMotorCylinder_setObjectColor(*args)
KikiMotorCylinder_setObjectColor = _kiki.KikiMotorCylinder_setObjectColor

class KikiMotorGear(KikiGear):
    __swig_setmethods__ = {}
    for _s in [KikiGear]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiMotorGear, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiGear]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiMotorGear, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KikiMotorGear(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiMotorGear_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiMotorGear_setObjectColor)
KikiMotorGear_swigregister = _kiki.KikiMotorGear_swigregister
KikiMotorGear_swigregister(KikiMotorGear)

def KikiMotorGear_setObjectColor(*args):
  return _kiki.KikiMotorGear_setObjectColor(*args)
KikiMotorGear_setObjectColor = _kiki.KikiMotorGear_setObjectColor

class KikiGenerator(KikiGear):
    __swig_setmethods__ = {}
    for _s in [KikiGear]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiGenerator, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiGear]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiGenerator, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KikiGenerator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiGenerator_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiGenerator_setObjectColor)
KikiGenerator_swigregister = _kiki.KikiGenerator_swigregister
KikiGenerator_swigregister(KikiGenerator)

def KikiGenerator_setObjectColor(*args):
  return _kiki.KikiGenerator_setObjectColor(*args)
KikiGenerator_setObjectColor = _kiki.KikiGenerator_setObjectColor

class KikiLight(KikiObject):
    __swig_setmethods__ = {}
    for _s in [KikiObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiLight, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiLight, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _kiki.new_KikiLight()
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiLight_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiLight_setObjectColor)
KikiLight_swigregister = _kiki.KikiLight_swigregister
KikiLight_swigregister(KikiLight)

def KikiLight_setObjectColor(*args):
  return _kiki.KikiLight_setObjectColor(*args)
KikiLight_setObjectColor = _kiki.KikiLight_setObjectColor


def kikiObjectToLight(*args):
  return _kiki.kikiObjectToLight(*args)
kikiObjectToLight = _kiki.kikiObjectToLight
class KikiCellText(KikiObject,KikiText):
    __swig_setmethods__ = {}
    for _s in [KikiObject,KikiText]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiCellText, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiObject,KikiText]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiCellText, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KikiCellText(*args)
        try: self.this.append(this)
        except: self.this = this
    def setOffset(self, *args): return _kiki.KikiCellText_setOffset(self, *args)
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiCellText_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiCellText_setObjectColor)
KikiCellText_swigregister = _kiki.KikiCellText_swigregister
KikiCellText_swigregister(KikiCellText)

def KikiCellText_setObjectColor(*args):
  return _kiki.KikiCellText_setObjectColor(*args)
KikiCellText_setObjectColor = _kiki.KikiCellText_setObjectColor


def kikiObjectToCellText(*args):
  return _kiki.kikiObjectToCellText(*args)
kikiObjectToCellText = _kiki.kikiObjectToCellText
class KikiStone(KikiObject):
    __swig_setmethods__ = {}
    for _s in [KikiObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiStone, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiStone, name)
    __repr__ = _swig_repr
    def __init__(self, color = None, slippery = False): 
        this = _kiki.new_KikiStone(color, slippery)
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiStone_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiStone_setObjectColor)
KikiStone_swigregister = _kiki.KikiStone_swigregister
KikiStone_swigregister(KikiStone)

def KikiStone_setObjectColor(*args):
  return _kiki.KikiStone_setObjectColor(*args)
KikiStone_setObjectColor = _kiki.KikiStone_setObjectColor


def kikiObjectToStone(*args):
  return _kiki.kikiObjectToStone(*args)
kikiObjectToStone = _kiki.kikiObjectToStone
class KikiWireStone(KikiStone):
    __swig_setmethods__ = {}
    for _s in [KikiStone]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiWireStone, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiStone]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiWireStone, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _kiki.new_KikiWireStone()
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiWireStone_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiWireStone_setObjectColor)
KikiWireStone_swigregister = _kiki.KikiWireStone_swigregister
KikiWireStone_swigregister(KikiWireStone)

def KikiWireStone_setObjectColor(*args):
  return _kiki.KikiWireStone_setObjectColor(*args)
KikiWireStone_setObjectColor = _kiki.KikiWireStone_setObjectColor


def kikiObjectToWireStone(*args):
  return _kiki.kikiObjectToWireStone(*args)
kikiObjectToWireStone = _kiki.kikiObjectToWireStone
class KikiWall(KikiObject):
    __swig_setmethods__ = {}
    for _s in [KikiObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiWall, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiWall, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _kiki.new_KikiWall()
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiWall_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiWall_setObjectColor)
KikiWall_swigregister = _kiki.KikiWall_swigregister
KikiWall_swigregister(KikiWall)

def KikiWall_setObjectColor(*args):
  return _kiki.KikiWall_setObjectColor(*args)
KikiWall_setObjectColor = _kiki.KikiWall_setObjectColor


def kikiObjectToWall(*args):
  return _kiki.kikiObjectToWall(*args)
kikiObjectToWall = _kiki.kikiObjectToWall
class KikiBomb(KikiObject):
    __swig_setmethods__ = {}
    for _s in [KikiObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiBomb, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiBomb, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _kiki.new_KikiBomb()
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiBomb_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiBomb_setObjectColor)
KikiBomb_swigregister = _kiki.KikiBomb_swigregister
KikiBomb_swigregister(KikiBomb)

def KikiBomb_setObjectColor(*args):
  return _kiki.KikiBomb_setObjectColor(*args)
KikiBomb_setObjectColor = _kiki.KikiBomb_setObjectColor


def kikiObjectToBomb(*args):
  return _kiki.kikiObjectToBomb(*args)
kikiObjectToBomb = _kiki.kikiObjectToBomb
class KikiSwitch(KikiObject):
    __swig_setmethods__ = {}
    for _s in [KikiObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiSwitch, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiSwitch, name)
    __repr__ = _swig_repr
    def __init__(self, on = False): 
        this = _kiki.new_KikiSwitch(on)
        try: self.this.append(this)
        except: self.this = this
    def toggle(self): return _kiki.KikiSwitch_toggle(self)
    def setActive(self, *args): return _kiki.KikiSwitch_setActive(self, *args)
    def isActive(self): return _kiki.KikiSwitch_isActive(self)
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiSwitch_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiSwitch_setObjectColor)
KikiSwitch_swigregister = _kiki.KikiSwitch_swigregister
KikiSwitch_swigregister(KikiSwitch)

def KikiSwitch_setObjectColor(*args):
  return _kiki.KikiSwitch_setObjectColor(*args)
KikiSwitch_setObjectColor = _kiki.KikiSwitch_setObjectColor


def kikiObjectToSwitch(*args):
  return _kiki.kikiObjectToSwitch(*args)
kikiObjectToSwitch = _kiki.kikiObjectToSwitch
class KikiGate(KikiSwitch):
    __swig_setmethods__ = {}
    for _s in [KikiSwitch]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiGate, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiSwitch]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiGate, name)
    __repr__ = _swig_repr
    def __init__(self, open = False): 
        this = _kiki.new_KikiGate(open)
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiGate_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiGate_setObjectColor)
KikiGate_swigregister = _kiki.KikiGate_swigregister
KikiGate_swigregister(KikiGate)

def KikiGate_setObjectColor(*args):
  return _kiki.KikiGate_setObjectColor(*args)
KikiGate_setObjectColor = _kiki.KikiGate_setObjectColor


def kikiObjectToGate(*args):
  return _kiki.kikiObjectToGate(*args)
kikiObjectToGate = _kiki.kikiObjectToGate
class KikiAtom(KikiObject):
    __swig_setmethods__ = {}
    for _s in [KikiObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiAtom, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiAtom, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def setValue(self, *args): return _kiki.KikiAtom_setValue(self, *args)
    def getValue(self): return _kiki.KikiAtom_getValue(self)
KikiAtom_swigregister = _kiki.KikiAtom_swigregister
KikiAtom_swigregister(KikiAtom)

class KikiMovesAtom(KikiAtom):
    __swig_setmethods__ = {}
    for _s in [KikiAtom]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiMovesAtom, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiAtom]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiMovesAtom, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiMovesAtom_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiMovesAtom_setObjectColor)
KikiMovesAtom_swigregister = _kiki.KikiMovesAtom_swigregister
KikiMovesAtom_swigregister(KikiMovesAtom)

def KikiMovesAtom_setObjectColor(*args):
  return _kiki.KikiMovesAtom_setObjectColor(*args)
KikiMovesAtom_setObjectColor = _kiki.KikiMovesAtom_setObjectColor

class KikiValueAtom(KikiAtom):
    __swig_setmethods__ = {}
    for _s in [KikiAtom]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiValueAtom, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiAtom]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiValueAtom, name)
    __repr__ = _swig_repr
    def __init__(self, range_start = 0.0, range_end = 1.0, start_value = 1.0, 
    levels = 9): 
        this = _kiki.new_KikiValueAtom(range_start, range_end, start_value, levels)
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiValueAtom_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiValueAtom_setObjectColor)
KikiValueAtom_swigregister = _kiki.KikiValueAtom_swigregister
KikiValueAtom_swigregister(KikiValueAtom)

def KikiValueAtom_setObjectColor(*args):
  return _kiki.KikiValueAtom_setObjectColor(*args)
KikiValueAtom_setObjectColor = _kiki.KikiValueAtom_setObjectColor

class KikiSpikes(KikiObject):
    __swig_setmethods__ = {}
    for _s in [KikiObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiSpikes, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiSpikes, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _kiki.new_KikiSpikes(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiSpikes_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiSpikes_setObjectColor)
KikiSpikes_swigregister = _kiki.KikiSpikes_swigregister
KikiSpikes_swigregister(KikiSpikes)

def KikiSpikes_setObjectColor(*args):
  return _kiki.KikiSpikes_setObjectColor(*args)
KikiSpikes_setObjectColor = _kiki.KikiSpikes_setObjectColor


def kikiObjectToSpikes(*args):
  return _kiki.kikiObjectToSpikes(*args)
kikiObjectToSpikes = _kiki.kikiObjectToSpikes
class KikiBullet(KikiObject):
    __swig_setmethods__ = {}
    for _s in [KikiObject]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiBullet, name, value)
    __swig_getmethods__ = {}
    for _s in [KikiObject]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiBullet, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["setObjectColor"] = lambda x: _kiki.KikiBullet_setObjectColor
    if _newclass:setObjectColor = staticmethod(_kiki.KikiBullet_setObjectColor)
KikiBullet_swigregister = _kiki.KikiBullet_swigregister
KikiBullet_swigregister(KikiBullet)

def KikiBullet_setObjectColor(*args):
  return _kiki.KikiBullet_setObjectColor(*args)
KikiBullet_setObjectColor = _kiki.KikiBullet_setObjectColor

class KConsole(KWindow):
    __swig_setmethods__ = {}
    for _s in [KWindow]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KConsole, name, value)
    __swig_getmethods__ = {}
    for _s in [KWindow]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KConsole, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_getmethods__["_print"] = lambda x: _kiki.KConsole__print
    if _newclass:_print = staticmethod(_kiki.KConsole__print)
    __swig_getmethods__["write"] = lambda x: _kiki.KConsole_write
    if _newclass:write = staticmethod(_kiki.KConsole_write)
    __swig_getmethods__["printError"] = lambda x: _kiki.KConsole_printError
    if _newclass:printError = staticmethod(_kiki.KConsole_printError)
    __swig_getmethods__["getConsole"] = lambda x: _kiki.KConsole_getConsole
    if _newclass:getConsole = staticmethod(_kiki.KConsole_getConsole)
    def clear(self): return _kiki.KConsole_clear(self)
    def out (self, *args):
        _kiki.KConsole__print(" ".join(map(str, args)))

KConsole_swigregister = _kiki.KConsole_swigregister
KConsole_swigregister(KConsole)

def KConsole__print(*args):
  return _kiki.KConsole__print(*args)
KConsole__print = _kiki.KConsole__print

def KConsole_write(*args):
  return _kiki.KConsole_write(*args)
KConsole_write = _kiki.KConsole_write

def KConsole_printError(*args):
  return _kiki.KConsole_printError(*args)
KConsole_printError = _kiki.KConsole_printError

def KConsole_getConsole():
  return _kiki.KConsole_getConsole()
KConsole_getConsole = _kiki.KConsole_getConsole

class KikiPythonWidget(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiPythonWidget, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KikiPythonWidget, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["cursorPos"] = _kiki.KikiPythonWidget_cursorPos_set
    __swig_getmethods__["cursorPos"] = _kiki.KikiPythonWidget_cursorPos_get
    if _newclass:cursorPos = _swig_property(_kiki.KikiPythonWidget_cursorPos_get, _kiki.KikiPythonWidget_cursorPos_set)
    __swig_setmethods__["selectionPos"] = _kiki.KikiPythonWidget_selectionPos_set
    __swig_getmethods__["selectionPos"] = _kiki.KikiPythonWidget_selectionPos_get
    if _newclass:selectionPos = _swig_property(_kiki.KikiPythonWidget_selectionPos_get, _kiki.KikiPythonWidget_selectionPos_set)
    def getTextRows(self): return _kiki.KikiPythonWidget_getTextRows(self)
    def getTextCols(self): return _kiki.KikiPythonWidget_getTextCols(self)
    def getTextSize(self): return _kiki.KikiPythonWidget_getTextSize(self)
    def getColumnWidth(self): return _kiki.KikiPythonWidget_getColumnWidth(self)
    def getRowHeight(self): return _kiki.KikiPythonWidget_getRowHeight(self)
    def getPythonWindow(self): return _kiki.KikiPythonWidget_getPythonWindow(self)
    def displayStringAtPos(self, *args): return _kiki.KikiPythonWidget_displayStringAtPos(self, *args)
KikiPythonWidget_swigregister = _kiki.KikiPythonWidget_swigregister
KikiPythonWidget_swigregister(KikiPythonWidget)

class KikiPython(KWindow):
    __swig_setmethods__ = {}
    for _s in [KWindow]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KikiPython, name, value)
    __swig_getmethods__ = {}
    for _s in [KWindow]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KikiPython, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getPythonWidget(self): return _kiki.KikiPython_getPythonWidget(self)
    def setScrollBarUnits(self, *args): return _kiki.KikiPython_setScrollBarUnits(self, *args)
    def requestUserInput(self, *args): return _kiki.KikiPython_requestUserInput(self, *args)
    def setTitle(self, *args): return _kiki.KikiPython_setTitle(self, *args)
    def setStatus(self, *args): return _kiki.KikiPython_setStatus(self, *args)
    def setInput(self, *args): return _kiki.KikiPython_setInput(self, *args)
    def executeFile(self, *args): return _kiki.KikiPython_executeFile(self, *args)
KikiPython_swigregister = _kiki.KikiPython_swigregister
KikiPython_swigregister(KikiPython)



