OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
284 Commits
80 Branches
23 Tags
172 MiB
Tree: f9381e7297
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'f9381e7297'
${ noResults }
CWE-ou-minkata/Sources/Plasma/FeatureLib/pfPython/cyMisc.h

922 lines
33 KiB
Raw Normal View History Unescape

Fix line endings and tabs
14 years ago
/*==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/>.
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==*/
#ifndef cyMisc_h
#define cyMisc_h
/////////////////////////////////////////////////////////////////////////////
//
// NAME: cyMisc
//
// PURPOSE: Class wrapper to map misc functions, such as the console
//
class pyKey;
class pySceneObject;
class pyPlayer;
class pyImage;
class pyDniCoordinates;
class pyColor;
class pyAgeInfoStruct;
class pyPoint3;
Fix the case of Python.h includes
14 years ago
#include <Python.h>
Fix line endings and tabs
14 years ago
#include "hsTypes.h"
#include "hsStlUtils.h"
#include "pnUtils/pnUtils.h"
class pyGUIDialog;
class plPipeline;
class plDisplayMode;
struct PipelineParams;
class cyMisc
{
// game playing to get the pipeline from the client when we can't really
// this is only for the C++ side
// The pipeline is set in the plClient
static plPipeline* fPipeline;
static UInt32 fUniqueNumber;
static UInt32 fPythonLoggingLevel;
public:
// periodically do things
static void Update( double secs );
// the python definitions
static void AddPlasmaMethods(std::vector<PyMethodDef> &methods);
static void AddPlasmaMethods2(std::vector<PyMethodDef> &methods);
static void AddPlasmaMethods3(std::vector<PyMethodDef> &methods);
static void AddPlasmaMethods4(std::vector<PyMethodDef> &methods);
static void AddPlasmaConstantsClasses(PyObject *m);
static void SetPipeline( plPipeline *pipe ) { fPipeline = pipe; }
static plPipeline *GetPipeline( void ) { return fPipeline; }
#if 1
//
// TEMP SCREEN PRINT CODE FOR NON-DBG TEXT DISPLAY
//
public:
static void PrintToScreen(const char* msg);
#endif
enum PythonDebugPrintLevels
{
kNoLevel = 0,
kDebugDump = 1,
kWarningLevel = 2,
kErrorLevel = 3,
kAssertLevel = 4
};
enum LOSObjectType
{
kClickables,
kCameraBlockers,
kCustom,
kShootable
};
static UInt32 GetPythonLoggingLevel();
static void SetPythonLoggingLevel(UInt32 new_level);
/////////////////////////////////////////////////////////////////////////////
//
// Function : Console
// PARAMETERS : command - string of console commmand to execute
//
// PURPOSE : Execute a console command from a python script,
// optionally propagate over the net
//
static void Console(const char* command);
static void ConsoleNet(const char* command, hsBool netForce);
/////////////////////////////////////////////////////////////////////////////
//
// Function : FindSceneObject
// PARAMETERS : name - string of name of the sceneobject
// : ageName - string of the name of the age to look in
//
// PURPOSE : Execute a console command from a python script,
// optionally propagate over the net
//
static PyObject* FindSceneObject(const char* name, const char* ageName); // returns pySceneObject
static PyObject* FindActivator(const char* name); // returns pyKey
/////////////////////////////////////////////////////////////////////////////
//
// Function : PopUpConsole
// PARAMETERS : command - string of console commmand to execute
//
// PURPOSE : Execute a console command from a python script
//
static void PopUpConsole(const char* command);
/////////////////////////////////////////////////////////////////////////////
//
// Function : TimerCallback
// PARAMETERS : command - string of console commmand to execute
//
// PURPOSE : Execute a console command from a python script
//
static void TimerCallback(pyKey& selfkey, hsScalar time, UInt32 id);
/////////////////////////////////////////////////////////////////////////////
//
// Function : ClearTimerCallbacks
// PARAMETERS : key and (optional) timer id
//
// PURPOSE : clears timer callbacks
//
static void ClearTimerCallbacks(pyKey& selfkey);
/////////////////////////////////////////////////////////////////////////////
//
// Function : AttachObject
// PARAMETERS : child object
// : to be attached to parent object
//
// PURPOSE : Attach an object to another object, knowing only their pyKeys
//
static void AttachObject(pyKey& ckey, pyKey& pkey);
static void AttachObjectSO(pySceneObject& cobj, pySceneObject& pobj);
/////////////////////////////////////////////////////////////////////////////
//
// Function : DetachObject
// PARAMETERS : child object
// : to be attached to parent object
//
// PURPOSE : Attach an object to another object, knowing only their pyKeys
//
static void DetachObject(pyKey& ckey, pyKey& pkey);
static void DetachObjectSO(pySceneObject& cobj, pySceneObject& pobj);
/////////////////////////////////////////////////////////////////////////////
//
// Function : LinkToAge
// PARAMETERS :
//
// PURPOSE : LinkToAge
//
// STATUS : Depreciated. Use plNetLinkingMgr or pyNetLinkingMgr instead.
//
/// static void LinkToAge(pyKey &selfkey, const char *AgeName,const char *SpawnPointName);
/////////////////////////////////////////////////////////////////////////////
//
// Function : SetDirtySyncStateServer
// PARAMETERS :
//
// PURPOSE : set the Python modifier to be dirty and asked to be saved out
//
static void SetDirtySyncState(pyKey &selfkey, const char* SDLStateName, UInt32 sendFlags);
/////////////////////////////////////////////////////////////////////////////
//
// Function : SetDirtySyncStateClients
// PARAMETERS :
//
// PURPOSE : set the Python modifier to be dirty and asked to be saved out
// specifies that state should be sent to other clients as well as server
//
static void SetDirtySyncStateWithClients(pyKey &selfkey, const char* SDLStateName, UInt32 sendFlags);
/////////////////////////////////////////////////////////////////////////////
//
// Function : EnableControlKeyEvents & DisableControlKeyEvents
// PARAMETERS : none
//
// PURPOSE : register and unregister for control key events
//
static void EnableControlKeyEvents(pyKey &selfkey);
static void DisableControlKeyEvents(pyKey &selfkey);
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetClientName
// PARAMETERS : avatar key
//
// PURPOSE : Return the net client (account) name of the player whose avatar
// key is provided.
//
static hsBool WasLocallyNotified(pyKey &selfkey);
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetClientName
// PARAMETERS : avatar key
//
// PURPOSE : Return the net client (account) name of the player whose avatar
// key is provided.
//
static const char* GetClientName(pyKey &avKey);
Syntax fixes for FeatureLib.
14 years ago
static PyObject* GetAvatarKeyFromClientID(int clientID); // returns pyKey
static int GetLocalClientID();
static int GetClientIDFromAvatarKey(pyKey& avatar);
static hsBool ValidateKey(pyKey& key);
Fix line endings and tabs
14 years ago
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetClientName
// PARAMETERS :
//
// PURPOSE : Return the local net client (account) name
//
static const char* GetLocalClientName();
//
// Get Current age information - DEPRECIATED. Use ptDniInfoSource() object instead.
//
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetAgeName
// Function : GetAgeTime
// PARAMETERS :
//
// PURPOSE : Return the age name of the current age the local player is in
// : Return the current coordinates of the player within this age
// : Return the current time with the current age the player is in
//
static const char* GetAgeName();
static PyObject* GetAgeInfo(); // returns pyAgeInfoStruct
static const char* GetPrevAgeName();
static PyObject* GetPrevAgeInfo();
// current time in current age
static UInt32 GetAgeTime( void );
Change the fSecs field of plUnifiedTime from UInt32 to time_t. This fixes various date formatting problems when building on a system where time_t is 64-bit (e.g. Visual Studio 2010), and, as a bonus, extends the range past 2038 on such systems. The wire protocol is left at 32-bit for now, we might change that to 64 when other reasons to break compatibility have accumulated.
14 years ago
static time_t GetDniTime(void);
static time_t ConvertGMTtoDni(time_t time);
static time_t GetServerTime( void ); // returns the current server time in GMT
Fix line endings and tabs
14 years ago
static float GetAgeTimeOfDayPercent(void);
/////////////////////////////////////////////////////////////////////////////
//
// Function : ExcludeRegionSet
// PARAMETERS : key - of the exclude region, ie. where to send the message
// state - what state of to set at:
//
// PURPOSE : Sets the state of an exclude region
//
enum
{
kExRegRelease = 0,
kExRegClear = 1,
};
static void ExcludeRegionSet(pyKey& sender, pyKey& exKey, UInt16 state);
static void ExcludeRegionSetNow(pyKey& sender, pyKey& exKey, UInt16 state);
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetSeconds
// PARAMETERS :
//
// PURPOSE : Return the nunber of seconds elapsed
//
static double GetSeconds();
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetSysSeconds
// PARAMETERS :
//
// PURPOSE : Return the number of system seconds elapsed
//
static double GetSysSeconds();
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetDelSysSeconds
// PARAMETERS :
//
// PURPOSE : Return the frame delta seconds
//
static hsScalar GetDelSysSeconds();
/////////////////////////////////////////////////////////////////////////////
//
// Function : LoadDialog
// PARAMETERS :
//
// PURPOSE : Loads the dialog by name
// : optionally sets the receiver key for the GUINotifyMsg
//
static void LoadDialog(const char* name);
static void LoadDialogK(const char* name, pyKey& modKey);
static void LoadDialogKA(const char* name, pyKey& rKey, const char* ageName);
/////////////////////////////////////////////////////////////////////////////
//
// Function : UnLoadDialog
// PARAMETERS :
//
// PURPOSE : UnLoads the dialog by name
// : optionally sets the receiver key for the GUINotifyMsg
//
static void UnloadDialog(const char* name);
/////////////////////////////////////////////////////////////////////////////
//
// Function : IsDialogLoaded
// PARAMETERS :
//
// PURPOSE : Test to see if a dialog is loaded (according to the dialog manager)
//
static hsBool IsDialogLoaded(const char* name);
/////////////////////////////////////////////////////////////////////////////
//
// Function : ShowDialog
// Function : HideDialog
// PARAMETERS :
//
// PURPOSE : Show or Hide a dialog by name
//
static void ShowDialog(const char* name);
static void HideDialog(const char* name);
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetDialogFromTagID
// PARAMETERS :
//
// PURPOSE : Return the frame delta seconds
//
static PyObject* GetDialogFromTagID(UInt32 tag); // returns pyGUIDialog
static PyObject* GetDialogFromString(const char* name); // returns pyGUIDialog
/////////////////////////////////////////////////////////////////////////////
//
// Function : IsGUIModal
// PARAMETERS :
//
// PURPOSE : Returns true if the GUI is currently modal (and therefore blocking input)
//
static bool IsGUIModal();
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetLocalAvatar
// PARAMETERS :
//
// PURPOSE : Return a pySceneobject of the local Avatar
//
static PyObject* GetLocalAvatar(); // returns pySceneObject
static PyObject* GetLocalPlayer(); // returns pyPlayer
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetPlayerList
// Function : GetPlayerListDistanceSorted
// PARAMETERS :
//
// PURPOSE : Get a list of players (other than self) that are playing the game
// : optionally get it sorted by distance
//
// RETURNS : Python object list of pyPlayer s
//
static std::vector<PyObject*> GetPlayerList(); // list of pyPlayer
static std::vector<PyObject*> GetPlayerListDistanceSorted(); // list of pyPlayer
static UInt32 GetMaxListenListSize();
static hsScalar GetMaxListenDistSq();
/////////////////////////////////////////////////////////////////////////////
//
// Function : SendRTChat
// PARAMETERS : from - is a pyPlayer of the person who is sending this
// : tolist - is a python list object, if empty then broadcast message
// : message - text string to send to others
// : flags - the flags of destiny... whatever that means
//
// PURPOSE : To send a real time chat message to a particualr user, a list of users
// : or broadcast it to everyone (within hearing distance?)
//
// RETURNS : the flags that were sent with the message (may be modified)
//
static UInt32 SendRTChat(pyPlayer& from, const std::vector<pyPlayer*> & tolist, const char* message, UInt32 flags);
PtSendRTChat now accepts a unicode object
14 years ago
static UInt32 SendRTChat(pyPlayer& from, const std::vector<pyPlayer*> & tolist, const wchar_t* message, UInt32 flags);
Fix line endings and tabs
14 years ago
/////////////////////////////////////////////////////////////////////////////
//
// Function : SendKIMessage
// PARAMETERS : command - the command type
// : value - extra value
//
// PURPOSE : Send message to the KI, to tell it things to do
//
// RETURNS : nothing
//
static void SendKIMessage(UInt32 command, hsScalar value);
/////////////////////////////////////////////////////////////////////////////
//
// Function : SendKIMessageS
// PARAMETERS : command - the command type
// : value - extra value as a string
//
// PURPOSE : Send message to the KI, to tell it things to do
//
// RETURNS : nothing
//
static void SendKIMessageS(UInt32 command, const wchar_t* value);
/////////////////////////////////////////////////////////////////////////////
//
// Function : SendKIMessageI
// PARAMETERS : command - the command type
// : value - extra value as an Int32
//
// PURPOSE : Send message to the KI, to tell it things to do
//
// RETURNS : nothing
//
static void SendKIMessageI(UInt32 command, Int32 value);
static void SendKIGZMarkerMsg(Int32 markerNumber, pyKey& sender);
static void SendKIRegisterImagerMsg(const char* imagerName, pyKey& sender);
/////////////////////////////////////////////////////////////////////////////
//
// Function : YesNoDialog
// PARAMETERS : sender - sender's key (to get the reply)
// : value - extra value
//
// PURPOSE : Send message to the KI, to tell it things to do
//
// RETURNS : nothing
//
static void YesNoDialog(pyKey& sender, const char* thestring);
static void YesNoDialog(pyKey& sender, std::wstring thestring);
/////////////////////////////////////////////////////////////////////////////
//
// Function : RateIt
// PARAMETERS : chonicleName - where to store the rating
// : thestring - the message in the RateIt dialog
// : onceFlag - flag to tell whether this is a onetime thing or ask everytime
//
// PURPOSE : Send message to the KI to tell it to ask the user to Rate something
//
// RETURNS : nothing
//
static void RateIt(const char* chronicleName, const char* thestring, hsBool onceFlag);
/////////////////////////////////////////////////////////////////////////////
//
// Function : SetPrivateChatList
// PARAMETERS : key - who's joining
//
// PURPOSE : Lock the local avatar into private vox messaging, and / or add new memebers to his chat list
//
// RETURNS : nothing
//
static void SetPrivateChatList(const std::vector<pyPlayer*> & tolist);
/////////////////////////////////////////////////////////////////////////////
//
// Function : RemovePrivateChatMember
// PARAMETERS : key - who's joining
//
// PURPOSE : Remove the local avatar from private vox messaging, and / or clear memebers from his chat list
//
// RETURNS : nothing
//
static void ClearPrivateChatList(pyKey& member);
/////////////////////////////////////////////////////////////////////////////
//
// Function : ClearCameraStack
// PARAMETERS :
//
// PURPOSE : knocks all the cameras off the current stack
//
Syntax fixes for FeatureLib.
14 years ago
static void ClearCameraStack();
Fix line endings and tabs
14 years ago
/////////////////////////////////////////////////////////////////////////////
//
// Function : SendPetitionToCCR
// PARAMETERS : message - message to send to the CCR ("please help me!")
//
// PURPOSE : Send a petition to the CCR for help or questions
//
static void SendPetitionToCCR(const char* message);
static void SendPetitionToCCRI(const char* message, UInt8 reason,const char* title);
/////////////////////////////////////////////////////////////////////////////
//
// Function : SendChatToCCR
// PARAMETERS : message - message to send to the CCR ("please help me!")
//
// PURPOSE : Send a petition to the CCR for help or questions
//
static void SendChatToCCR(const char* message,Int32 CCRPlayerID);
/////////////////////////////////////////////////////////////////////////////
//
// Function : GetNumRemotePlayers
//
// PURPOSE : return the number of remote players connected
//
static int GetNumRemotePlayers();
/////////////////////////////////////////////////////////////////////////////
//
// Function : Paging functions
// PARAMETERS : nodeName - name of the page to load
//
// PURPOSE : page in, or out a paritcular node
//
static void PageInNodes(const std::vector<std::string> & nodeNames, const char* age);
static void PageOutNode(const char* nodeName);
/////////////////////////////////////////////////////////////////////////////
//
// Function : LimitAvatarLOD
// PARAMETERS : LODlimit - number of to limit the LOD to
//
// PURPOSE : sets the avatar LOD limit
//
static void LimitAvatarLOD(int LODlimit);
/////////////////////////////////////////////////////////////////////////////
//
// Function : Set fog default functions
// PARAMETERS : floats - the parameters
//
// PURPOSE : sets the fog defaults
//
static void FogSetDefColor(pyColor& color);
static void FogSetDefLinear(float start, float end, float density);
static void FogSetDefExp(float end, float density);
static void FogSetDefExp2(float end, float density);
static void SetClearColor(float red, float green, float blue);
/////////////////////////////////////////////////////////////////////////////
//
// Function : Enable / disable cursor fade for avatar
// PARAMETERS :
//
// PURPOSE : turns avatar fade out on / off
//
static void EnableAvatarCursorFade();
static void DisableAvatarCursorFade();
static void FadeLocalPlayer(hsBool fade);
/////////////////////////////////////////////////////////////////////////////
//
// Function : Put the interface into 'offer book mode'
// PARAMETERS :
//
// PURPOSE :
//
static void EnableOfferBookMode(pyKey& selfkey, const char* ageFileName, const char* ageInstanceName);
static void DisableOfferBookMode();
static void NotifyOffererPublicLinkAccepted(UInt32 offerer);
static void NotifyOffererPublicLinkRejected(UInt32 offerer);
static void NotifyOffererPublicLinkCompleted(UInt32 offerer);
static void ToggleAvatarClickability(hsBool on);
static void SetShareSpawnPoint(const char* spawnPoint);
static void SetShareAgeInstanceGuid(const Uuid& guid);
//////////////////////////////////////////////////////////////////////////////
//
// Function : IsCCRAwayStatus
// PARAMETERS :
//
// PURPOSE : Returns current status of CCR dept
//
static hsBool IsCCRAwayStatus();
//////////////////////////////////////////////////////////////////////////////
//
// Function : AmCCR
// PARAMETERS :
//
// PURPOSE : Returns true if local player is a CCR
//
static hsBool AmCCR();
//////////////////////////////////////////////////////////////////////////////
//
// Function : AcceptInviteInGame
// PARAMETERS : Friend's Name, Invite Key
//
// PURPOSE : Send's a VaultTask to the server to perform the invite
//
static void AcceptInviteInGame(const char* friendName, const char* inviteKey);
//////////////////////////////////////////////////////////////////////////////
//
// Function : GetLanguage
// PARAMETERS :
//
// PURPOSE : Returns the current language the game is in
//
static int GetLanguage();
//////////////////////////////////////////////////////////////////////////////
//
// Function : UsingUnicode
// PARAMETERS :
//
// PURPOSE : Returns true if the current language uses Unicode (like Japanese)
//
static bool UsingUnicode();
//////////////////////////////////////////////////////////////////////////////
//
// Function : RequestLOSScreen
// PARAMETERS : lots...
//
// PURPOSE : To request an LOS from a point on the screen
//
static bool RequestLOSScreen(pyKey &selfkey, Int32 ID, hsScalar xPos, hsScalar yPos, hsScalar distance, int what, int reportType);
//////////////////////////////////////////////////////////////////////////////
//
// Function : CheckVisLOS
// PARAMETERS : StartPoint, EndPoint
//
// PURPOSE : Check is there is something visible in the path from StartPoint to EndPoint
//
static PyObject* CheckVisLOS(pyPoint3 startPoint, pyPoint3 endPoint);
static PyObject* CheckVisLOSFromCursor();
//////////////////////////////////////////////////////////////////////////////
//
// Function : particle system management
//
static void TransferParticlesToKey(pyKey& fromKey, pyKey& toKey, int numParticles);
static void SetParticleDissentPoint(float x, float y, float z, pyKey& particles);
static void SetParticleOffset(float x, float y, float z, pyKey& particles);
static void KillParticles(float time, float pct, pyKey& particles);
static int GetNumParticles(pyKey& host);
static void SetLightColorValue(pyKey& light, std::string lightName, hsScalar r, hsScalar g, hsScalar b, hsScalar a);
static void SetLightAnimationOn(pyKey& light, std::string lightName, hsBool start);
//////////////////////////////////////////////////////////////////////////////
//
// Function : RegisterForControlEventMessages
// PARAMETERS : switch on or off, registrant
//
// PURPOSE : let you get control event messages at will (for pseudo-GUI's like the psnl bookshelf or clft imager)
static void RegisterForControlEventMessages(hsBool on, pyKey& k);
//////////////////////////////////////////////////////////////////////////////
//
// Function : IsSinglePlayerMode
// And : IsDemoMode
// PARAMETERS :
//
// PURPOSE : Returns whether the game is in Single Player mode
// And : returns whether the game in in Demo mode
//
static bool IsSinglePlayerMode();
static bool IsDemoMode();
//////////////////////////////////////////////////////////////////////////////
//
// Function : IsInternalRelease
// PARAMETERS :
//
// PURPOSE : Returns true if we are running an internal build
//
static bool IsInternalRelease();
//////////////////////////////////////////////////////////////////////////////
//
// Function : IsEnterChatModeKeyBound
// PARAMETERS :
//
// PURPOSE : Returns whether the EnterChatMode is bound to a key
//
static bool IsEnterChatModeKeyBound();
//////////////////////////////////////////////////////////////////////////////
//
// Function : ShootBulletFromScreen
// PARAMETERS : lots...
//
// PURPOSE : Shoots from screen coordinates, a bullet and makes a mark on objects that know about bullet holes
//
static void ShootBulletFromScreen(pyKey &selfkey, hsScalar xPos, hsScalar yPos, hsScalar radius, hsScalar range);
//////////////////////////////////////////////////////////////////////////////
//
// Function : ShootBulletFromObject
// PARAMETERS : lots...
//
// PURPOSE : Shoots from an object, a bullet and makes a mark on objects that know about bullet holes
//
static void ShootBulletFromObject(pyKey &selfkey, pySceneObject* sobj, hsScalar radius, hsScalar range);
//////////////////////////////////////////////////////////////////////////////
//
// Function : GetPublicAgeList
// PARAMETERS : ageName, callback object
//
// PURPOSE : Get the list of public ages for the given age name.
//
static void GetPublicAgeList( const char * ageName, PyObject * cbObject=nil );
//////////////////////////////////////////////////////////////////////////////
//
// Function : CreatePublicAge
// PARAMETERS : ageInfo, callback object
//
// PURPOSE : Add a public age to the list of available ones.
//
static void CreatePublicAge( pyAgeInfoStruct * ageInfo, PyObject * cbObject=nil );
//////////////////////////////////////////////////////////////////////////////
//
// Function : RemovePublicAge
// PARAMETERS : ageInstanceGuid, callback object
//
// PURPOSE : Remove a public age from the list of available ones.
//
static void RemovePublicAge( const char * ageInstanceGuid, PyObject * cbObject=nil );
//////////////////////////////////////////////////////////////////////////////
//
// Function : GetKILevel
//
// PURPOSE : returns the ki level of the local player
//
static int GetKILevel(); // return local player's ki level
//////////////////////////////////////////////////////////////////////////////
//
//
// PURPOSE : these functions are for saving / restoring the camera stack
//
static int GetNumCameras();
static const char* GetCameraNumber(int number);
static void RebuildCameraStack(const char* name, const char* ageName);
static void PyClearCameraStack();
static void RecenterCamera();
static bool IsFirstPerson();
//////////////////////////////////////////////////////////////////////////////
//
// Function : FadeIn and FadeOut
//
// PURPOSE : fade screen in and out
//
static void FadeIn(float lenTime, bool holdFlag, bool noSound = 0);
static void FadeOut(float lenTime, bool holdFlag, bool noSound = 0);
//////////////////////////////////////////////////////////////////////////////
//
// Function : Disable / Enable global clickability
//
// PURPOSE : globally enable or disable ALL clickables on this local client
//
static void SetClickability(hsBool b);
//////////////////////////////////////////////////////////////////////////////
//
// Function : Debug build only: Assert if condition is false.
//
// PURPOSE : debugging
//
static void DebugAssert( bool cond, const char * msg );
//////////////////////////////////////////////////////////////////////////////
//
// Function : Set a python object to be called back after a certain amount of time.
// Python object should have this method: def onAlarm(self,context)
//
// PURPOSE : script can trigger itself over time w/o having to specify it in the dataset.
//
static void SetAlarm( float secs, PyObject * cb, UInt32 cbContext );
//////////////////////////////////////////////////////////////////////////////
//
// Function : Save Screen Shot
//
// PURPOSE : captures the screen and saves it as a jpeg
//
static void SaveScreenShot(const char* fileName, int x = 640, int y = 480, int quality = 75);
//////////////////////////////////////////////////////////////////////////////
//
// Function : Start a screen capture
//
// PURPOSE : This starts a screen capture in motion. It will be capture on the next
// update and a plCaptureRenderMsg when its ready
//
static void StartScreenCapture(pyKey& selfkey);
static void StartScreenCaptureWH(pyKey& selfkey, UInt16 width, UInt16 height);
//////////////////////////////////////////////////////////////////////////////
//
// Function : wear maintainer suit
//
// PURPOSE : puts the maintainer suit on or off the avatar
//
static void WearMaintainerSuit(pyKey& key, hsBool wear);
static void WearDefaultClothing(pyKey& key);
static void WearDefaultClothingType(pyKey& key, UInt32 type);
//////////////////////////////////////////////////////////////////////////////
//
// Function : Fake link to object
//
// PURPOSE : takes an avatar key and an object key and fake-links the avatar
// to that object's position. appears to be a link to other players
//
static void FakeLinkToObject(pyKey& avatar, pyKey& object);
static void FakeLinkToObjectNamed(const char* name);
//////////////////////////////////////////////////////////////////////////////
//
// Function : Spawn an avatar
//
// PURPOSE : takes the name of an avatar model and a sceneobject key and
// spawns the avatar at that point
//
static PyObject* LoadAvatarModel(const char* modelName, pyKey& object, const char* userStr); // returns pyKey
static void UnLoadAvatarModel(pyKey& avatar);
///////////////////////////////////////////////////////////////////////////////
//
// Function : Hide/show the mouse cursor
//
// PURPOSE : forces the mouse cursor to hide/show, overrides pretty much
// everything and should only be used if "normal" methods don't
// work (like ptGUIMouseOff)
static void ForceCursorHidden();
static void ForceCursorShown();
///////////////////////////////////////////////////////////////////////////////
//
// Function : GetLocalizedString
//
// PURPOSE : Returns the specified localized string with the parameters
// properly replaced (the list is a list of unicode strings) Name
// is in "Age.Set.Name" format
//
static std::wstring GetLocalizedString(std::wstring name, const std::vector<std::wstring> & arguments);
static void EnablePlanarReflections(bool enable = true);
static void SetGraphicsOptions(int Width, int Height, int ColorDepth, hsBool Windowed, int NumAASamples, int MaxAnisotropicSamples, hsBool VSync);
static void GetSupportedDisplayModes(std::vector<plDisplayMode> *res);
static int GetDesktopWidth();
static int GetDesktopHeight();
static int GetDesktopColorDepth();
static PipelineParams *GetDefaultDisplayParams();
static bool DumpLogs(const std::wstring & folder);
static bool FileExists(const std::wstring & filename);
static bool CreateDir(const std::wstring & directory);
static std::wstring GetUserPath();
static std::wstring GetInitPath();
static void SetBehaviorNetFlags(pyKey & behKey, hsBool netForce, hsBool netProp);
static void SendFriendInvite(const wchar email[], const wchar toName[]);
static PyObject* PyGuidGenerate();
static PyObject* GetAIAvatarsByModelName(const char* name);
static void ForceVaultNodeUpdate(unsigned nodeId);
static void VaultDownload(unsigned nodeId);
};
#endif // cyMisc_h