CWE-ou-minkata/Sources/Plasma/FeatureLib/pfPython/cyMiscGlue2.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/>.

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==*/
#include "cyMisc.h"
#include "pyGlueHelpers.h"
#include "pyKey.h"
#include "pyColor.h"
#include "pyPlayer.h"
#include "pyEnum.h"

// for enums
#include "plNetCommon\plNetCommon.h"
#include "plResMgr\plLocalization.h"
#include "plMessage\plLOSRequestMsg.h"

#include <python.h>

PYTHON_GLOBAL_METHOD_DEFINITION(PtYesNoDialog, args, "Params: selfkey,dialogMessage\nThis will display a Yes/No dialog to the user with the text dialogMessage\n"
            "This dialog _has_ to be answered by the user.\n"
            "And their answer will be returned in a Notify message.")
{
    PyObject* keyObj = NULL;
    PyObject* dialogMsgObj = NULL;
    if (!PyArg_ParseTuple(args, "OO", &keyObj, &dialogMsgObj))
    {
        PyErr_SetString(PyExc_TypeError, "PtYesNoDialog expects a ptKey and a string or unicode string");
        PYTHON_RETURN_ERROR;
    }
    if (!pyKey::Check(keyObj))
    {
        PyErr_SetString(PyExc_TypeError, "PtYesNoDialog expects a ptKey and a string or unicode string");
        PYTHON_RETURN_ERROR;
    }
    pyKey* key = pyKey::ConvertFrom(keyObj);
    if (PyUnicode_Check(dialogMsgObj))
    {
        int len = PyUnicode_GetSize(dialogMsgObj);
        wchar_t* text = TRACKED_NEW wchar_t[len + 1];
        PyUnicode_AsWideChar((PyUnicodeObject*)dialogMsgObj, text, len);
        text[len] = L'\0';
        cyMisc::YesNoDialog(*key, text);
        delete [] text;
        PYTHON_RETURN_NONE;
    }
    else if (PyString_Check(dialogMsgObj))
    {
        char* text = PyString_AsString(dialogMsgObj);
        cyMisc::YesNoDialog(*key, text);
        PYTHON_RETURN_NONE;
    }
    PyErr_SetString(PyExc_TypeError, "PtYesNoDialog expects a ptKey and a string or unicode string");
    PYTHON_RETURN_ERROR;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtRateIt, args, "Params: chronicleName,dialogPrompt,onceFlag\nShows a dialog with dialogPrompt and stores user input rating into chronicleName")
{
    char* chronicleName;
    char* dialogPrompt;
    char onceFlag;
    if (!PyArg_ParseTuple(args, "ssb", &chronicleName, &dialogPrompt, &onceFlag))
    {
        PyErr_SetString(PyExc_TypeError, "PtRateIt expects two strings and a boolean");
        PYTHON_RETURN_ERROR;
    }
    cyMisc::RateIt(chronicleName, dialogPrompt, onceFlag != 0);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtExcludeRegionSet, args, "Params: senderKey,regionKey,state\nThis will set the state of an exclude region\n"
            "- 'senderKey' is a ptKey of the PythonFile component\n"
            "- 'regionKey' is a ptKey of the exclude region\n"
            "- 'state' is either kExRegRelease or kExRegClear")
{
    PyObject* senderObj = NULL;
    PyObject* regionObj = NULL;
    unsigned short stateVal;
    if (!PyArg_ParseTuple(args, "OOh", &senderObj, &regionObj, &stateVal))
    {
        PyErr_SetString(PyExc_TypeError, "PtExcludeRegionSet expects two ptKeys and a short");
        PYTHON_RETURN_ERROR;
    }
    if ((!pyKey::Check(senderObj)) || (!pyKey::Check(regionObj)))
    {
        PyErr_SetString(PyExc_TypeError, "PtExcludeRegionSet expects two ptKeys and a short");
        PYTHON_RETURN_ERROR;
    }
    pyKey* sender = pyKey::ConvertFrom(senderObj);
    pyKey* region = pyKey::ConvertFrom(regionObj);
    cyMisc::ExcludeRegionSet(*sender, *region, stateVal);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtExcludeRegionSetNow, args, "Params: senderKey,regionKey,state\nThis will set the state of an exclude region immediately on the server\n"
            "- 'senderKey' is a ptKey of the PythonFile component\n"
            "- 'regionKey' is a ptKey of the exclude region\n"
            "- 'state' is either kExRegRelease or kExRegClear")
{
    PyObject* senderObj = NULL;
    PyObject* regionObj = NULL;
    unsigned short stateVal;
    if (!PyArg_ParseTuple(args, "OOh", &senderObj, &regionObj, &stateVal))
    {
        PyErr_SetString(PyExc_TypeError, "PtExcludeRegionSetNow expects two ptKeys and a short");
        PYTHON_RETURN_ERROR;
    }
    if ((!pyKey::Check(senderObj)) || (!pyKey::Check(regionObj)))
    {
        PyErr_SetString(PyExc_TypeError, "PtExcludeRegionSetNow expects two ptKeys and a short");
        PYTHON_RETURN_ERROR;
    }
    pyKey* sender = pyKey::ConvertFrom(senderObj);
    pyKey* region = pyKey::ConvertFrom(regionObj);
    cyMisc::ExcludeRegionSetNow(*sender, *region, stateVal);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtAcceptInviteInGame, args, "Params: friendName,inviteKey\nSends a VaultTask to the server to perform the invite")
{
    char* friendName;
    char* inviteKey;
    if (!PyArg_ParseTuple(args, "ss", &friendName, &inviteKey))
    {
        PyErr_SetString(PyExc_TypeError, "PtAcceptInviteInGame expects two strings");
        PYTHON_RETURN_ERROR;
    }
    cyMisc::AcceptInviteInGame(friendName, inviteKey);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION_NOARGS(PtGetTime, "Returns the number of seconds since the game was started.")
{
    return PyFloat_FromDouble(cyMisc::GetSeconds());
}

PYTHON_GLOBAL_METHOD_DEFINITION_NOARGS(PtGetGameTime, "Returns the system game time (frame based) in seconds.")
{
    return PyFloat_FromDouble(cyMisc::GetSysSeconds());
}

PYTHON_GLOBAL_METHOD_DEFINITION_NOARGS(PtGetFrameDeltaTime, "Returns the amount of time that has elapsed since last frame.")
{
    return PyFloat_FromDouble(cyMisc::GetDelSysSeconds());
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtPageInNode, args, "Params: nodeName, ageName=\"\"\nPages in node, or a list of nodes")
{
    PyObject* nodeNameObj = NULL;
    char* ageName = NULL;
    if (!PyArg_ParseTuple(args, "O|s", &nodeNameObj, &ageName))
    {
        PyErr_SetString(PyExc_TypeError, "PtPageInNode expects a string or list of strings, and optionally a string");
        PYTHON_RETURN_ERROR;
    }
    std::vector<std::string> nodeNames;
    if (PyString_Check(nodeNameObj))
    {
        nodeNames.push_back(PyString_AsString(nodeNameObj));
    }
    else if (PyList_Check(nodeNameObj))
    {
        int num = PyList_Size(nodeNameObj);
        for (int i = 0; i < num; i++)
        {
            PyObject* listItem = PyList_GetItem(nodeNameObj, i);
            if (!PyString_Check(listItem))
            {
                PyErr_SetString(PyExc_TypeError, "PtPageInNode expects a string or list of strings, and optionally a string");
                PYTHON_RETURN_ERROR;
            }
            nodeNames.push_back(PyString_AsString(listItem));
        }
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "PtPageInNode expects a string or list of strings, and optionally a string");
        PYTHON_RETURN_ERROR;
    }

    cyMisc::PageInNodes(nodeNames, ageName);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtPageOutNode, args, "Params: nodeName\nPages out a node")
{
    char* nodeName;
    if (!PyArg_ParseTuple(args, "s", &nodeName))
    {
        PyErr_SetString(PyExc_TypeError, "PtPageOutNode expects a string");
        PYTHON_RETURN_ERROR;
    }
    cyMisc::PageOutNode(nodeName);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtLimitAvatarLOD, args, "Params: LODlimit\nSets avatar's LOD limit")
{
    int lodLimit;
    if (!PyArg_ParseTuple(args, "i", &lodLimit))
    {
        PyErr_SetString(PyExc_TypeError, "PtLimitAvatarLOD expects an integer");
        PYTHON_RETURN_ERROR;
    }
    cyMisc::LimitAvatarLOD(lodLimit);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtFogSetDefColor, args, "Params: color\nSets default fog color")
{
    PyObject* colorObj = NULL;
    if (!PyArg_ParseTuple(args, "O", &colorObj))
    {
        PyErr_SetString(PyExc_TypeError, "PtFogSetDefColor expects a ptColor object");
        PYTHON_RETURN_ERROR;
    }
    if (!pyColor::Check(colorObj))
    {
        PyErr_SetString(PyExc_TypeError, "PtFogSetDefColor expects a ptColor object");
        PYTHON_RETURN_ERROR;
    }
    pyColor* color = pyColor::ConvertFrom(colorObj);
    cyMisc::FogSetDefColor(*color);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtFogSetDefLinear, args, "Params: start,end,density\nSet linear fog values")
{
    float start, end, density;
    if (!PyArg_ParseTuple(args, "fff", &start, &end, &density))
    {
        PyErr_SetString(PyExc_TypeError, "PtFogSetDefLinear expects three floats");
        PYTHON_RETURN_ERROR;
    }
    cyMisc::FogSetDefLinear(start, end, density);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtFogSetDefExp, args, "Params: end,density\nSet exp fog values")
{
    float end, density;
    if (!PyArg_ParseTuple(args, "ff", &end, &density))
    {
        PyErr_SetString(PyExc_TypeError, "PtFogSetDefExp expects three floats");
        PYTHON_RETURN_ERROR;
    }
    cyMisc::FogSetDefExp(end, density);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtFogSetDefExp2, args, "Params: end,density\nSet exp2 fog values")
{
    float end, density;
    if (!PyArg_ParseTuple(args, "ff", &end, &density))
    {
        PyErr_SetString(PyExc_TypeError, "PtFogSetDefExp2 expects three floats");
        PYTHON_RETURN_ERROR;
    }
    cyMisc::FogSetDefExp2(end, density);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtLoadDialog, args, "Params: dialogName,selfKey=None,ageName=\"\"\nLoads a GUI dialog by name and optionally set the Notify proc key\n"
            "If the dialog is already loaded then it won't load it again")
{
    char* dialogName;
    PyObject* keyObj = NULL;
    char* ageName = NULL;
    if (!PyArg_ParseTuple(args, "s|Os", &dialogName, &keyObj, &ageName))
    {
        PyErr_SetString(PyExc_TypeError, "PtLoadDialog expects a string, and optionally a ptKey and second string");
        PYTHON_RETURN_ERROR;
    }
    if (keyObj)
    {
        if (!pyKey::Check(keyObj))
        {
            PyErr_SetString(PyExc_TypeError, "PtLoadDialog expects a string, and optionally a ptKey and second string");
            PYTHON_RETURN_ERROR;
        }
        pyKey* key = pyKey::ConvertFrom(keyObj);
        if (ageName)
            cyMisc::LoadDialogKA(dialogName, *key, ageName);
        else
            cyMisc::LoadDialogK(dialogName, *key);
    }
    else
        cyMisc::LoadDialog(dialogName);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtUnloadDialog, args, "Params: dialogName\nThis will unload the GUI dialog by name. If not loaded then nothing will happen")
{
    char* dialogName;
    if (!PyArg_ParseTuple(args, "s", &dialogName))
    {
        PyErr_SetString(PyExc_TypeError, "PtUnloadDialog expects a string");
        PYTHON_RETURN_ERROR;
    }
    cyMisc::UnloadDialog(dialogName);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtIsDialogLoaded, args, "Params: dialogName\nTest to see if a GUI dialog is loaded, by name")
{
    char* dialogName;
    if (!PyArg_ParseTuple(args, "s", &dialogName))
    {
        PyErr_SetString(PyExc_TypeError, "PtIsDialogLoaded expects a string");
        PYTHON_RETURN_ERROR;
    }
    PYTHON_RETURN_BOOL(cyMisc::IsDialogLoaded(dialogName));
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtShowDialog, args, "Params: dialogName\nShow a GUI dialog by name (does not load dialog)")
{
    char* dialogName;
    if (!PyArg_ParseTuple(args, "s", &dialogName))
    {
        PyErr_SetString(PyExc_TypeError, "PtShowDialog expects a string");
        PYTHON_RETURN_ERROR;
    }
    cyMisc::ShowDialog(dialogName);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtHideDialog, args, "Params: dialogName\nHide a GUI dialog by name (does not unload dialog)")
{
    char* dialogName;
    if (!PyArg_ParseTuple(args, "s", &dialogName))
    {
        PyErr_SetString(PyExc_TypeError, "PtHideDialog expects a string");
        PYTHON_RETURN_ERROR;
    }
    cyMisc::HideDialog(dialogName);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtGetDialogFromTagID, args, "Params: tagID\nReturns the dialog associated with the tagID")
{
    unsigned long tagID;
    if (!PyArg_ParseTuple(args, "l", &tagID))
    {
        PyErr_SetString(PyExc_TypeError, "PtGetDialogFromTagID expects a long");
        PYTHON_RETURN_ERROR;
    }
    return cyMisc::GetDialogFromTagID(tagID);
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtGetDialogFromString, args, "Params: dialogName\nGet a ptGUIDialog from its name")
{
    char* dialogName;
    if (!PyArg_ParseTuple(args, "s", &dialogName))
    {
        PyErr_SetString(PyExc_TypeError, "PtHideDialog expects a string");
        PYTHON_RETURN_ERROR;
    }
    return cyMisc::GetDialogFromString(dialogName);
}

