CWE-ou-minkata/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.

Additional permissions under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
//////////////////////////////////////////////////////////////////////
//
// plPythonFileMod   - the 'special' Python File modifier.
//
// This modifier will handle the interface to python code that has been file-ized.
//
//////////////////////////////////////////////////////////////////////////

#include "hsTypes.h"
#include "hsStream.h"
#include "plgDispatch.h"
#include "hsResMgr.h"
#include "../plResMgr/plKeyFinder.h"
#include "../pnKeyedObject/plKeyImp.h"
#include "../pnKeyedObject/plUoid.h"

#include "../pnSceneObject/plSceneObject.h"
#include "../pnSceneObject/plCoordinateInterface.h"
#include "../pnKeyedObject/plKey.h"
#include "../pnMessage/plTimeMsg.h"
#include "../pnMessage/plCmdIfaceModMsg.h"
#include "../plMessage/plInputEventMsg.h"
#include "../plModifier/plLogicModifier.h"
#include "../pfMessage/pfGUINotifyMsg.h"
#include "../plMessage/plRoomLoadNotifyMsg.h"
#include "../pfMessage/plClothingMsg.h"
#include "../pfMessage/pfKIMsg.h"
#include "../plMessage/plMemberUpdateMsg.h"
#include "../plMessage/plAgeLoadedMsg.h"
#include "../pnMessage/plRemoteAvatarInfoMsg.h"
#include "../pnMessage/plPlayerPageMsg.h"
#include "../plNetClient/plNetClientMgr.h"
#include "../plNetTransport/plNetTransportMember.h"
#include "../pnMessage/plSDLNotificationMsg.h"
#include "../plMessage/plNetOwnershipMsg.h"
#include "../plSDL/plSDL.h"
#include "../plVault/plVault.h"
#include "../plMessage/plCCRMsg.h"
#include "../plMessage/plVaultNotifyMsg.h"
#include "../plInputCore/plInputInterfaceMgr.h"
#include "../plInputCore/plInputDevice.h"
#include "../pfMessage/pfMarkerMsg.h"
#include "../pfMessage/pfBackdoorMsg.h"
#include "../plMessage/plAvatarMsg.h"
#include "../plMessage/plLOSHitMsg.h"
#include "../plMessage/plRenderMsg.h"
#include "../pfMessage/pfMovieEventMsg.h"
#include "../plMessage/plClimbEventMsg.h"
#include "../plMessage/plCaptureRenderMsg.h"
#include "../plGImage/plMipmap.h"
#include "../plMessage/plAccountUpdateMsg.h"
#include "../plAgeLoader/plAgeLoader.h"
#include "../pfGameMgr/pfGameMgr.h"
#include "../plMessage/plAIMsg.h"
#include "../plAvatar/plAvBrainCritter.h"

#include "plProfile.h"

#include "plPythonFileMod.h"
#include "cyPythonInterface.h"
#include "pyKey.h"
#include "cyDraw.h"
#include "cyPhysics.h"
#include "pySceneObject.h"
#include "cyMisc.h"
#include "cyCamera.h"
#include "pyNotify.h"
#include "cyAvatar.h"
#include "pyGeometry3.h"
#include "pyVault.h"
#include "pyVaultNode.h"
#include "pyVaultNodeRef.h"
#include "pyVaultAgeLinkNode.h"
#include "pyPlayer.h"
#include "pyNetLinkingMgr.h"
#include "pyAgeInfoStruct.h"
#include "pyAgeLinkStruct.h"
#include "pyImage.h"
#include "pyCritterBrain.h"

// GUI Control:
#include "pyGUIDialog.h"
#include "pyGUIControlButton.h"
#include "pyGUIControlCheckBox.h"
#include "pyGUIControlEditBox.h"
#include "pyGUIControlListBox.h"
#include "pyGUIControlRadioGroup.h"
#include "pyGUIControlTextBox.h"
#include "pyGUIControlValue.h"
#include "pyGUIControlDynamicText.h"
#include "pyGUIControlMultiLineEdit.h"
#include "pyGUIPopUpMenu.h"
#include "pyGUIControlClickMap.h"

// Game manager
#include "Games/pyGameMgrMsg.h"
#include "Games/pyGameCliMsg.h"

#include <locale>

#include "plPythonSDLModifier.h"

#include "../plMessage/plTimerCallbackMsg.h"

plProfile_CreateTimer("Update", "Python", PythonUpdate);

/////////////////////////////////////////////////////////////////////////////
//
// fFunctionNames    - the actual names of the functions for On[event] types
//
char*	plPythonFileMod::fFunctionNames[] = 
{
	{ "OnFirstUpdate" },		// kfunc_FirstUpdate
	{ "OnUpdate" },				// kfunc_Update
	{ "OnNotify" },				// kfunc_Notify
	{ "OnTimer" },				// kfunc_AtTimer
	{ "OnControlKeyEvent" },	// kfunc_OnKeyEvent
	{ "Load" },					// kfunc_Load
	{ "Save" },					// kfunc_Save
	{ "OnGUINotify" },			// kfunc_GUINotify
	{ "OnPageLoad"	},			// kfunc_PageLoad
	{ "OnClothingUpdate" },		// kfunc_ClothingUpdate
	{ "OnKIMsg" },				// kfunc_KIMsg,
	{ "OnMemberUpdate" },		// kfunc_MemberUpdate,
	{ "OnRemoteAvatarInfo" },	// kfunc_RemoteAvatarInfo,
	{ "OnRTChat" },				// kfunc_RTChat,
	{ "OnVaultEvent" },			// kfunc_VaultEvent,
	{ "AvatarPage" },			// kfunc_AvatarPage,
	{ "OnSDLNotify" },			// kfunc_SDLNotify
	{ "OnOwnershipChanged" },	// kfunc_OwnershipNotify
	{ "OnAgeVaultEvent" },		// kfunc_AgeVaultEvent
	{ "OnInit" },				// kfunc_Init,
	{ "OnCCRMsg" },				// kfunc_OnCCRMsg,
	{ "OnServerInitComplete" }, // kfunc_OnServerInitComplete
	{ "OnVaultNotify" },		// kfunc_OnVaultNotify
	{ "OnDefaultKeyCaught" },	// kfunc_OnDefaultKeyCaught
	{ "OnMarkerMsg" },			// kfunc_OnMarkerMsg,
	{ "OnBackdoorMsg" },		// kfunc_OnBackdoorMsg,
	{ "OnBehaviorNotify" },		// kfunc_OnBehaviorNotify,
	{ "OnLOSNotify" },			// kfunc_OnLOSNotify,
	{ "BeginAgeUnLoad" },		// kfunc_OnBeginAgeLoad,
	{ "OnMovieEvent" },			// kfunc_OnMovieEvent,
	{ "OnScreenCaptureDone" },	// kfunc_OnScreenCaptureDone,
	{ "OnClimbingBlockerEvent"},// kFunc_OnClimbingBlockerEvent,
	{ "OnAvatarSpawn"},			// kFunc_OnAvatarSpawn
	{ "OnAccountUpdate"},		// kFunc_OnAccountUpdate
	{ "gotPublicAgeList"},		// kfunc_gotPublicAgeList
	{ "OnGameMgrMsg" },			// kfunc_OnGameMgrMsg
	{ "OnGameCliMsg" },			// kfunc_OnGameCliMsg
	{ "OnAIMsg" },				// kfunc_OnAIMsg
	{ nil }
};

//// Callback From the Vault Events //////////////////////////////////////////////
class PythonVaultCallback : public VaultCallback
{
protected:
	plPythonFileMod* fPyFileMod;
	int		fFunctionIdx;

public:
	PythonVaultCallback( plPythonFileMod *pymod, int fidx )
	{
		fPyFileMod = pymod;
		fFunctionIdx = fidx;
	}

	void AddedChildNode ( RelVaultNode * parentNode, RelVaultNode * childNode )
	{
		// is there an 'OnVaultEvent' defined?
		if ( fPyFileMod && fPyFileMod->fPyFunctionInstances[fFunctionIdx] != nil )
		{
			PyObject* ptuple = PyTuple_New(1);
			PyTuple_SetItem(ptuple, 0, pyVaultNodeRef::New(parentNode, childNode));
			// call it
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFileMod->fPyFunctionInstances[fFunctionIdx],
						fPyFileMod->fFunctionNames[fFunctionIdx],
						"lO",pyVault::kVaultNodeRefAdded,ptuple);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFileMod->fPyFunctionInstances[fFunctionIdx] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				fPyFileMod->ReportError();
			}
			Py_XDECREF(retVal);
			Py_DECREF(ptuple);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			fPyFileMod->DisplayPythonOutput();
		}
	}

	void RemovingChildNode ( RelVaultNode * parentNode, RelVaultNode * childNode )
	{
		// is there an 'OnVaultEvent' defined?
		if ( fPyFileMod && fPyFileMod->fPyFunctionInstances[fFunctionIdx] != nil )
		{
			PyObject* ptuple = PyTuple_New(1);
			PyTuple_SetItem(ptuple, 0, pyVaultNodeRef::New(parentNode, childNode));
			// call it
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFileMod->fPyFunctionInstances[fFunctionIdx],
						fPyFileMod->fFunctionNames[fFunctionIdx],
						"lO",pyVault::kVaultRemovingNodeRef,ptuple);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFileMod->fPyFunctionInstances[fFunctionIdx] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				fPyFileMod->ReportError();
			}
			Py_XDECREF(retVal);
			Py_DECREF(ptuple);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			fPyFileMod->DisplayPythonOutput();
		}
	}

	void ChangedNode ( RelVaultNode * changedNode )
	{
		// is there an 'OnVaultEvent' defined?
		if ( fPyFileMod && fPyFileMod->fPyFunctionInstances[fFunctionIdx] != nil )
		{
			PyObject* ptuple = PyTuple_New(1);
			PyTuple_SetItem(ptuple, 0, pyVaultNode::New(changedNode));
			// call it
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFileMod->fPyFunctionInstances[fFunctionIdx],
						fPyFileMod->fFunctionNames[fFunctionIdx],
						"lO",pyVault::kVaultNodeSaved,ptuple);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFileMod->fPyFunctionInstances[fFunctionIdx] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				fPyFileMod->ReportError();
			}
			Py_XDECREF(retVal);
			Py_DECREF(ptuple);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			fPyFileMod->DisplayPythonOutput();
		}
	}
};

/////////////////////////////////////////////////////////////////////////////
//
//  Class	   : pfPythonKeyCatcher
//  PARAMETERS : none
//
//  PURPOSE    : Small wrapper class to catch discarded key events and pass
//				 them to a plPythonFileMod
//

class pfPythonKeyCatcher : public plDefaultKeyCatcher
{
	plPythonFileMod *fMod;

	public:
		pfPythonKeyCatcher( plPythonFileMod *mod ) : fMod( mod ) {}
		
		virtual void	HandleKeyEvent( plKeyEventMsg *event )
		{
			fMod->HandleDiscardedKey( event );
		}
};

hsBool plPythonFileMod::fAtConvertTime = false;

/////////////////////////////////////////////////////////////////////////////
//
//  Function   : plPythonFileMod and ~plPythonFileMod
//  PARAMETERS : none
//
//  PURPOSE    : Constructor and destructor
//
plPythonFileMod::plPythonFileMod()
{
	fPythonFile = nil;
	fModuleName = nil;
	fModule = nil;
	fLocalNotify= true;
	fIsFirstTimeEval = true;
	fVaultCallback = nil;
	fSDLMod = nil;
	fSelfKey = nil;
	fInstance = nil;
	fKeyCatcher = nil;
	fPipe = nil;
	fAmIAttachedToClone = false;

	// assume that all the functions are not available
	// ...if the functions are defined in the module, then we'll call 'em
	int i;
	for (i=0 ; i<kfunc_lastone; i++)
		fPyFunctionInstances[i] = nil;
}