PYTHON_GLOBAL_METHOD_DEFINITION_NOARGS(PtIsGUIModal, "Returns true if the GUI is displaying a modal dialog and blocking input")
{
    PYTHON_RETURN_BOOL(cyMisc::IsGUIModal());
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtSendPrivateChatList, args, "Params: chatList\nLock the local avatar into private vox messaging, and / or add new members to his chat list")
{
    PyObject* chatListObj = NULL;
    if (!PyArg_ParseTuple(args, "O", &chatListObj))
    {
        PyErr_SetString(PyExc_TypeError, "PtSendPrivateChatList expects a list of ptPlayers");
        PYTHON_RETURN_ERROR;
    }

    std::vector<pyPlayer*> chatList;
    if (PyList_Check(chatListObj))
    {
        int listSize = PyList_Size(chatListObj);
        for (int i = 0; i < listSize; i++)
        {
            PyObject* listItem = PyList_GetItem(chatListObj, i);
            if (!pyPlayer::Check(listItem))
            {
                PyErr_SetString(PyExc_TypeError, "PtSendPrivateChatList expects a list of ptPlayers");
                PYTHON_RETURN_ERROR;
            }
            chatList.push_back(pyPlayer::ConvertFrom(listItem));
        }
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "PtSendPrivateChatList expects a list of ptPlayers");
        PYTHON_RETURN_ERROR;
    }

    cyMisc::SetPrivateChatList(chatList);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtClearPrivateChatList, args, "Params: memberKey\nRemove the local avatar from private vox messaging, and / or clear members from his chat list")
{
    PyObject* keyObj = NULL;
    if (!PyArg_ParseTuple(args, "O", &keyObj))
    {
        PyErr_SetString(PyExc_TypeError, "PtClearPrivateChatList expects a ptKey");
        PYTHON_RETURN_ERROR;
    }
    if (!pyKey::Check(keyObj))
    {
        PyErr_SetString(PyExc_TypeError, "PtClearPrivateChatList expects a ptKey");
        PYTHON_RETURN_ERROR;
    }
    pyKey* key = pyKey::ConvertFrom(keyObj);
    cyMisc::ClearPrivateChatList(*key);
    PYTHON_RETURN_NONE;
}