plPythonFileMod::~plPythonFileMod()
{
	if ( !fAtConvertTime )		// if this is just an Add that's during a convert, then don't do anymore
	{
		// remove our reference to the instance (but only if we made one)
		if(fInstance)
		{
			if ( fInstance->ob_refcnt > 1)
				Py_DECREF(fInstance);
			//  then have the glue delete the instance of class
			PyObject* delInst = PythonInterface::GetModuleItem("glue_delInst",fModule);
			if ( delInst!=nil && PyCallable_Check(delInst) )
			{
				PyObject* retVal = PyObject_CallFunction(delInst,nil);
				if ( retVal == nil )
				{
					// if there was an error make sure that the stderr gets flushed so it can be seen
					ReportError();
				}
				Py_XDECREF(retVal);
				// display any output
				DisplayPythonOutput();
			}
		}
		fInstance = nil;
	}

	// If we have a key catcher, get rid of it
	delete fKeyCatcher;
	fKeyCatcher = nil;

	// if we created a Vault callback, undo it and get rid of it
	if (fVaultCallback)
	{
		// Set the callback for the vault thingy
		VaultUnregisterCallback(fVaultCallback);
		delete fVaultCallback;
		fVaultCallback = nil;
	}

	if (fSelfKey)
	{
		Py_DECREF(fSelfKey);
		fSelfKey = nil;
	}

	// get rid of the python code
	if ( fPythonFile )
	{
		delete [] fPythonFile;
		fPythonFile = nil;
	}
	// then get rid of this module
	//  NOTE: fModule shouldn't be made in the plugin, only at runtime
	if ( fModuleName && fModule )
	{
		//_PyModule_Clear(fModule);
		PyObject *m;
		PyObject *modules = PyImport_GetModuleDict();
		if( modules && (m = PyDict_GetItemString(modules, fModuleName)) && PyModule_Check(m))
		{
			hsStatusMessageF("Module %s removed from python dictionary",fModuleName);
			PyDict_DelItemString(modules, fModuleName);
		}
		else
		{
			hsStatusMessageF("Module %s not found in python dictionary. Already removed?",fModuleName);
		}
		// the above code should have unloaded the module from python, so it will delete itself, therefore
		// we need to set our pointer to nil to make sure we don't try to use it
		fModule = nil;
	}
	delete [] fModuleName;
	fModuleName = nil;
}

#include "plPythonPack.h"

bool plPythonFileMod::ILoadPythonCode()
{

#ifndef PLASMA_EXTERNAL_RELEASE
	// get code from file and execute in module
	// see if the file exists first before trying to import it
	char pathandfile[256];
	sprintf(pathandfile, ".\\python\\%s.py",fPythonFile);
	wchar *wPathandfile = hsStringToWString(pathandfile);
	hsBool exists = PathDoesFileExist(wPathandfile);
	delete [] wPathandfile;
	if (exists)
	{
		char fromLoad[256];
		//sprintf(fromLoad,"from %s import *", fPythonFile);
		// ok... we can't really use import because Python remembers too much where global variables came from
		// ...and using execfile make it sure that globals are defined in this module and not in the imported module
		sprintf(fromLoad,"execfile('.\\\\python\\\\%s.py')", fPythonFile);
		if ( PythonInterface::RunString( fromLoad, fModule) )
		{
			// we've loaded the code into our module
		// now attach the glue python code to the end
			if ( !PythonInterface::RunString("execfile('.\\\\python\\\\plasma\\\\glue.py')", fModule) )
			{
				// display any output (NOTE: this would be disabled in production)
				DisplayPythonOutput();
				return false;
			}
			else
				return true;
		}
		DisplayPythonOutput();
		char errMsg[256];
		sprintf(errMsg,"Python file %s.py had errors!!! Could not load.",fPythonFile);
		PythonInterface::WriteToLog(errMsg);
		hsAssert(0,errMsg);
		return false;
	}
#endif  //PLASMA_EXTERNAL_RELEASE

	// Finally, try and find the file in the Python packfile
	// ... for the external users .pak file is only used
	PyObject* pythonCode = PythonPack::OpenPythonPacked(fPythonFile);
	if (pythonCode && PythonInterface::RunPYC(pythonCode, fModule))
		return true;

	DisplayPythonOutput();
	char errMsg[256];
	sprintf(errMsg,"Python file %s.py was not found.",fPythonFile);
	PythonInterface::WriteToLog(errMsg);
	hsAssert(0,errMsg);
	return false;
}