///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaMethods - the python method definitions
//

void cyMisc::AddPlasmaMethods2(std::vector<PyMethodDef> &methods)
{
    PYTHON_GLOBAL_METHOD(methods, PtYesNoDialog);
    PYTHON_GLOBAL_METHOD(methods, PtRateIt);
    
    PYTHON_GLOBAL_METHOD(methods, PtExcludeRegionSet);
    PYTHON_GLOBAL_METHOD(methods, PtExcludeRegionSetNow);

    PYTHON_GLOBAL_METHOD(methods, PtAcceptInviteInGame);

    PYTHON_GLOBAL_METHOD_NOARGS(methods, PtGetTime);
    PYTHON_GLOBAL_METHOD_NOARGS(methods, PtGetGameTime);
    PYTHON_GLOBAL_METHOD_NOARGS(methods, PtGetFrameDeltaTime);

    PYTHON_GLOBAL_METHOD(methods, PtPageInNode);
    PYTHON_GLOBAL_METHOD(methods, PtPageOutNode);
    
    PYTHON_GLOBAL_METHOD(methods, PtLimitAvatarLOD);

    PYTHON_GLOBAL_METHOD(methods, PtFogSetDefColor);
    PYTHON_GLOBAL_METHOD(methods, PtFogSetDefLinear);
    PYTHON_GLOBAL_METHOD(methods, PtFogSetDefExp);
    PYTHON_GLOBAL_METHOD(methods, PtFogSetDefExp2);

    PYTHON_GLOBAL_METHOD(methods, PtLoadDialog);
    PYTHON_GLOBAL_METHOD(methods, PtUnloadDialog);
    PYTHON_GLOBAL_METHOD(methods, PtIsDialogLoaded);
    PYTHON_GLOBAL_METHOD(methods, PtShowDialog);
    PYTHON_GLOBAL_METHOD(methods, PtHideDialog);
    PYTHON_GLOBAL_METHOD(methods, PtGetDialogFromTagID);
    PYTHON_GLOBAL_METHOD(methods, PtGetDialogFromString);
    PYTHON_GLOBAL_METHOD_NOARGS(methods, PtIsGUIModal);

    PYTHON_GLOBAL_METHOD(methods, PtSendPrivateChatList);
    PYTHON_GLOBAL_METHOD(methods, PtClearPrivateChatList);
}