/////////////////////////////////////////////////////////////////////////////
//
//  Function   : AddTarget
//  PARAMETERS : sobj  - object to add as our target
//
//  PURPOSE    : Get the Key of our target
//
// NOTE: This modifier wasn't intended to have multiple targets
//
void plPythonFileMod::AddTarget(plSceneObject* sobj)
{
	plMultiModifier::AddTarget(sobj);
	plgDispatch::Dispatch()->RegisterForExactType(plEvalMsg::Index(), GetKey());
	plgDispatch::Dispatch()->RegisterForExactType(plPlayerPageMsg::Index(), GetKey());
	plgDispatch::Dispatch()->RegisterForExactType(plAgeBeginLoadingMsg::Index(), GetKey());
	plgDispatch::Dispatch()->RegisterForExactType(plInitialAgeStateLoadedMsg::Index(), GetKey());
	// initialize the python stuff
	if ( !fAtConvertTime )		// if this is just an Add that's during a convert, then don't do anymore
	{
		// was there a python file module with this?
		if ( fPythonFile )
		{
			// has the module not been initialized yet
			if ( !fModule )
			{
				plKey pkey = sobj->GetKey();
				// nope, must be the first object. Then use it as the basis for the module
				char modulename[256];
				IMakeModuleName(modulename,sobj);
				delete [] fModuleName;
				fModuleName = StrDup(modulename);
				fModule = PythonInterface::CreateModule(modulename);

				// if we can't create the instance then there is nothing to do here
				if (!ILoadPythonCode())
				{
					// things are getting off on a bad foot... just say there wasn't a module...
					fModule = nil;
					return;
				}

			// set the name of the file (in the global dictionary of the module)
				PyObject* dict = PyModule_GetDict(fModule);
				PyObject* pfilename = PyString_FromString(fPythonFile);
				PyDict_SetItemString(dict, "glue_name", pfilename);
			// next we need to:
			//  - create instance of class
				PyObject* getInst = PythonInterface::GetModuleItem("glue_getInst",fModule);
				fInstance = nil;
				if ( getInst!=nil && PyCallable_Check(getInst) )
				{
					fInstance = PyObject_CallFunction(getInst,nil);
					if ( fInstance == nil )
						// if there was an error make sure that the stderr gets flushed so it can be seen
						ReportError();
				}
				// display any output
				DisplayPythonOutput();
				if ( fInstance == nil )		// then there was an error
				{
					// display any output (NOTE: this would be disabled in production)
					char errMsg[256];
					sprintf(errMsg,"Python file %s.py, instance not found.",fPythonFile);
					PythonInterface::WriteToLog(errMsg);
					hsAssert(0, errMsg);
					return;			// if we can't create the instance then there is nothing to do here
				}

				// Add the SDL modifier
				if (plPythonSDLModifier::HasSDL(fPythonFile))
				{
					plSceneObject* sceneObj = plSceneObject::ConvertNoRef(GetTarget(0)->GetKey()->ObjectIsLoaded());
					if (sceneObj)
					{
						hsAssert(!fSDLMod, "Python SDL modifier already created");
						fSDLMod = TRACKED_NEW plPythonSDLModifier(this);
						sceneObj->AddModifier(fSDLMod);
					}
				}

				//  - set the self.key and self.sceneobject in the instance of the class
				// create the pyKey for this modifier
				fSelfKey = pyKey::New(GetKey(),this);
				// set the selfKey as an attribute to their instance
				PyObject_SetAttrString(fInstance, "key", fSelfKey);
				// create the sceneobject
				PyObject* pSobj = pySceneObject::New(pkey, fSelfKey);
				// set the sceneobject as an attribute to their instance
				PyObject_SetAttrString(fInstance, "sceneobject", pSobj);
				Py_DECREF(pSobj);
				// set the isInitialStateLoaded to not loaded... yet
				PyObject* pInitialState = PyInt_FromLong(0);
				PyObject_SetAttrString(fInstance, "isInitialStateLoaded", pInitialState);
				Py_DECREF(pInitialState);
				// Give the SDL mod to Python
				if (fSDLMod)
				{
					PyObject* pSDL = pySDLModifier::New(fSDLMod);
					PyObject_SetAttrString(fInstance, "SDL", pSDL);
					Py_DECREF(pSDL);
				}

				//  - set the parameters
				PyObject* setParams = PythonInterface::GetModuleItem("glue_setParam",fModule);
				PyObject* check_isNamed = PythonInterface::GetModuleItem("glue_isNamedAttribute",fModule);
				if ( setParams!=nil && PyCallable_Check(setParams) )
				{
					// loop throught the parameters and set them by id
					// (will need to create the appropiate Python object for each type)
					int nparam;
					for ( nparam=0; nparam<GetParameterListCount() ; nparam++ )
					{
						plPythonParameter parameter = GetParameterItem(nparam);
						// create the python object that matches the type
						// (NOTE: this relies on function created above to help create Plasma python objects)
						PyObject* value = nil;		// assume that there is no conversion available
						int isNamedAttr = 0;
						PyObject* retvalue;
						switch (parameter.fValueType)
						{
							case plPythonParameter::kInt:
								value = PyInt_FromLong(parameter.datarecord.fIntNumber);
								break;
							case plPythonParameter::kFloat:
								value = PyFloat_FromDouble(parameter.datarecord.fFloatNumber);
								break;
							case plPythonParameter::kBoolean:
								value = PyInt_FromLong(parameter.datarecord.fBool);
								break;
							case plPythonParameter::kString:
							case plPythonParameter::kAnimationName:
								isNamedAttr = 0;
								if ( check_isNamed!=nil && PyCallable_Check(check_isNamed) )
								{
									retvalue = PyObject_CallFunction(check_isNamed,"l", parameter.fID);
									if ( retvalue == nil )
									{
										ReportError();
										DisplayPythonOutput();
									}
									if ( retvalue && PyInt_Check(retvalue) )
										isNamedAttr = PyInt_AsLong(retvalue);
									Py_XDECREF(retvalue);
									// is it a NamedActivator
									if ( isNamedAttr == 1 || isNamedAttr == 2)
									{
										if (plAgeLoader::GetInstance()->IsLoadingAge())
										{
											NamedComponent comp;
											comp.isActivator = (isNamedAttr == 1);
											comp.id = parameter.fID;
											comp.name = TRACKED_NEW char[strlen(parameter.datarecord.fString) + 1];
											strcpy(comp.name, parameter.datarecord.fString);
											
											fNamedCompQueue.Append(comp);
										}
										else
										{
											if (isNamedAttr == 1)
												IFindActivatorAndAdd(parameter.datarecord.fString, parameter.fID);
											else
												IFindResponderAndAdd(parameter.datarecord.fString, parameter.fID);
										}
									}
								}
								// if it wasn't a named string then must be normal string type
								if ( isNamedAttr == 0 )
									if ( parameter.datarecord.fString != nil )
										value = PyString_FromString(parameter.datarecord.fString);
								break;
							case plPythonParameter::kSceneObject:
							case plPythonParameter::kSceneObjectList:
								if ( parameter.fObjectKey != nil )
								{
									// create the sceneobject
									value = pySceneObject::New(parameter.fObjectKey, fSelfKey);
								}
								break;
							case plPythonParameter::kActivatorList:
							case plPythonParameter::kResponderList:
							case plPythonParameter::kDynamicText:
							case plPythonParameter::kGUIDialog:
							case plPythonParameter::kExcludeRegion:
							case plPythonParameter::kAnimation:
							case plPythonParameter::kBehavior:
							case plPythonParameter::kMaterial:
							case plPythonParameter::kGUIPopUpMenu:
							case plPythonParameter::kGUISkin:
							case plPythonParameter::kWaterComponent:
							case plPythonParameter::kSwimCurrentInterface:
							case plPythonParameter::kClusterComponentList:
							case plPythonParameter::kMaterialAnimation:
							case plPythonParameter::kGrassShaderComponent:
								if ( parameter.fObjectKey != nil )
								{
									// create pyKey for the object
									value = pyKey::New(parameter.fObjectKey);
								}
								break;
						}
						// if there is a value that was converted then tell the Python code
						if ( value != nil )
						{
							PyObject* retVal = PyObject_CallFunction(setParams,"lO", parameter.fID, value);
							if ( retVal == nil )
							{
								// if there was an error make sure that the stderr gets flushed so it can be seen
								ReportError();
							}
							Py_XDECREF(retVal);
							Py_DECREF(value);
						}
					}
				}

				// check if we need to register named activators or responders
				if (fNamedCompQueue.Count() > 0)
				{
					plgDispatch::Dispatch()->RegisterForExactType( plAgeLoadedMsg::Index(), GetKey() );
				}

			//  - find functions in class they've defined.
				PythonInterface::CheckInstanceForFunctions(fInstance,fFunctionNames,fPyFunctionInstances);
				// clear any errors created by checking for methods in a class
				PyErr_Clear();		// clear the error
			// register for messages that they have functions defined for
				// register for PageLoaded message if needed
				if ( fPyFunctionInstances[kfunc_PageLoad] != nil )
				{
					// register for plRoomLoadNotifyMsg
					plgDispatch::Dispatch()->RegisterForExactType(plRoomLoadNotifyMsg::Index(), GetKey());
				}

				// register for ClothingUpdate message if needed
				if ( fPyFunctionInstances[kfunc_ClothingUpdate] != nil )
				{
					// register for plRoomLoadNotifyMsg
					plgDispatch::Dispatch()->RegisterForExactType(plClothingUpdateBCMsg::Index(), GetKey());
				}

				// register for pfKIMsg message if needed
				if ( fPyFunctionInstances[kfunc_KIMsg] != nil )
				{
					// register for pfKIMsg
					plgDispatch::Dispatch()->RegisterForExactType(pfKIMsg::Index(), GetKey());
				}

				// register for Member update message if needed
				if ( fPyFunctionInstances[kfunc_MemberUpdate] != nil )
				{
					// register for plMemberUpdateMsg
					plgDispatch::Dispatch()->RegisterForExactType(plMemberUpdateMsg::Index(), GetKey());
				}

				// register for Remote Avatar Info message if needed
				if ( fPyFunctionInstances[kfunc_RemoteAvatarInfo] != nil )
				{
					// register for plRemoteAvatarInfoMsg
					plgDispatch::Dispatch()->RegisterForExactType(plRemoteAvatarInfoMsg::Index(), GetKey());
				}

				// register for CCR message if needed
				if ( fPyFunctionInstances[kfunc_OnCCRMsg] != nil )
				{
					// register for plCCRCommunicationMsg
					plgDispatch::Dispatch()->RegisterForExactType(plCCRCommunicationMsg::Index(), GetKey());
				}

				// register for VaultNotify message if needed
				if ( fPyFunctionInstances[kfunc_OnVaultNotify] != nil )
				{
					// register for plVaultNotifyMsg
					plgDispatch::Dispatch()->RegisterForExactType(plVaultNotifyMsg::Index(), GetKey());
				}

				// register for Owndership change notification message if needed
				if ( fPyFunctionInstances[kfunc_OwnershipNotify] != nil )
				{
					// register for plNetOwnershipMsg
					plgDispatch::Dispatch()->RegisterForExactType(plNetOwnershipMsg::Index(), GetKey());
				}

#ifndef PLASMA_EXTERNAL_RELEASE
				// register for Backdoor message if needed
				if ( fPyFunctionInstances[kfunc_OnBackdoorMsg] != nil )
				{
					// register for pfDebugTriggerMsg
					plgDispatch::Dispatch()->RegisterForExactType(pfBackdoorMsg::Index(), GetKey());
				}
#endif  //PLASMA_EXTERNAL_RELEASE

				// register for VaultCallback events if needed
				if ( fPyFunctionInstances[kfunc_VaultEvent] != nil )
				{
					// create the callback object
					// Set the callback for the vault thingy
					fVaultCallback = TRACKED_NEW PythonVaultCallback( this, kfunc_VaultEvent );
					VaultRegisterCallback(fVaultCallback);
				}

				// register ourselves to be the default key catcher if necessary
				if ( fPyFunctionInstances[kfunc_OnDefaultKeyCaught] != nil )
				{
					// Make us a key catcher
					fKeyCatcher = TRACKED_NEW pfPythonKeyCatcher( this );

					// Tell the input interface manager to use our catcher
					plInputInterfaceMgr::GetInstance()->SetDefaultKeyCatcher( fKeyCatcher );
				}

				// register for Marker messages if needed
				if ( fPyFunctionInstances[kfunc_OnMarkerMsg] != nil )
				{
					plgDispatch::Dispatch()->RegisterForExactType(pfMarkerMsg::Index(), GetKey());
				}

				// if they are going to get LOS hit messages then we need to get the Pipeline pointer
				if ( fPyFunctionInstances[kfunc_OnLOSNotify] != nil )
				{
					plgDispatch::Dispatch()->RegisterForExactType( plRenderMsg::Index(), GetKey() );
				}
				
				// if this is a climbing-wall function, we need to register for climbing wall messages
				if ( fPyFunctionInstances[kfunc_OnClimbBlockerEvent] != nil)
				{
					plgDispatch::Dispatch()->RegisterForExactType( plClimbEventMsg::Index(), GetKey() );	
				}
				if ( fPyFunctionInstances[kfunc_OnAvatarSpawn] != nil)
				{
					plgDispatch::Dispatch()->RegisterForExactType( plAvatarSpawnNotifyMsg::Index(), GetKey() );	
				}
				if ( fPyFunctionInstances[kfunc_OnAccountUpdate] != nil)
				{
					plgDispatch::Dispatch()->RegisterForExactType( plAccountUpdateMsg::Index(), GetKey() );	
				}
				if ( fPyFunctionInstances[kfunc_gotPublicAgeList] != nil)
				{
					plgDispatch::Dispatch()->RegisterForExactType(plNetCommPublicAgeListMsg::Index(), GetKey());
				}
				if ( fPyFunctionInstances[kfunc_OnGameMgrMsg] != nil)
				{
					pfGameMgr::GetInstance()->AddReceiver(GetKey());
				}
				if ( fPyFunctionInstances[kfunc_OnAIMsg] != nil)
				{
					// the message that is spammed to anyone who will listen
					plgDispatch::Dispatch()->RegisterForExactType(plAIBrainCreatedMsg::Index(), GetKey());
				}

				// As the last thing... call the OnInit function if they have one
				if ( fPyFunctionInstances[kfunc_Init] != nil )
				{
					plProfile_BeginTiming(PythonUpdate);
					// call it
					PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_Init],fFunctionNames[kfunc_Init],nil);
					if ( retVal == nil )
					{
#ifndef PLASMA_EXTERNAL_RELEASE
						// for some reason this function didn't, remember that and not call it again
						fPyFunctionInstances[kfunc_Init] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
						// if there was an error make sure that the stderr gets flushed so it can be seen
						ReportError();
					}
					Py_XDECREF(retVal);
					plProfile_EndTiming(PythonUpdate);
					// display any output (NOTE: this would be disabled in production)
					DisplayPythonOutput();
				}

				// display python output
				DisplayPythonOutput();
			}
			else
			{
			// else if module is already created... Then we are just adding an addition object to the already existing SceneObject
				if ( fInstance )		// make sure that we have an instance already also
				{
					PyObject* dict = PyModule_GetDict(fModule);
					// create pyKey for the object
					PyObject* pkeyObj = pyKey::New(sobj->GetKey());
					// need to get the instance, that holds the sceneobject that we are attached to
					PyObject* getInst = PythonInterface::GetModuleItem("glue_getInst",fModule);
					// get the sceneObject that should already be created
					PyObject* pSceneObject = PyObject_GetAttrString(fInstance,"sceneobject");
					// add our new object to the list of objects that are in the _selfObject
					PyObject* retVal = PyObject_CallMethod(pSceneObject,"addKey","O",pkeyObj );
					Py_XDECREF(retVal);
					// GetAttrString put a ref on pSceneObject, but we're done with it now.
					Py_XDECREF(pSceneObject); 
					Py_DECREF(pkeyObj);
				}
			}
		}
	}
}

void plPythonFileMod::RemoveTarget(plSceneObject* so)
{
	// remove sdl modifier
	if (fSDLMod)
	{
		if (GetNumTargets() > 0)
		{
			plSceneObject* sceneObj = plSceneObject::ConvertNoRef(GetTarget(0)->GetKey()->ObjectIsLoaded());
			if (sceneObj && fSDLMod)
				sceneObj->RemoveModifier(fSDLMod);
		}
		delete fSDLMod;
		fSDLMod = nil;
	}

	plMultiModifier::RemoveTarget(so);
}

/////////////////////////////////////////////////////////////////////////////
//
//  Function   : HandleDiscardedKey
//  PARAMETERS : msg - the key event message that was discarded
//
//  PURPOSE    : API for processing discarded keys as the deafult key catcher
//

void	plPythonFileMod::HandleDiscardedKey( plKeyEventMsg *msg )
{
	// So OnDefaultKeyCaught takes two parameters: the key character pressed and a boolean saying up or down
	char keyChar = plKeyboardDevice::KeyEventToChar( msg );

	// if the caps lock is down then reverse upper and lowercase
	if ( msg->GetCapsLockKeyDown() )
	{
		if ( std::islower(keyChar,std::locale()) )
			keyChar = std::toupper(keyChar,std::locale());
		else
			keyChar = std::tolower(keyChar,std::locale());
	}

	if (!fPyFunctionInstances[kfunc_OnDefaultKeyCaught])
		return;

	plProfile_BeginTiming( PythonUpdate );

	PyObject* retVal = PyObject_CallMethod( fPyFunctionInstances[ kfunc_OnDefaultKeyCaught ],
				fFunctionNames[ kfunc_OnDefaultKeyCaught ],
				"ciiiii",
				keyChar, 
				(int)msg->GetKeyDown(),
				(int)msg->GetRepeat(),
				(int)msg->GetShiftKeyDown(),
				(int)msg->GetCtrlKeyDown(),
				(int)msg->GetKeyCode() );
	if( retVal == nil )
	{
#ifndef PLASMA_EXTERNAL_RELEASE
		// for some reason this function didn't, remember that and not call it again
		fPyFunctionInstances[ kfunc_OnDefaultKeyCaught ] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
		// if there was an error make sure that the stderr gets flushed so it can be seen
		ReportError();
	}
	Py_XDECREF(retVal);

	plProfile_EndTiming( PythonUpdate );
	// display any output (NOTE: this would be disabled in production)
	DisplayPythonOutput();
}


/////////////////////////////////////////////////////////////////////////////
//
//  Function   : IMakeModuleName
//  PARAMETERS : sobj  - object to add as our target
//
//  PURPOSE    : Get the Key of our target
//
// NOTE: This modifier wasn't intended to have multiple targets
//
void plPythonFileMod::IMakeModuleName(char* modulename,plSceneObject* sobj)
{
	// Forgive my general crapulance...
	// This strips underscores out of module names 
	// so python won't truncate them... -S

	plKey pKey = GetKey();
	plKey sKey = sobj->GetKey();

	const char* pKeyName = pKey->GetName(); 
	const char* pSobjName = sKey->GetName(); 

	UInt16 len = hsStrlen(pKeyName);
	UInt16 slen = hsStrlen(pSobjName);

	hsAssert(len+slen < 256, "Warning: String length exceeds 256 characters.");
	
	int i, k = 0;
	for(i = 0; i < slen; i++)
	{
		if(pSobjName[i] == '_') continue;

		modulename[k++] = pSobjName[i];
	}
	for(i = 0; i < len; i++)
	{
		if(pKeyName[i] == '_') continue;

		modulename[k++] = pKeyName[i];
	}

	modulename[k] = '\0';

	// check to see if we are attaching to a clone?
	plKeyImp* pKeyImp = (plKeyImp*)(sKey);
	if (pKeyImp->GetCloneOwner())
	{
		// we have an owner... so we must be a clone.
		// add the cloneID to the end of the module name
		// and set the fIAmAClone flag
		UInt32 cloneID = pKeyImp->GetUoid().GetCloneID();
		sprintf(modulename,"%s%d",modulename,cloneID);
		fAmIAttachedToClone = true;
	}

	// make sure that the actual modulue will be uniqie
	if ( !PythonInterface::IsModuleNameUnique(modulename) )
	{
		// if not unique then add the sequence number to the end of the modulename
		UInt32 seqID = pKeyImp->GetUoid().GetLocation().GetSequenceNumber();
		sprintf(modulename,"%s%d",modulename,seqID);
	}
}