void cyMisc::AddPlasmaConstantsClasses(PyObject *m)
{
    PYTHON_ENUM_START(PtCCRPetitionType);
    PYTHON_ENUM_ELEMENT(PtCCRPetitionType, kGeneralHelp,plNetCommon::PetitionTypes::kGeneralHelp);
    PYTHON_ENUM_ELEMENT(PtCCRPetitionType, kBug,        plNetCommon::PetitionTypes::kBug);
    PYTHON_ENUM_ELEMENT(PtCCRPetitionType, kFeedback,   plNetCommon::PetitionTypes::kFeedback);
    PYTHON_ENUM_ELEMENT(PtCCRPetitionType, kExploit,    plNetCommon::PetitionTypes::kExploit);
    PYTHON_ENUM_ELEMENT(PtCCRPetitionType, kHarass,     plNetCommon::PetitionTypes::kHarass);
    PYTHON_ENUM_ELEMENT(PtCCRPetitionType, kStuck,      plNetCommon::PetitionTypes::kStuck);
    PYTHON_ENUM_ELEMENT(PtCCRPetitionType, kTechnical,  plNetCommon::PetitionTypes::kTechnical);
    PYTHON_ENUM_END(m, PtCCRPetitionType);
    
    PYTHON_ENUM_START(PtLanguage);
    PYTHON_ENUM_ELEMENT(PtLanguage, kEnglish,       plLocalization::kEnglish);
    PYTHON_ENUM_ELEMENT(PtLanguage, kFrench,        plLocalization::kFrench);
    PYTHON_ENUM_ELEMENT(PtLanguage, kGerman,        plLocalization::kGerman);
    PYTHON_ENUM_ELEMENT(PtLanguage, kSpanish,       plLocalization::kSpanish);
    PYTHON_ENUM_ELEMENT(PtLanguage, kItalian,       plLocalization::kItalian);
    PYTHON_ENUM_ELEMENT(PtLanguage, kJapanese,      plLocalization::kJapanese);
    PYTHON_ENUM_ELEMENT(PtLanguage, kNumLanguages,  plLocalization::kNumLanguages);
    PYTHON_ENUM_END(m, PtLanguage);
    
    PYTHON_ENUM_START(PtLOSReportType);
    PYTHON_ENUM_ELEMENT(PtLOSReportType, kReportHit,        plLOSRequestMsg::kReportHit);
    PYTHON_ENUM_ELEMENT(PtLOSReportType, kReportMiss,       plLOSRequestMsg::kReportMiss);
    PYTHON_ENUM_ELEMENT(PtLOSReportType, kReportHitOrMiss,  plLOSRequestMsg::kReportHitOrMiss);
    PYTHON_ENUM_END(m, PtLOSReportType);
    
    PYTHON_ENUM_START(PtLOSObjectType);
    PYTHON_ENUM_ELEMENT(PtLOSObjectType, kClickables,       kClickables);
    PYTHON_ENUM_ELEMENT(PtLOSObjectType, kCameraBlockers,   kCameraBlockers);
    PYTHON_ENUM_ELEMENT(PtLOSObjectType, kCustom,           kCustom);
    PYTHON_ENUM_ELEMENT(PtLOSObjectType, kShootable,        kShootable);
    PYTHON_ENUM_END(m, PtLOSObjectType);
}