/////////////////////////////////////////////////////////////////////////////
//
//  Function   : ISetKeyValue
//  PARAMETERS : key to responder, parameter id
//
//  PURPOSE    : set the param in the python file
//             : so named stuff works
//
void plPythonFileMod::ISetKeyValue(const plKey& key, Int32 id)
{
	PyObject* setParams = PythonInterface::GetModuleItem("glue_setParam",fModule);
	
	if ( setParams != nil && PyCallable_Check(setParams) )
	{
		if ( key != nil )
		{
			// create pyKey for the object
			PyObject* value = pyKey::New(key);

			if ( value != nil )
			{
				PyObject* retVal = PyObject_CallFunction(setParams,"lO", id, value);
				if ( retVal == nil )
				{
					// if there was an error make sure that the stderr gets flushed so it can be seen
					ReportError();
				}
				Py_XDECREF(retVal);
				Py_DECREF(value);
			}
		}
	}
}

/////////////////////////////////////////////////////////////////////////////
//
//  Function   : IFindResponderAndAdd
//  PARAMETERS : ResponderName  - name of the responder to find
//
//  PURPOSE    : find a responder by name in all age and page locations
//             : and add to the Parameter list
//
void plPythonFileMod::IFindResponderAndAdd(const char *responderName, Int32 id)
{
	if ( responderName != nil )
	{
		std::vector<plKey> keylist;
		const plLocation &loc = GetKey()->GetUoid().GetLocation();
		plKeyFinder::Instance().ReallyStupidResponderSearch(responderName,keylist,loc); // use the really stupid search to find the responder
		// the keylist will be filled with all the keys that correspond to that responder
		int list_size = keylist.size();
		int i;
		for ( i=0 ; i<list_size; i++ )
		{
			plPythonParameter parm(id);
			parm.SetToResponder(keylist[i]);
			AddParameter(parm);
			ISetKeyValue(keylist[i], id);
		}
	}
}

/////////////////////////////////////////////////////////////////////////////
//
//  Function   : IFindActivatorAndAdd
//  PARAMETERS : ResponderName  - name of the responder to find
//
//  PURPOSE    : find a responder by name in all age and page locations
//             : and add to the Parameter list
//
void plPythonFileMod::IFindActivatorAndAdd(const char *activatorName, Int32 id)
{
	if ( activatorName != nil )
	{
		std::vector<plKey> keylist;
		const plLocation &loc = GetKey()->GetUoid().GetLocation();
		plKeyFinder::Instance().ReallyStupidActivatorSearch(activatorName,keylist, loc); // use the really stupid search to find the responder
		// the keylist will be filled with all the keys that correspond to that responder
		int list_size = keylist.size();
		// create the Python object that is the list, starts as empty
		int i;
		for ( i=0 ; i<list_size; i++ )
		{
			plPythonParameter parm(id);
			parm.SetToActivator(keylist[i]);
			AddParameter(parm);
			ISetKeyValue(keylist[i], id);

			// need to add ourselves as a receiver to their list
			// first see if it is an logicMod, then add to their receiver list
			plLogicModifier *logic = plLogicModifier::ConvertNoRef(keylist[i]->ObjectIsLoaded());
			if (logic)
			{
				logic->AddNotifyReceiver(this->GetKey());
			}
			else  // else might be a python file key
			{
				// next check to see if it is another PythonFileMod, and add to their notify list
				plPythonFileMod *pymod = plPythonFileMod::ConvertNoRef(keylist[i]->ObjectIsLoaded());
				if (pymod)
				{
					pymod->AddToNotifyList(this->GetKey());
				}
				else  // else maybe its just not loaded yet
				{
					// setup a ref notify when it does get loaded
					hsgResMgr::ResMgr()->AddViaNotify(keylist[i],
													TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, kAddNotify, 0),
													plRefFlags::kPassiveRef);
				}
			}
		}
	}
}

/////////////////////////////////////////////////////////////////////////////
//
//  Function   : IEval
//  PARAMETERS : secs
//               del
//               dirty
//
//  PURPOSE    : This is where the main update work is done
//    Tasks:
//      - Call the Python code's Update function (if there)
//
hsBool plPythonFileMod::IEval(double secs, hsScalar del, UInt32 dirty)
{
	if ( fModule )
	{
		// if this is the first time at the Eval, then run Python init
		if ( fIsFirstTimeEval )
		{
			fIsFirstTimeEval = false;		// no longer the first time
			// now run the __init__ function if there is one.
			// is the Update function defined and working (as far as we know)?
			if ( fPyFunctionInstances[kfunc_FirstUpdate] != nil )
			{
				plProfile_BeginTiming(PythonUpdate);
				// call it
				PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_FirstUpdate],fFunctionNames[kfunc_FirstUpdate],nil);
				if ( retVal == nil )
				{
#ifndef PLASMA_EXTERNAL_RELEASE
					// for some reason this function didn't, remember that and not call it again
					fPyFunctionInstances[kfunc_FirstUpdate] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
					// if there was an error make sure that the stderr gets flushed so it can be seen
					ReportError();
				}
				Py_XDECREF(retVal);
				plProfile_EndTiming(PythonUpdate);
				// display any output (NOTE: this would be disabled in production)
				DisplayPythonOutput();
			}
		}

		// is the Update function defined and working (as far as we know)?
		if ( fPyFunctionInstances[kfunc_Update] != nil )
		{
			plProfile_BeginTiming(PythonUpdate);
			// call it
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_Update],fFunctionNames[kfunc_Update],"df",secs,del);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_Update] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
		}
	}
	return true;
}


/////////////////////////////////////////////////////////////////////////////
//
//  Function   : MsgReceive
//  PARAMETERS : msg   - the message that came to us.
//
//  PURPOSE    : Handle all the different types of messages that we recv
//
hsBool plPythonFileMod::MsgReceive(plMessage* msg)
{
	// is it a ref message
	plGenRefMsg* genRefMsg = plGenRefMsg::ConvertNoRef(msg);
	if (genRefMsg)
	{
		// is it a ref for a named activator that we need to add to notify?
		if ((genRefMsg->GetContext() & plRefMsg::kOnCreate) && genRefMsg->fWhich == kAddNotify)
		{
			// which kind of activator is this
			plLogicModifier *logic = plLogicModifier::ConvertNoRef(genRefMsg->GetRef());
			if (logic)
			{
				logic->AddNotifyReceiver(this->GetKey());
			}
			else  // else might be a python file key
			{
				// next check to see if it is another PythonFileMod, and add to their notify list
				plPythonFileMod *pymod = plPythonFileMod::ConvertNoRef(genRefMsg->GetRef());
				if (pymod)
				{
					pymod->AddToNotifyList(this->GetKey());
				}
			}
		}
	}

	plAgeLoadedMsg* ageLoadedMsg = plAgeLoadedMsg::ConvertNoRef(msg);
	if (ageLoadedMsg && ageLoadedMsg->fLoaded)
	{
		for (int i = 0; i < fNamedCompQueue.Count(); ++i)
		{
			NamedComponent comp = fNamedCompQueue[i];
			if (comp.isActivator)
				IFindActivatorAndAdd(comp.name, comp.id);
			else
				IFindResponderAndAdd(comp.name, comp.id);

			delete [] comp.name;
		}

		fNamedCompQueue.Reset();

		plgDispatch::Dispatch()->UnRegisterForExactType( plAgeLoadedMsg::Index(), GetKey() );
	}

	// if this is a render message, then we are just trying to get a pointer to the Pipeline
	plRenderMsg *rMsg = plRenderMsg::ConvertNoRef( msg );
	if( rMsg != nil )
	{
		fPipe = rMsg->Pipeline();
		plgDispatch::Dispatch()->UnRegisterForExactType( plRenderMsg::Index(), GetKey() );
		return true;
	}

	// are they looking for an Notify message? should be coming from a proActivator
	if (fPyFunctionInstances[kfunc_Notify] != nil)
	{
		// yes, so was there actually a plActivateMsg?
		plNotifyMsg* pNtfyMsg = plNotifyMsg::ConvertNoRef(msg);
		if (pNtfyMsg)
		{
			// remember if this was a Local Broad cast or not
			fLocalNotify = (pNtfyMsg->HasBCastFlag(plMessage ::plBCastFlags::kNetNonLocal)) ? false : true;

			// create a list for the event records
			PyObject* levents = PyList_New(0); // start with a list of no elements
			// loop thought the event records to get the data and transform into python objects
			Int32 num_records = pNtfyMsg->GetEventCount();
			int j;
			for ( j=0; j<num_records; j++ )
			{
				// get an event record
				proEventData* pED = pNtfyMsg->GetEventRecord(j);
				switch ( pED->fEventType )
				{

					case proEventData::kCollision:
						{
							proCollisionEventData *eventData = (proCollisionEventData *)pED;
							// get data from the collision
							// create list
							PyObject* event = PyList_New(4);
							PyList_SetItem(event, 0, PyLong_FromLong((long)proEventData::kCollision));
							PyList_SetItem(event, 1, PyInt_FromLong(eventData->fEnter ? 1 : 0));
							PyList_SetItem(event, 2, pySceneObject::New(eventData->fHitter, fSelfKey));
							PyList_SetItem(event, 3, pySceneObject::New(eventData->fHittee, fSelfKey));
							// add this event record to the main event list (lists within a list)
							PyList_Append(levents, event);
							Py_DECREF(event);
						}
						break;
						
					case proEventData::kSpawned:
						{
							proSpawnedEventData *eventData = (proSpawnedEventData *)pED;
							PyObject* event = PyList_New(3);
							PyList_SetItem(event, 0, PyLong_FromLong((long)proEventData::kSpawned));
							PyList_SetItem(event, 1, pySceneObject::New(eventData->fSpawner, fSelfKey));
							PyList_SetItem(event, 2, pySceneObject::New(eventData->fSpawnee, fSelfKey));
							PyList_Append(levents, event);
							Py_DECREF(event);
						}
						break;

					case proEventData::kPicked:
						{
							// get data from the picked event
							proPickedEventData *eventData = (proPickedEventData *)pED;
							// create list
							PyObject* event = PyList_New(6);
							PyList_SetItem(event, 0, PyLong_FromLong((long)proEventData::kPicked));
							PyList_SetItem(event, 1, PyInt_FromLong(eventData->fEnabled ? 1 : 0));
							PyList_SetItem(event, 2, pySceneObject::New(eventData->fPicker, fSelfKey));
							PyList_SetItem(event, 3, pySceneObject::New(eventData->fPicked, fSelfKey));
							PyList_SetItem(event, 4, pyPoint3::New(eventData->fHitPoint));

							// make it in the local space
							hsPoint3 tolocal(0,0,0);
							if(eventData->fPicked)
							{
								plSceneObject* obj = plSceneObject::ConvertNoRef(eventData->fPicked->ObjectIsLoaded());
								if ( obj )
								{
									const plCoordinateInterface* ci = obj->GetCoordinateInterface();
									if ( ci )
										tolocal = (hsMatrix44)ci->GetWorldToLocal() * eventData->fHitPoint;
								}
							}
							PyList_SetItem(event, 5, pyPoint3::New(tolocal));

							// add this event record to the main event list (lists within a list)
							PyList_Append(levents, event);
							Py_DECREF(event);
						}
						break;

					case proEventData::kControlKey:
						{
							proControlKeyEventData *eventData = (proControlKeyEventData *)pED;
							// create event list
							PyObject* event = PyList_New(3);
							PyList_SetItem(event, 0, PyLong_FromLong((long)proEventData::kControlKey));
							PyList_SetItem(event, 1, PyLong_FromLong(eventData->fControlKey));
							PyList_SetItem(event, 2, PyInt_FromLong(eventData->fDown ? 1 : 0));
							// add this event record to the main event list (lists within a list)
							PyList_Append(levents, event);
							Py_DECREF(event);
						}
						break;

					case proEventData::kVariable:
						{
							proVariableEventData *eventData = (proVariableEventData *)pED;
							// create event list
							PyObject* event = PyList_New(4);
							PyList_SetItem(event, 0, PyLong_FromLong((long)proEventData::kVariable));
							PyList_SetItem(event, 1, PyString_FromString(eventData->fName));
							PyList_SetItem(event, 2, PyLong_FromLong(eventData->fDataType));
							
							// depending on the data type create the data
							switch ( eventData->fDataType )
							{
								case proEventData::kFloat:
									PyList_SetItem(event, 3, PyFloat_FromDouble(eventData->fNumber.f));
									break;
								case proEventData::kKey:
									PyList_SetItem(event, 3, pyKey::New(eventData->fKey));
									break;
								case proEventData::kInt:
									PyList_SetItem(event, 3, PyInt_FromLong(eventData->fNumber.i));
									break;
								default:
									Py_XINCREF(Py_None);
									PyList_SetItem(event, 3, Py_None);
									break;
							}
							// add this event record to the main event list (lists within a list)
							PyList_Append(levents, event);
							Py_DECREF(event);
						}
						break;

					case proEventData::kFacing:
						{
							proFacingEventData *eventData = (proFacingEventData *)pED;
							// create event list
							PyObject* event = PyList_New(5);
							PyList_SetItem(event, 0, PyLong_FromLong((long)proEventData::kFacing));
							PyList_SetItem(event, 1, PyInt_FromLong(eventData->enabled ? 1 : 0));
							PyList_SetItem(event, 2, pySceneObject::New(eventData->fFacer, fSelfKey));
							PyList_SetItem(event, 3, pySceneObject::New(eventData->fFacee, fSelfKey));
							PyList_SetItem(event, 4, PyFloat_FromDouble(eventData->dot));
							// add this event record to the main event list (lists within a list)
							PyList_Append(levents, event);
							Py_DECREF(event);
						}
						break;

					case proEventData::kContained:
						{
							proContainedEventData *eventData = (proContainedEventData *)pED;
							// create event list
							PyObject* event = PyList_New(4);
							PyList_SetItem(event, 0, PyLong_FromLong((long)proEventData::kContained));
							PyList_SetItem(event, 1, PyInt_FromLong(eventData->fEntering ? 1 : 0));
							PyList_SetItem(event, 2, pySceneObject::New(eventData->fContained, fSelfKey));
							PyList_SetItem(event, 3, pySceneObject::New(eventData->fContainer, fSelfKey));
							// add this event record to the main event list (lists within a list)
							PyList_Append(levents, event);
							Py_DECREF(event);
						}
						break;

					case proEventData::kActivate:
						{
							proActivateEventData *eventData = (proActivateEventData *)pED;
							// create event list
							PyObject* event = PyList_New(3);
							PyList_SetItem(event, 0, PyLong_FromLong((long)proEventData::kActivate));
							PyList_SetItem(event, 1, PyInt_FromLong(eventData->fActive ? 1 : 0));
							PyList_SetItem(event, 2, PyInt_FromLong(eventData->fActivate ? 1 : 0));
							// add this event record to the main event list (lists within a list)
							PyList_Append(levents, event);
							Py_DECREF(event);
						}
						break;

					case proEventData::kCallback:
						{
							proCallbackEventData *eventData = (proCallbackEventData *)pED;
							// create event list
							PyObject* event = PyList_New(2);
							PyList_SetItem(event, 0, PyLong_FromLong((long)proEventData::kCallback));
							PyList_SetItem(event, 1, PyLong_FromLong(eventData->fEventType));
							// add this event record to the main event list (lists within a list)
							PyList_Append(levents, event);
							Py_DECREF(event);
						}
						break;

					case proEventData::kResponderState:
						{
							proResponderStateEventData *eventData = (proResponderStateEventData *)pED;
							// create event list
							PyObject* event = PyList_New(2);
							PyList_SetItem(event, 0, PyLong_FromLong((long)proEventData::kResponderState));
							PyList_SetItem(event, 1, PyLong_FromLong(eventData->fState));
							// add this event record to the main event list (lists within a list)
							PyList_Append(levents, event);
							Py_DECREF(event);
						}
						break;

					case proEventData::kMultiStage:
						{
							proMultiStageEventData *eventData = (proMultiStageEventData *)pED;
							// create event list
							PyObject* event = PyList_New(4);
							PyList_SetItem(event, 0, PyLong_FromLong((long)proEventData::kMultiStage));
							PyList_SetItem(event, 1, PyLong_FromLong(eventData->fStage));
							PyList_SetItem(event, 2, PyLong_FromLong(eventData->fEvent));
							PyList_SetItem(event, 3, pySceneObject::New(eventData->fAvatar, fSelfKey));
							// add this event record to the main event list (lists within a list)
							PyList_Append(levents, event);
							Py_DECREF(event);
						}
						break;
					case proEventData::kOfferLinkingBook:
						{
							proOfferLinkingBookEventData* eventData = (proOfferLinkingBookEventData*)pED;
							// create event list
							PyObject* event = PyList_New(4);
							PyList_SetItem(event, 0, PyLong_FromLong((long)proEventData::kOfferLinkingBook));
							PyList_SetItem(event, 1, pySceneObject::New(eventData->offerer, fSelfKey));
							PyList_SetItem(event, 2, PyInt_FromLong(eventData->targetAge));
							PyList_SetItem(event, 3, PyInt_FromLong(eventData->offeree));
							PyList_Append(levents, event);
							Py_DECREF(event);
						}
						break;
					case proEventData::kBook:
						{
							proBookEventData* eventData = (proBookEventData*)pED;
							// create event list
							PyObject* event = PyList_New(3);
							PyList_SetItem(event, 0, PyLong_FromLong((long)proEventData::kBook));
							PyList_SetItem(event, 1, PyLong_FromUnsignedLong(eventData->fEvent));
							PyList_SetItem(event, 2, PyLong_FromUnsignedLong(eventData->fLinkID));
							PyList_Append(levents, event);
							Py_DECREF(event);
						}
						break;
				}
			}

			// Need to determine which of the Activators sent this plNotifyMsg
			// and set the ID appropriately
			Int32 id = -1;	// assume that none was found
			if ( pNtfyMsg->GetSender() != nil )
			{
				// loop throught the parameters and set them by id
				// (will need to create the appropiate Python object for each type)
				int npm;
				for ( npm=0; npm<GetParameterListCount() ; npm++ )
				{
					plPythonParameter parameter = GetParameterItem(npm);
					// is it something that could produce a plNotifiyMsg?
					if ( parameter.fValueType == plPythonParameter::kActivatorList
					   	|| parameter.fValueType == plPythonParameter::kBehavior 
						|| parameter.fValueType == plPythonParameter::kResponderList )
					{
						// is there an actual ObjectKey to look at?
					    if (parameter.fObjectKey != nil )
						{
							// is it the same as the sender of the notify message?
							if ( pNtfyMsg->GetSender()->GetUoid() == parameter.fObjectKey->GetUoid() )
							{
								// match! Then return that as the ID
								id = parameter.fID;
							}
						}
					}
				}
			}



			// call it
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_Notify],fFunctionNames[kfunc_Notify],
						"flO",pNtfyMsg->fState,id,levents);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_Notify] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			Py_DECREF(levents);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}

	// are they looking for a key event message?
	if (fPyFunctionInstances[kfunc_OnKeyEvent] != nil)
	{
		// we are looking for collision messages, is it one?
		plControlEventMsg* pEMsg = plControlEventMsg::ConvertNoRef(msg);
		if (pEMsg)
		{
			// call it
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_OnKeyEvent],fFunctionNames[kfunc_OnKeyEvent],
						"ll",pEMsg->GetControlCode(),pEMsg->ControlActivated());
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_OnKeyEvent] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}

	}

	// are they looking for an Timer message?
	if (fPyFunctionInstances[kfunc_AtTimer])
	{
		// yes, so was there actually a plActivateMsg?
		plTimerCallbackMsg* pTimerMsg = plTimerCallbackMsg::ConvertNoRef(msg);
		if (pTimerMsg)
		{
			// yes...
			// call it
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_AtTimer],fFunctionNames[kfunc_AtTimer],
						"l",pTimerMsg->fID);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_AtTimer] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}

	// are they looking for an GUINotify message?
	if (fPyFunctionInstances[kfunc_GUINotify])
	{
		// yes, so was there actually a plActivateMsg?
		pfGUINotifyMsg* pGUIMsg = pfGUINotifyMsg::ConvertNoRef(msg);
		if (pGUIMsg)
		{
			// yes...
			// call it ... but first create the control that started this mess
			// create the key
			PyObject* pyControl = nil;
			if ( pGUIMsg->GetControlKey() )		// make sure there is a control key
			{
				// now create the control... but first we need to find out what it is
				PyObject* pyCtrlKey = pyKey::New(pGUIMsg->GetControlKey());
				UInt32 control_type = pyGUIDialog::WhatControlType(*(pyKey::ConvertFrom(pyCtrlKey)));
				Py_DECREF(pyCtrlKey);

				switch (control_type)
				{
					case pyGUIDialog::kDialog:
						pyControl = pyGUIDialog::New(pGUIMsg->GetControlKey());
						break;

					case pyGUIDialog::kButton:
						pyControl = pyGUIControlButton::New(pGUIMsg->GetControlKey());
						break;

					case pyGUIDialog::kListBox:
						pyControl = pyGUIControlListBox::New(pGUIMsg->GetControlKey());
						break;

					case pyGUIDialog::kTextBox:
						pyControl = pyGUIControlTextBox::New(pGUIMsg->GetControlKey());
						break;

					case pyGUIDialog::kEditBox:
						pyControl = pyGUIControlEditBox::New(pGUIMsg->GetControlKey());
						break;

					case pyGUIDialog::kUpDownPair:
					case pyGUIDialog::kKnob:
						pyControl = pyGUIControlValue::New(pGUIMsg->GetControlKey());
						break;

					case pyGUIDialog::kCheckBox:
						pyControl = pyGUIControlCheckBox::New(pGUIMsg->GetControlKey());
						break;

					case pyGUIDialog::kRadioGroup:
						pyControl = pyGUIControlRadioGroup::New(pGUIMsg->GetControlKey());
						break;

					case pyGUIDialog::kDynamicText:
						pyControl = pyGUIControlDynamicText::New(pGUIMsg->GetControlKey());
						break;

					case pyGUIDialog::kMultiLineEdit:
						pyControl = pyGUIControlMultiLineEdit::New(pGUIMsg->GetControlKey());
						break;

					case pyGUIDialog::kPopUpMenu:
						pyControl = pyGUIPopUpMenu::New(pGUIMsg->GetControlKey());
						break;

					case pyGUIDialog::kClickMap:
						pyControl = pyGUIControlClickMap::New(pGUIMsg->GetControlKey());
						break;

					default:
						// we don't know what it is... just send 'em the pyKey
						pyControl = pyKey::New(pGUIMsg->GetControlKey());
						break;

				}
			}
			// Need to determine which of the GUIDialogs sent this plGUINotifyMsg
			// and set the ID appropriately
			Int32 id = -1;	// assume that none was found
			if ( pGUIMsg->GetSender() != nil )
			{
				// loop throught the parameters and set them by id
				// (will need to create the appropiate Python object for each type)
				int npm;
				for ( npm=0; npm<GetParameterListCount() ; npm++ )
				{
					plPythonParameter parameter = GetParameterItem(npm);
					// is it something that could produce a plNotifiyMsg?
					if ( parameter.fValueType == plPythonParameter::kGUIDialog || parameter.fValueType == plPythonParameter::kGUIPopUpMenu )
					{
						// is there an actual ObjectKey to look at?
					    if (parameter.fObjectKey != nil )
						{
							// is it the same of the sender of the notify message?
							if ( pGUIMsg->GetSender()->GetUoid() == parameter.fObjectKey->GetUoid() )
							{
								// match! then set the ID to what the parameter is, so the python programmer can find it
								id = parameter.fID;
							}
						}
					}
				}
			}

			// make sure that we found a control to go with this
			if ( pyControl == nil )
			{
				// if none then return a Python None object
				Py_INCREF(Py_None);
				pyControl = Py_None;
			}

			// call their OnGUINotify method
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_GUINotify],fFunctionNames[kfunc_GUINotify],
						"lOl",id,pyControl,pGUIMsg->GetEvent() );
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_GUINotify] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			Py_DECREF(pyControl);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}

	// are they looking for an RoomLoadNotify message?
	if (fPyFunctionInstances[kfunc_PageLoad])
	{
		// yes, so was there actually a plRoomLoadNotifyMsg?
		plRoomLoadNotifyMsg* pRLNMsg = plRoomLoadNotifyMsg::ConvertNoRef(msg);
		if (pRLNMsg)
		{
			// yes...
			// call it
			char* roomname = "";
			if ( pRLNMsg->GetRoom() != nil )
				roomname = (char*)pRLNMsg->GetRoom()->GetName();

			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_PageLoad],fFunctionNames[kfunc_PageLoad],
						"ls",pRLNMsg->GetWhatHappen(),roomname);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_PageLoad] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}


	// are they looking for an ClothingUpdate message?
	if (fPyFunctionInstances[kfunc_ClothingUpdate])
	{
		// yes, so was there actually a plClothingUpdateBCMsg?
		plClothingUpdateBCMsg* pCUMsg = plClothingUpdateBCMsg::ConvertNoRef(msg);
		if (pCUMsg)
		{
			// yes...
			// call it
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_ClothingUpdate],fFunctionNames[kfunc_ClothingUpdate],nil);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_ClothingUpdate] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}

	// are they looking for an KIMsg message?
	if (fPyFunctionInstances[kfunc_KIMsg])
	{
		// yes, so was there actually a pfKIMsg?
		pfKIMsg* pkimsg = pfKIMsg::ConvertNoRef(msg);
		if (pkimsg && pkimsg->GetCommand() != pfKIMsg::kHACKChatMsg)
		{
			// yes...
			// find the value that would go with a command
			PyObject* value;
			std::wstring str;
			switch (pkimsg->GetCommand())
			{
				case pfKIMsg::kSetChatFadeDelay:
					value = PyFloat_FromDouble(pkimsg->GetDelay());
					break;
				case pfKIMsg::kSetTextChatAdminMode:
					value = PyLong_FromLong(pkimsg->GetFlags()&pfKIMsg::kAdminMsg ? 1 : 0 );
					break;
				case pfKIMsg::kYesNoDialog:
					value = PyTuple_New(2);
					str = pkimsg->GetStringU();
					PyTuple_SetItem(value, 0, PyUnicode_FromWideChar(str.c_str(), str.length()));
					PyTuple_SetItem(value, 1, pyKey::New(pkimsg->GetSender()));
					break;
				case pfKIMsg::kGZInRange:
					value = PyTuple_New(2);
					PyTuple_SetItem(value, 0, PyLong_FromLong(pkimsg->GetIntValue()));
					PyTuple_SetItem(value, 1, pyKey::New(pkimsg->GetSender()));
					break;
				case pfKIMsg::kRateIt:
					value = PyTuple_New(3);
					str = pkimsg->GetStringU();
					PyTuple_SetItem(value,0,PyString_FromString(pkimsg->GetUser()));
					PyTuple_SetItem(value,1,PyUnicode_FromWideChar(str.c_str(), str.length()));
					PyTuple_SetItem(value,2,PyLong_FromLong(pkimsg->GetIntValue()));
					break;
				case pfKIMsg::kRegisterImager:
					value = PyTuple_New(2);
					str = pkimsg->GetStringU();
					PyTuple_SetItem(value, 0, PyUnicode_FromWideChar(str.c_str(), str.length()));
					PyTuple_SetItem(value, 1, pyKey::New(pkimsg->GetSender()));
					break;
				case pfKIMsg::kAddPlayerDevice:
				case pfKIMsg::kRemovePlayerDevice:
					{
						str = pkimsg->GetStringU();
						if ( str.length() > 0 )
							value = PyUnicode_FromWideChar(str.c_str(), str.length());
						else
						{
							Py_INCREF(Py_None);
							value = Py_None;
						}
					}
					break;
				case pfKIMsg::kKIChatStatusMsg:
				case pfKIMsg::kKILocalChatStatusMsg:
				case pfKIMsg::kKILocalChatErrorMsg:
				case pfKIMsg::kKIOKDialog:
				case pfKIMsg::kKIOKDialogNoQuit:
				case pfKIMsg::kGZFlashUpdate:
				case pfKIMsg::kKICreateMarkerNode:
					str = pkimsg->GetStringU();
					value = PyUnicode_FromWideChar(str.c_str(), str.length());
					break;
				case pfKIMsg::kMGStartCGZGame:
				case pfKIMsg::kMGStopCGZGame:
				case pfKIMsg::kFriendInviteSent:
				default:
					value = PyLong_FromLong(pkimsg->GetIntValue());
					break;
			}

			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_KIMsg],fFunctionNames[kfunc_KIMsg],
						"lO",pkimsg->GetCommand(),value);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_KIMsg] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			Py_DECREF(value);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}

	// are they looking for an MemberUpdate message?
	if (fPyFunctionInstances[kfunc_MemberUpdate])
	{
		// yes, so was there actually a plMemberUpdateMsg?
		plMemberUpdateMsg* pmumsg = plMemberUpdateMsg::ConvertNoRef(msg);
		if (pmumsg)
		{
			// yes... then call it
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_MemberUpdate],fFunctionNames[kfunc_MemberUpdate],nil);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_MemberUpdate] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}

	// are they looking for a RemoteAvatar Info message?
	if (fPyFunctionInstances[kfunc_RemoteAvatarInfo])
	{
		// yes, so was there actually a plActivateMsg?
		plRemoteAvatarInfoMsg* pramsg = plRemoteAvatarInfoMsg::ConvertNoRef(msg);
		if (pramsg)
		{
			// yes...
			PyObject* player;
			// if there was no avatar key in the message
			if ( pramsg->GetAvatarKey() == nil )
			{
				// then just return a None... same thing as nil.. which I guess means a non-avatar is selected
				player = PyInt_FromLong(0);
			}
			else
			{
				// try to create the pyPlayer for where this message came from
				int mbrIndex = plNetClientMgr::GetInstance()->TransportMgr().FindMember(pramsg->GetAvatarKey());
				if ( mbrIndex != -1 )
				{
					plNetTransportMember *mbr = plNetClientMgr::GetInstance()->TransportMgr().GetMember( mbrIndex );
					player = pyPlayer::New(mbr->GetAvatarKey(), mbr->GetPlayerName(), mbr->GetPlayerID(), mbr->GetDistSq());
				}
				else
				{
					// else if we could not find the player in our list, then no avatar selected
					player = PyInt_FromLong(0);
				}
			}

			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_RemoteAvatarInfo],fFunctionNames[kfunc_RemoteAvatarInfo],
						"O",player);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_RemoteAvatarInfo] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			Py_DECREF(player);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}


	// are they looking for a CCR communication message?
	if (fPyFunctionInstances[kfunc_OnCCRMsg])
	{
		// yes, so was there actually a plActivateMsg?
		plCCRCommunicationMsg* ccrmsg = plCCRCommunicationMsg::ConvertNoRef(msg);
		if (ccrmsg)
		{
			const char* textmessage = ccrmsg->GetMessage();
			if ( textmessage == nil)
				textmessage = "";
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_OnCCRMsg],fFunctionNames[kfunc_OnCCRMsg],
						"lsl",ccrmsg->GetType(),textmessage,ccrmsg->GetCCRPlayerID());
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_OnCCRMsg] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}


	// are they looking for a VaultNotify message?
	if (fPyFunctionInstances[kfunc_OnVaultNotify])
	{
		// yes, so was there actually a plVaultNotifyMsg?
		if (plVaultNotifyMsg * vaultNotifyMsg = plVaultNotifyMsg::ConvertNoRef(msg))
		{
			if ( hsSucceeded( vaultNotifyMsg->GetResultCode() ) )
			{
				// Create a tuple for second argument according to msg type.
				// Default to an empty tuple.
				PyObject* ptuple = PyTuple_New(0);
				switch ( vaultNotifyMsg->GetType() )
				{
					case plVaultNotifyMsg::kRegisteredOwnedAge:
					case plVaultNotifyMsg::kRegisteredVisitAge:
					case plVaultNotifyMsg::kUnRegisteredOwnedAge:
					case plVaultNotifyMsg::kUnRegisteredVisitAge: {
						if (RelVaultNode * rvn = VaultGetNodeIncRef(vaultNotifyMsg->GetArgs()->GetInt(plNetCommon::VaultTaskArgs::kAgeLinkNode))) {
							Py_DECREF(ptuple);
							ptuple = PyTuple_New(1);
							PyTuple_SetItem(ptuple, 0, pyVaultAgeLinkNode::New(rvn));
							rvn->DecRef();
						}
					}
					break;
					
					case plVaultNotifyMsg::kPublicAgeCreated:
					case plVaultNotifyMsg::kPublicAgeRemoved: {
						if (const char * ageName = vaultNotifyMsg->GetArgs()->GetString(plNetCommon::VaultTaskArgs::kAgeFilename)) {
							Py_DECREF(ptuple);
							ptuple = PyTuple_New(1);
							PyTuple_SetItem(ptuple, 0, PyString_FromString(ageName));
						}
					}
					break;
				}

				plProfile_BeginTiming(PythonUpdate);
				PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_OnVaultNotify],fFunctionNames[kfunc_OnVaultNotify],
							"lO",vaultNotifyMsg->GetType(),ptuple);
				if ( retVal == nil )
				{
#ifndef PLASMA_EXTERNAL_RELEASE
					// for some reason this function didn't, remember that and not call it again
					fPyFunctionInstances[kfunc_OnVaultNotify] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
					// if there was an error make sure that the stderr gets flushed so it can be seen
					ReportError();
				}
				Py_XDECREF(retVal);
				Py_DECREF(ptuple);
				plProfile_EndTiming(PythonUpdate);
				// display any output (NOTE: this would be disabled in production)
				DisplayPythonOutput();
				// we handled this message (I think)
			}
			return true;
		}
	}

	
	// are they looking for a RealTimeChat message?
	if (fPyFunctionInstances[kfunc_RTChat])
	{
		// yes, so was there actually a pfKIMsg?
		pfKIMsg* pkimsg = pfKIMsg::ConvertNoRef(msg);
		if (pkimsg && pkimsg->GetCommand() == pfKIMsg::kHACKChatMsg)
		{
			// yes...
			// filter ignored player
			if ( !VaultAmIgnoringPlayer( pkimsg->GetPlayerID() ) )
			{
				// create the pyPlayer for where this message came from
				PyObject* player;
				PyObject* ptPlayerClass = PythonInterface::GetPlasmaItem("ptPlayer");
				hsAssert(ptPlayerClass,"Could not create a ptPlayer");
				int mbrIndex = plNetClientMgr::GetInstance()->TransportMgr().FindMember(pkimsg->GetPlayerID());
				if ( mbrIndex != -1 )
				{
					plNetTransportMember *mbr = plNetClientMgr::GetInstance()->TransportMgr().GetMember( mbrIndex );
					player = pyPlayer::New(mbr->GetAvatarKey(), pkimsg->GetUser(), mbr->GetPlayerID(), mbr->GetDistSq());
				}
				else
				{
					// else if we could not find the player in our list, then just return a string of the user's name
					const char * fromName = pkimsg->GetUser();
					if (!fromName)
						fromName = "Anonymous Coward";
					player = pyPlayer::New(plNetClientMgr::GetInstance()->GetLocalPlayerKey(), fromName, pkimsg->GetPlayerID(), 0.0);
				}

				plProfile_BeginTiming(PythonUpdate);
				PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_RTChat],fFunctionNames[kfunc_RTChat],
							"Osl",player,pkimsg->GetString().c_str(),pkimsg->GetFlags());
				if ( retVal == nil )
				{
#ifndef PLASMA_EXTERNAL_RELEASE
					// for some reason this function didn't, remember that and not call it again
					fPyFunctionInstances[kfunc_RTChat] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
					// if there was an error make sure that the stderr gets flushed so it can be seen
					ReportError();
				}
				Py_XDECREF(retVal);
				Py_DECREF(player);
				plProfile_EndTiming(PythonUpdate);
				// display any output (NOTE: this would be disabled in production)
				DisplayPythonOutput();
				// we handled this message (I think)
				return true;
			}
		}
	}
	if (plPlayerPageMsg::ConvertNoRef(msg))
	{
		if (fPyFunctionInstances[kfunc_AvatarPage])
		{
			// yes, so was there actually a player page msg
			plPlayerPageMsg* ppMsg = plPlayerPageMsg::ConvertNoRef(msg);
			if (ppMsg)
			{
				PyObject* pSobj = pySceneObject::New(ppMsg->fPlayer, fSelfKey);
				plProfile_BeginTiming(PythonUpdate);
				plSynchEnabler ps(true);	// enable dirty state tracking during shutdown	
	
				PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_AvatarPage],fFunctionNames[kfunc_AvatarPage],
							"Oli",pSobj,!ppMsg->fUnload,ppMsg->fLastOut);
				if ( retVal == nil )
				{
	#ifndef PLASMA_EXTERNAL_RELEASE
					// for some reason this function didn't, remember that and not call it again
					fPyFunctionInstances[kfunc_AvatarPage] = nil;
	#endif  //PLASMA_EXTERNAL_RELEASE
					// if there was an error make sure that the stderr gets flushed so it can be seen
					ReportError();
				}
				Py_XDECREF(retVal);
				Py_DECREF(pSobj);
				plProfile_EndTiming(PythonUpdate);
				// display any output (NOTE: this would be disabled in production)
				DisplayPythonOutput();
				// we handled this message (I think)
				return true;
			}
		}
	}
	if (plAgeBeginLoadingMsg::ConvertNoRef(msg))
	{
		if (fPyFunctionInstances[kfunc_OnBeginAgeLoad])
		{
			// yes, so was there actually a player page msg
			plAgeBeginLoadingMsg* ppMsg = plAgeBeginLoadingMsg::ConvertNoRef(msg);
			if (ppMsg)
			{
				PyObject* pSobj = pySceneObject::New(plNetClientMgr::GetInstance()->GetLocalPlayerKey(), fSelfKey);
				plProfile_BeginTiming(PythonUpdate);
				plSynchEnabler ps(true);	// enable dirty state tracking during shutdown	
	
				PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_OnBeginAgeLoad],fFunctionNames[kfunc_OnBeginAgeLoad],
							"O",pSobj);
				if ( retVal == nil )
				{
	#ifndef PLASMA_EXTERNAL_RELEASE
					// for some reason this function didn't, remember that and not call it again
					fPyFunctionInstances[kfunc_OnBeginAgeLoad] = nil;
	#endif  //PLASMA_EXTERNAL_RELEASE
					// if there was an error make sure that the stderr gets flushed so it can be seen
					ReportError();
				}
				Py_XDECREF(retVal);
				Py_DECREF(pSobj);
				plProfile_EndTiming(PythonUpdate);
				// display any output (NOTE: this would be disabled in production)
				DisplayPythonOutput();
				// we handled this message (I think)
				return true;
			}
		}
	}
	if (plInitialAgeStateLoadedMsg::ConvertNoRef(msg))// initial server update complete message
	{
		// make sure there is a valid python instance
		if ( fInstance )
		{
			// set the isInitialStateLoaded to that it is loaded
			PyObject* pInitialState = PyInt_FromLong(1);
			PyObject_SetAttrString(fInstance, "isInitialStateLoaded", pInitialState);
			Py_DECREF(pInitialState);
		}
		if (fPyFunctionInstances[kfunc_OnServerInitComplete])
		{
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_OnServerInitComplete],fFunctionNames[kfunc_OnServerInitComplete],nil);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
					// for some reason this function didn't, remember that and not call it again
					fPyFunctionInstances[kfunc_OnServerInitComplete] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
					// if there was an error make sure that the stderr gets flushed so it can be seen
					ReportError();
			}
			Py_XDECREF(retVal);

			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}
	// are they looking for an plSDLNotificationMsg message?
	if (fPyFunctionInstances[kfunc_SDLNotify])
	{
		// yes, so was there actually a plSDLNotificationMsg?
		plSDLNotificationMsg* sn = plSDLNotificationMsg::ConvertNoRef(msg);
		if (sn)
		{
			const char* tag = sn->fHintString.c_str();
			if (tag == nil)
				tag = "";
			// yes... then call it
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_SDLNotify],fFunctionNames[kfunc_SDLNotify],
						"ssls",sn->fVar->GetName(),sn->fSDLName.c_str(),sn->fPlayerID,tag);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_SDLNotify] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}
	// are they looking for an plNetOwnershipMsg message?
	if (fPyFunctionInstances[kfunc_OwnershipNotify])
	{
		// yes, so was there actually a plNetOwnershipMsg?
		plNetOwnershipMsg* nom = plNetOwnershipMsg::ConvertNoRef(msg);
		if (nom)
		{
			// yes... then call it
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_OwnershipNotify],fFunctionNames[kfunc_OwnershipNotify],
						nil);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_OwnershipNotify] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}
	// are they looking for an pfMarkerMsg message?
	if (fPyFunctionInstances[kfunc_OnMarkerMsg])
	{
		pfMarkerMsg* markermsg = pfMarkerMsg::ConvertNoRef(msg);
		if (markermsg)
		{
			// yes... then call it
			plProfile_BeginTiming(PythonUpdate);
			// Default to an empty tuple.
			PyObject* ptuple = PyTuple_New(0);
			switch ( markermsg->fType )
			{
				case pfMarkerMsg::kMarkerCaptured:
					// Sent when we collide with a marker
					Py_DECREF(ptuple);
					ptuple = PyTuple_New(1);
					PyTuple_SetItem(ptuple, 0, PyLong_FromUnsignedLong((long)markermsg->fMarkerID));
					break;
			}

			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_OnMarkerMsg], fFunctionNames[kfunc_OnMarkerMsg],
						"lO", (UInt32)markermsg->fType, ptuple);
			if (retVal == nil)
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_OnMarkerMsg] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			Py_DECREF(ptuple);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}

#ifndef PLASMA_EXTERNAL_RELEASE
	// are they looking for an pfDebugTriggerMsg message?
	if (fPyFunctionInstances[kfunc_OnBackdoorMsg])
	{
		// yes, so was there actually a plNetOwnershipMsg?
		pfBackdoorMsg* dt = pfBackdoorMsg::ConvertNoRef(msg);
		if (dt)
		{
			// yes... then call it
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_OnBackdoorMsg],
						fFunctionNames[kfunc_OnBackdoorMsg],
						"ss",dt->GetTarget(),dt->GetString());
			if ( retVal == nil )
			{
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}
#endif  //PLASMA_EXTERNAL_RELEASE

	// are they looking for a plLOSHitMsg message?
	if (fPyFunctionInstances[kfunc_OnLOSNotify])
	{
		// yes, so was there actually a plLOSHitMsg?
		plLOSHitMsg *pLOSMsg = plLOSHitMsg::ConvertNoRef( msg );
		if (pLOSMsg)
		{
			// yes... then call it (self,ID,noHitFlag,sceneobject,hitPoint,distance)
			plProfile_BeginTiming(PythonUpdate);
			PyObject* scobj;
			PyObject* hitpoint;
			if ( pLOSMsg->fObj && plSceneObject::ConvertNoRef( pLOSMsg->fObj->ObjectIsLoaded()) )
			{
				scobj = pySceneObject::New(pLOSMsg->fObj);
				hitpoint = pyPoint3::New(pLOSMsg->fHitPoint);
			}
			else
			{
				// otherwise return a None object for the avatarKey
				Py_INCREF(Py_None);
				scobj = Py_None;
				Py_INCREF(Py_None);
				hitpoint = Py_None;
			}
					
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_OnLOSNotify],
						fFunctionNames[kfunc_OnLOSNotify],
						"llOOf",pLOSMsg->fRequestID,pLOSMsg->fNoHit,
						scobj, hitpoint, pLOSMsg->fDistance);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_OnLOSNotify] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			Py_DECREF(scobj);
			Py_DECREF(hitpoint);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}

	// are they looking for a plAvatarBehaviorNotifyMsg message?
	if (fPyFunctionInstances[kfunc_OnBehaviorNotify])
	{
		// yes, so was there actually a plAvatarBehaviorNotifyMsg?
		plAvatarBehaviorNotifyMsg *behNotifymsg = plAvatarBehaviorNotifyMsg::ConvertNoRef(msg);
		if (behNotifymsg)
		{
			// yes... then call it
			plProfile_BeginTiming(PythonUpdate);
			// the parent of the sender should be the avatar that did the behavior
			PyObject* pSobj;
				
			plModifier* avmod = plModifier::ConvertNoRef(behNotifymsg->GetSender()->ObjectIsLoaded());
			if ( avmod && avmod->GetNumTargets() > 0 )
			{
				pSobj = pySceneObject::New(avmod->GetTarget(0)->GetKey(), fSelfKey);
			}
			else
			{
				// otherwise return a None object for the avatarKey
				Py_INCREF(Py_None);
				pSobj = Py_None;
			}
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_OnBehaviorNotify],
						fFunctionNames[kfunc_OnBehaviorNotify],
						"lOl",behNotifymsg->fType,pSobj,behNotifymsg->state);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_OnBehaviorNotify] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			Py_DECREF(pSobj);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}

	// are they looking for a pfMovieEventMsg message?
	if (fPyFunctionInstances[kfunc_OnMovieEvent])
	{
		// yes, so was there actually a pfMovieEventMsg?
		pfMovieEventMsg *moviemsg = pfMovieEventMsg::ConvertNoRef(msg);
		if (moviemsg)
		{
			// yes... then call it
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_OnMovieEvent],
						fFunctionNames[kfunc_OnMovieEvent],
						"si",moviemsg->fMovieName,(UInt32)moviemsg->fReason);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_OnMovieEvent] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}

	// are they looking for a plCaptureRenderMsg message?
	if (fPyFunctionInstances[kfunc_OnScreenCaptureDone])
	{
		// yes, so was there actually a pfMovieEventMsg?
		plCaptureRenderMsg *capturemsg = plCaptureRenderMsg::ConvertNoRef(msg);
		if (capturemsg)
		{
			// yes... then call it
			plProfile_BeginTiming(PythonUpdate);
			PyObject* pSobj;
				
			if ( capturemsg->GetMipmap() )
			{
				pSobj = pyImage::New(capturemsg->GetMipmap());
			}
			else
			{
				// otherwise return a None object for the avatarKey
				Py_INCREF(Py_None);
				pSobj = Py_None;
			}
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_OnScreenCaptureDone],
						fFunctionNames[kfunc_OnScreenCaptureDone],
						"O",pSobj);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_OnScreenCaptureDone] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			Py_DECREF(pSobj);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();
			// we handled this message (I think)
			return true;
		}
	}

	if (fPyFunctionInstances[kfunc_OnClimbBlockerEvent])
	{
		plClimbEventMsg* pEvent = plClimbEventMsg::ConvertNoRef(msg);
		if (pEvent)
		{
			PyObject* pSobj = pySceneObject::New(pEvent->GetSender(), fSelfKey);
			
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_OnClimbBlockerEvent],
						fFunctionNames[kfunc_OnClimbBlockerEvent],
						"O",pSobj);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_OnClimbBlockerEvent] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			Py_DECREF(pSobj);
			return true;
		}
	}
	if (fPyFunctionInstances[kfunc_OnAvatarSpawn])
	{
		plAvatarSpawnNotifyMsg* pSpawn = plAvatarSpawnNotifyMsg::ConvertNoRef(msg);
		if (pSpawn)
		{
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_OnAvatarSpawn],
						fFunctionNames[kfunc_OnAvatarSpawn],
						"l",1);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_OnAvatarSpawn] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			return true;
		}
	}
	
	if (fPyFunctionInstances[kfunc_OnAccountUpdate])
	{
		plAccountUpdateMsg* pUpdateMsg = plAccountUpdateMsg::ConvertNoRef(msg);
		if (pUpdateMsg)
		{
			plProfile_BeginTiming(PythonUpdate);
			PyObject* retVal = PyObject_CallMethod(fPyFunctionInstances[kfunc_OnAccountUpdate], fFunctionNames[kfunc_OnAccountUpdate],
				"iii", (int)pUpdateMsg->GetUpdateType(), (int)pUpdateMsg->GetResult(), (int)pUpdateMsg->GetPlayerInt()
			);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_OnAccountUpdate] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();

			return true;
		}
	}

	if (fPyFunctionInstances[kfunc_gotPublicAgeList])
	{
		plNetCommPublicAgeListMsg * pPubAgeMsg = plNetCommPublicAgeListMsg::ConvertNoRef(msg);
		if (pPubAgeMsg)
		{
			plProfile_BeginTiming(PythonUpdate);
			PyObject* pyEL = PyList_New(pPubAgeMsg->ages.Count());
			for (unsigned i = 0; i<pPubAgeMsg->ages.Count(); ++i) {
				plAgeInfoStruct ageInfo;
				ageInfo.CopyFrom(pPubAgeMsg->ages[i]);
				unsigned nPlayers = pPubAgeMsg->ages[i].currentPopulation;
				unsigned nOwners = pPubAgeMsg->ages[i].population;
				
				PyObject* t = PyTuple_New(3);
				PyTuple_SetItem(t, 0, pyAgeInfoStruct::New(&ageInfo));
				PyTuple_SetItem(t, 1, PyLong_FromUnsignedLong(nPlayers));
				PyTuple_SetItem(t, 2, PyLong_FromUnsignedLong(nOwners));
				PyList_SetItem(pyEL, i, t); // steals the ref
			}
			
			PyObject* retVal = PyObject_CallMethod(
				fPyFunctionInstances[kfunc_gotPublicAgeList],
				fFunctionNames[kfunc_gotPublicAgeList],
				"O",
				pyEL
			);
			if ( retVal == nil )
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_gotPublicAgeList] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			plProfile_EndTiming(PythonUpdate);
			// display any output (NOTE: this would be disabled in production)
			DisplayPythonOutput();

			return true;
		}
	}

	if (fPyFunctionInstances[kfunc_OnGameMgrMsg])
	{
		pfGameMgrMsg* gameMgrMsg = pfGameMgrMsg::ConvertNoRef(msg);
		if (gameMgrMsg)
		{
			plProfile_BeginTiming(PythonUpdate);
			PyObject* pythonMsg = pyGameMgrMsg::New(gameMgrMsg);
			PyObject* retVal = PyObject_CallMethod(
				fPyFunctionInstances[kfunc_OnGameMgrMsg],
				fFunctionNames[kfunc_OnGameMgrMsg],
				"O",
				pythonMsg
			);
			Py_DECREF(pythonMsg);
			if (retVal == nil)
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_OnGameMgrMsg] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			plProfile_EndTiming(PythonUpdate);
			// display any output
			DisplayPythonOutput();

			return true;
		}
	}

	if (fPyFunctionInstances[kfunc_OnGameCliMsg])
	{
		pfGameCliMsg* gameMgrMsg = pfGameCliMsg::ConvertNoRef(msg);
		if (gameMgrMsg)
		{
			plProfile_BeginTiming(PythonUpdate);
			PyObject* pythonMsg = pyGameCliMsg::New(gameMgrMsg);
			PyObject* retVal = PyObject_CallMethod(
				fPyFunctionInstances[kfunc_OnGameCliMsg],
				fFunctionNames[kfunc_OnGameCliMsg],
				"O",
				pythonMsg
			);
			Py_DECREF(pythonMsg);
			if (retVal == nil)
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_OnGameCliMsg] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);
			plProfile_EndTiming(PythonUpdate);
			// display any output
			DisplayPythonOutput();

			return true;
		}
	}

	if (fPyFunctionInstances[kfunc_OnAIMsg])
	{
		plAIMsg* aiMsg = plAIMsg::ConvertNoRef(msg);
		if (aiMsg)
		{
			plProfile_BeginTiming(PythonUpdate);

			// grab the sender (the armature mod that has our brain)
			plArmatureMod* armMod = plArmatureMod::ConvertNoRef(aiMsg->GetSender()->ObjectIsLoaded());
			PyObject* brainObj = NULL;
			if (armMod)
			{
				plArmatureBrain* brain = armMod->FindBrainByClass(plAvBrainCritter::Index());
				plAvBrainCritter* critterBrain = plAvBrainCritter::ConvertNoRef(brain);
				if (critterBrain)
					brainObj = pyCritterBrain::New(critterBrain);
			}
			if (!brainObj)
			{
				Py_INCREF(Py_None);
				brainObj = Py_None;
			}

			// set up the msg type and any args, based on the message we got
			int msgType = plAIMsg::kAIMsg_Unknown;
			PyObject* args = NULL;
			plAIBrainCreatedMsg* brainCreatedMsg = plAIBrainCreatedMsg::ConvertNoRef(aiMsg);
			if (brainCreatedMsg)
				msgType = plAIMsg::kAIMsg_BrainCreated;

			plAIArrivedAtGoalMsg* arrivedMsg = plAIArrivedAtGoalMsg::ConvertNoRef(aiMsg);
			if (arrivedMsg)
			{
				msgType = plAIMsg::kAIMsg_ArrivedAtGoal;
				args = PyTuple_New(1);
				PyTuple_SetItem(args, 0, pyPoint3::New(arrivedMsg->Goal()));
			}

			// if no args were set, simply set to none
			if (!args)
			{
				Py_INCREF(Py_None);
				args = Py_None;
			}

			// call the function with the above arguments
			PyObject* retVal = PyObject_CallMethod(
				fPyFunctionInstances[kfunc_OnAIMsg],
				fFunctionNames[kfunc_OnAIMsg],
				"OisO",
				brainObj, msgType, aiMsg->BrainUserString().c_str(), args
			);
			Py_DECREF(brainObj);
			Py_DECREF(args);
			if (retVal == nil)
			{
#ifndef PLASMA_EXTERNAL_RELEASE
				// for some reason this function didn't, remember that and not call it again
				fPyFunctionInstances[kfunc_OnAIMsg] = nil;
#endif  //PLASMA_EXTERNAL_RELEASE
				// if there was an error make sure that the stderr gets flushed so it can be seen
				ReportError();
			}
			Py_XDECREF(retVal);

			plProfile_EndTiming(PythonUpdate);
			// display any output
			DisplayPythonOutput();

			return true;
		}
	}

	return plModifier::MsgReceive(msg);
}

/////////////////////////////////////////////////////////////////////////////
//
//  Function   : ReportError
//  PARAMETERS : 
//
//  PURPOSE    : Report error to somewhere
//
void plPythonFileMod::ReportError()
{
	char objectName[128];
	StrCopy(objectName, this->GetKeyName(), arrsize(objectName));
	StrPack(objectName, " - ", arrsize(objectName));

	PythonInterface::WriteToStdErr(objectName);

	PyErr_Print();		// make sure the error is printed
	PyErr_Clear();		// clear the error
}

/////////////////////////////////////////////////////////////////////////////
//
//  Function   : DisplayPythonOutput
//  PARAMETERS : 
//
//  PURPOSE    : display any Python stdout or stderr to file and to screen(later)
//
void plPythonFileMod::DisplayPythonOutput()
{
	// get the messages
	PythonInterface::getOutputAndReset();
}

/////////////////////////////////////////////////////////////////////////////
//
//  Function   : SetSourceFile
//  PARAMETERS : code      - text source code
//             : filename  - where the source code came from (just say the object name)
//
//  PURPOSE    : Sets the source code for this modifier.
//             : Compile it into a Python code object
//             : (This is usually called by the component)
//
void plPythonFileMod::SetSourceFile(const char* filename)
{
	delete [] fPythonFile;
	fPythonFile = hsStrcpy(filename);
}

/////////////////////////////////////////////////////////////////////////////
//
//  Function   : getPythonOutput
//  PARAMETERS : none
//
//  PURPOSE    : get the Output to the error file to be displayed
//
int  plPythonFileMod::getPythonOutput(std::string* line)
{
	 return PythonInterface::getOutputAndReset(line);
}


/////////////////////////////////////////////////////////////////////////////
//
//  Function   : EnableControlKeys
//  PARAMETERS : none
//
//  PURPOSE    : get the Output to the error file to be displayed
//
void plPythonFileMod::EnableControlKeyEvents()
{
	// register for keyboard events if needed
	if ( fPyFunctionInstances[kfunc_OnKeyEvent] != nil )
	{
		// register for key events
		plCmdIfaceModMsg* pModMsg = TRACKED_NEW plCmdIfaceModMsg;
		pModMsg->SetBCastFlag(plMessage::kBCastByExactType);
		pModMsg->SetSender(GetKey());
		pModMsg->SetCmd(plCmdIfaceModMsg::kAdd);
		plgDispatch::MsgSend(pModMsg);
	}
}

	
/////////////////////////////////////////////////////////////////////////////
//
//  Function   : DisableControlKeys
//  PARAMETERS : none
//
//  PURPOSE    : get the Output to the error file to be displayed
//
void plPythonFileMod::DisableControlKeyEvents()
{
	// unregister for key events
	plCmdIfaceModMsg* pModMsg = TRACKED_NEW plCmdIfaceModMsg;
	pModMsg->SetBCastFlag(plMessage::kBCastByExactType);
	pModMsg->SetSender(GetKey());
	pModMsg->SetCmd(plCmdIfaceModMsg::kRemove);
	plgDispatch::MsgSend(pModMsg);
}

void plPythonFileMod::Read(hsStream* stream, hsResMgr* mgr)
{
	plMultiModifier::Read(stream, mgr);

	// read in the compile python code (pyc)
	if ( fPythonFile )
	{
		// if we already have some code, get rid of it!
		delete [] fPythonFile;
		fPythonFile = nil;
	}
	fPythonFile = stream->ReadSafeString();

	// then read in the list of receivers that want to be notified
	int nRcvs = stream->ReadSwap32();
	fReceivers.Reset();
	int m;
	for( m=0; m<nRcvs; m++ )
	{	
		fReceivers.Append(mgr->ReadKey(stream));
	}

	// then read in the list of parameters
	int nParms = stream->ReadSwap32();
	fParameters.SetCountAndZero(nParms);
	int i;
	for( i=0; i<nParms; i++ )
	{
		plPythonParameter parm;
		parm.Read(stream,mgr);
		fParameters[i] = parm;
	}	
}

void plPythonFileMod::Write(hsStream* stream, hsResMgr* mgr)
{
	plMultiModifier::Write(stream, mgr);

	stream->WriteSafeString(fPythonFile);

	// then write out the list of receivers that want to be notified
	stream->WriteSwap32(fReceivers.GetCount());
	int m;
	for( m=0; m<fReceivers.GetCount(); m++ )
		mgr->WriteKey(stream, fReceivers[m]);

	// then write out the list of parameters
	stream->WriteSwap32(fParameters.GetCount());
	int i;
	for( i=0; i<fParameters.GetCount(); i++ )
		fParameters[i].Write(stream,mgr);
}

//// kGlobalNameKonstant /////////////////////////////////////////////////
//	My continued attempt to spread the CORRECT way to spell konstant. -mcn

char plPythonFileMod::kGlobalNameKonstant[] = "VeryVerySpecialPythonFileMod";