Files
AVA2/upstream/ava2-client/UserInterface/PythonPlayerModule.cpp
T

3446 lines
116 KiB
C++

#include "StdAfx.h"
#include "PythonPlayer.h"
#include "PythonApplication.h"
#include "../GameLib/GameLibDefines.h"
#include "../UserInterface/Locale_inc.h"
extern const DWORD c_iSkillIndex_Tongsol = 121;
extern const DWORD c_iSkillIndex_Combo = 122;
extern const DWORD c_iSkillIndex_Fishing = 123;
extern const DWORD c_iSkillIndex_Mining = 124;
extern const DWORD c_iSkillIndex_Making = 125;
extern const DWORD c_iSkillIndex_Language1 = 126;
extern const DWORD c_iSkillIndex_Language2 = 127;
extern const DWORD c_iSkillIndex_Language3 = 128;
extern const DWORD c_iSkillIndex_Polymorph = 129;
extern const DWORD c_iSkillIndex_Riding = 130;
extern const DWORD c_iSkillIndex_Summon = 131;
enum
{
EMOTION_CLAP = 1,
EMOTION_CHEERS_1,
EMOTION_CHEERS_2,
EMOTION_DANCE_1,
EMOTION_DANCE_2,
EMOTION_DANCE_3,
EMOTION_DANCE_4,
EMOTION_DANCE_5,
EMOTION_DANCE_6, // 강남스타일
EMOTION_CONGRATULATION,
EMOTION_FORGIVE,
EMOTION_ANGRY,
EMOTION_ATTRACTIVE,
EMOTION_SAD,
EMOTION_SHY,
EMOTION_CHEERUP,
EMOTION_BANTER,
EMOTION_JOY,
EMOTION_KISS = 51,
EMOTION_FRENCH_KISS,
EMOTION_SLAP,
};
std::map<int, CGraphicImage *> m_kMap_iEmotionIndex_pkIconImage;
extern int TWOHANDED_WEWAPON_ATT_SPEED_DECREASE_VALUE;
#ifdef ENABLE_FEATURES_REFINE_SYSTEM
enum
{
REFINE_PERCENTAGE_LOW = 5,
REFINE_PERCENTAGE_MEDIUM = 10,
REFINE_PERCENTAGE_EXTRA = 15,
REFINE_VNUM_POTION_LOW = 56001,
REFINE_VNUM_POTION_MEDIUM = 56002,
REFINE_VNUM_POTION_EXTRA = 56003,
};
#endif
#ifdef ENABLE_NEW_EQUIPMENT_SYSTEM
class CBeltInventoryHelper
{
public:
typedef BYTE TGradeUnit;
static TGradeUnit GetBeltGradeByRefineLevel(int refineLevel)
{
static TGradeUnit beltGradeByLevelTable[] =
{
0, // 벨트+0
1, // +1
1, // +2
2, // +3
2, // +4,
3, // +5
4, // +6,
5, // +7,
6, // +8,
7, // +9
};
return beltGradeByLevelTable[refineLevel];
}
// 현재 벨트 레벨을 기준으로, 어떤 셀들을 이용할 수 있는지 리턴
static const TGradeUnit* GetAvailableRuleTableByGrade()
{
/**
벨트는 총 +0 ~ +9 레벨을 가질 수 있으며, 레벨에 따라 7단계 등급으로 구분되어 인벤토리가 활성 화 된다.
벨트 레벨에 따른 사용 가능한 셀은 아래 그림과 같음. 현재 등급 >= 활성가능 등급이면 사용 가능.
(단, 현재 레벨이 0이면 무조건 사용 불가, 괄호 안의 숫자는 등급)
2(1) 4(2) 6(4) 8(6)
5(3) 5(3) 6(4) 8(6)
7(5) 7(5) 7(5) 8(6)
9(7) 9(7) 9(7) 9(7)
벨트 인벤토리의 크기는 4x4 (16칸)
*/
static TGradeUnit availableRuleByGrade[c_Belt_Inventory_Slot_Count] = {
1, 2, 4, 6,
3, 3, 4, 6,
5, 5, 5, 6,
7, 7, 7, 7
};
return availableRuleByGrade;
}
static bool IsAvailableCell(WORD cell, int beltGrade /*int beltLevel*/)
{
// 기획 또 바뀜.. 아놔...
//const TGradeUnit beltGrade = GetBeltGradeByRefineLevel(beltLevel);
const TGradeUnit* ruleTable = GetAvailableRuleTableByGrade();
return ruleTable[cell] <= beltGrade;
}
};
#endif
#if defined(WJ_COMBAT_ZONE)
PyObject * playerIsCombatZoneMap(PyObject* poSelf, PyObject* poArgs)
{
CInstanceBase * pInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
if (!pInstance)
return Py_BuildValue("i", 0);
return Py_BuildValue("i", pInstance->IsCombatZoneMap());
}
PyObject * playerGetCombatZonePoints(PyObject* poSelf, PyObject* poArgs)
{
CInstanceBase * pInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
if (!pInstance)
return Py_BuildValue("i", 0);
return Py_BuildValue("i", pInstance->GetCombatZonePoints());
}
#endif
#ifdef TOURNAMENT_PVP_SYSTEM
PyObject * playerIsTournamentMap(PyObject* poSelf, PyObject* poArgs)
{
CInstanceBase * pInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
return Py_BuildValue("i", pInstance->IsTournamentMap());
}
#endif
#ifdef ENABLE_OPTION_COLLECT_EQUIPMENT
PyObject * playerPickCloseItem(PyObject* poSelf, PyObject* poArgs)
{
bool specific_pick = !CPythonSystem::Instance().IsCollectEquipment();
CPythonPlayer::Instance().PickCloseItem(specific_pick);
return Py_BuildNone();
}
#else
PyObject * playerPickCloseItem(PyObject* poSelf, PyObject* poArgs)
{
CPythonPlayer::Instance().PickCloseItem();
return Py_BuildNone();
}
#endif
#ifdef ENABLE_AUTOMATIC_PICK_UP_SYSTEM
PyObject * playerPickCloseItemVector(PyObject * poSelf, PyObject * poArgs)
{
CPythonPlayer::Instance().PickCloseItemVector();
return Py_BuildNone();
}
#endif
PyObject * playerSetGameWindow(PyObject* poSelf, PyObject* poArgs)
{
PyObject * pyHandle;
if (!PyTuple_GetObject(poArgs, 0, &pyHandle))
return Py_BadArgument();
CPythonPlayer & rkPlayer = CPythonPlayer::Instance();
rkPlayer.SetGameWindow(pyHandle);
return Py_BuildNone();
}
PyObject * playerSetQuickCameraMode(PyObject* poSelf, PyObject* poArgs)
{
int nIsEnable;
if (!PyTuple_GetInteger(poArgs, 0, &nIsEnable))
return Py_BadArgument();
CPythonPlayer & rkPlayer = CPythonPlayer::Instance();
rkPlayer.SetQuickCameraMode(nIsEnable ? true : false);
return Py_BuildNone();
}
// Test Code
PyObject * playerSetMainCharacterIndex(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();
CPythonPlayer::Instance().SetMainCharacterIndex(iVID);
CPythonCharacterManager::Instance().SetMainInstance(iVID);
return Py_BuildNone();
}
// Test Code
PyObject * playerGetMainCharacterIndex(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("i", CPythonPlayer::Instance().GetMainCharacterIndex());
}
PyObject * playerGetMainCharacterName(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("s", CPythonPlayer::Instance().GetName());
}
PyObject * playerGetMainCharacterPosition(PyObject* poSelf, PyObject* poArgs)
{
TPixelPosition kPPosMainActor;
CPythonPlayer & rkPlayer = CPythonPlayer::Instance();
rkPlayer.NEW_GetMainActorPosition(&kPPosMainActor);
return Py_BuildValue("fff", kPPosMainActor.x, kPPosMainActor.y, kPPosMainActor.z);
}
PyObject * playerIsMainCharacterIndex(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();
return Py_BuildValue("i", CPythonPlayer::Instance().IsMainCharacterIndex(iVID));
}
PyObject * playerCanAttackInstance(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();
CInstanceBase * pMainInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
CInstanceBase * pTargetInstance = CPythonCharacterManager::Instance().GetInstancePtr(iVID);
if (!pMainInstance)
return Py_BuildValue("i", 0);
if (!pTargetInstance)
return Py_BuildValue("i", 0);
return Py_BuildValue("i", pMainInstance->IsAttackableInstance(*pTargetInstance));
}
PyObject * playerIsActingEmotion(PyObject* poSelf, PyObject* poArgs)
{
CInstanceBase * pMainInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
if (!pMainInstance)
return Py_BuildValue("i", 0);
return Py_BuildValue("i", pMainInstance->IsActingEmotion());
}
PyObject * playerIsPVPInstance(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();
CInstanceBase * pMainInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
CInstanceBase * pTargetInstance = CPythonCharacterManager::Instance().GetInstancePtr(iVID);
if (!pMainInstance)
return Py_BuildValue("i", 0);
if (!pTargetInstance)
return Py_BuildValue("i", 0);
return Py_BuildValue("i", pMainInstance->IsPVPInstance(*pTargetInstance));
}
PyObject * playerIsSameEmpire(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();
CInstanceBase * pMainInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
CInstanceBase * pTargetInstance = CPythonCharacterManager::Instance().GetInstancePtr(iVID);
if (!pMainInstance)
return Py_BuildValue("i", FALSE);
if (!pTargetInstance)
return Py_BuildValue("i", FALSE);
return Py_BuildValue("i", pMainInstance->IsSameEmpire(*pTargetInstance));
}
PyObject * playerIsChallengeInstance(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();
return Py_BuildValue("i", CPythonPlayer::Instance().IsChallengeInstance(iVID));
}
PyObject * playerIsRevengeInstance(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();
return Py_BuildValue("i", CPythonPlayer::Instance().IsRevengeInstance(iVID));
}
PyObject * playerIsCantFightInstance(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();
return Py_BuildValue("i", CPythonPlayer::Instance().IsCantFightInstance(iVID));
}
PyObject * playerGetCharacterDistance(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();
CInstanceBase * pMainInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
CInstanceBase * pTargetInstance = CPythonCharacterManager::Instance().GetInstancePtr(iVID);
if (!pMainInstance)
return Py_BuildValue("f", -1.0f);
if (!pTargetInstance)
return Py_BuildValue("f", -1.0f);
return Py_BuildValue("f", pMainInstance->GetDistance(pTargetInstance));
}
PyObject * playerIsInSafeArea(PyObject* poSelf, PyObject* poArgs)
{
CInstanceBase * pMainInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
if (!pMainInstance)
return Py_BuildValue("i", FALSE);
return Py_BuildValue("i", pMainInstance->IsInSafe());
}
PyObject * playerIsMountingHorse(PyObject* poSelf, PyObject* poArgs)
{
CInstanceBase * pMainInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
if (!pMainInstance)
return Py_BuildValue("i", FALSE);
return Py_BuildValue("i", pMainInstance->IsMountingHorse());
}
PyObject * playerIsObserverMode(PyObject* poSelf, PyObject* poArgs)
{
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
return Py_BuildValue("i", rkPlayer.IsObserverMode());
}
PyObject * playerActEmotion(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
rkPlayer.ActEmotion(iVID);
return Py_BuildNone();
}
PyObject * playerShowPlayer(PyObject* poSelf, PyObject* poArgs)
{
CInstanceBase * pMainInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
if (pMainInstance)
pMainInstance->GetGraphicThingInstanceRef().Show();
return Py_BuildNone();
}
PyObject * playerHidePlayer(PyObject* poSelf, PyObject* poArgs)
{
CInstanceBase * pMainInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
if (pMainInstance)
pMainInstance->GetGraphicThingInstanceRef().Hide();
return Py_BuildNone();
}
PyObject * playerComboAttack(PyObject* poSelf, PyObject* poArgs)
{
CPythonPlayer::Instance().NEW_Attack();
return Py_BuildNone();
}
PyObject * playerRegisterEffect(PyObject* poSelf, PyObject* poArgs)
{
int iEft;
if (!PyTuple_GetInteger(poArgs, 0, &iEft))
return Py_BadArgument();
char* szFileName;
if (!PyTuple_GetString(poArgs, 1, &szFileName))
return Py_BadArgument();
CPythonPlayer & rkPlayer = CPythonPlayer::Instance();
if (!rkPlayer.RegisterEffect(iEft, szFileName, false))
return Py_BuildException("CPythonPlayer::RegisterEffect(eEft=%d, szFileName=%s", iEft, szFileName);
return Py_BuildNone();
}
PyObject * playerRegisterCacheEffect(PyObject* poSelf, PyObject* poArgs)
{
int iEft;
if (!PyTuple_GetInteger(poArgs, 0, &iEft))
return Py_BadArgument();
char* szFileName;
if (!PyTuple_GetString(poArgs, 1, &szFileName))
return Py_BadArgument();
CPythonPlayer & rkPlayer = CPythonPlayer::Instance();
if (!rkPlayer.RegisterEffect(iEft, szFileName, true))
return Py_BuildException("CPythonPlayer::RegisterEffect(eEft=%d, szFileName=%s", iEft, szFileName);
return Py_BuildNone();
}
PyObject * playerSetAttackKeyState(PyObject* poSelf, PyObject* poArgs)
{
int isPressed;
if (!PyTuple_GetInteger(poArgs, 0, &isPressed))
return Py_BuildException("playerSetAttackKeyState(isPressed) - There is no first argument");
CPythonPlayer & rkPlayer = CPythonPlayer::Instance();
rkPlayer.SetAttackKeyState(isPressed ? true : false);
return Py_BuildNone();
}
PyObject * playerSetSingleDIKKeyState(PyObject* poSelf, PyObject* poArgs)
{
int eDIK;
if (!PyTuple_GetInteger(poArgs, 0, &eDIK))
return Py_BuildException("playerSetSingleDIKKeyState(eDIK, isPressed) - There is no first argument");
int isPressed;
if (!PyTuple_GetInteger(poArgs, 1, &isPressed))
return Py_BuildException("playerSetSingleDIKKeyState(eDIK, isPressed) - There is no second argument");
CPythonPlayer & rkPlayer = CPythonPlayer::Instance();
rkPlayer.NEW_SetSingleDIKKeyState(eDIK, isPressed ? true : false);
return Py_BuildNone();
}
PyObject * playerEndKeyWalkingImmediately(PyObject* poSelf, PyObject* poArgs)
{
CPythonPlayer::Instance().NEW_Stop();
return Py_BuildNone();
}
PyObject * playerStartMouseWalking(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildNone();
}
PyObject * playerEndMouseWalking(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildNone();
}
PyObject * playerResetCameraRotation(PyObject* poSelf, PyObject* poArgs)
{
CPythonPlayer::Instance().NEW_ResetCameraRotation();
return Py_BuildNone();
}
PyObject* playerSetAutoCameraRotationSpeed(PyObject* poSelf, PyObject* poArgs)
{
float fCmrRotSpd;
if (!PyTuple_GetFloat(poArgs, 0, &fCmrRotSpd))
return Py_BuildException();
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
rkPlayer.NEW_SetAutoCameraRotationSpeed(fCmrRotSpd);
return Py_BuildNone();
}
PyObject* playerSetMouseState(PyObject* poSelf, PyObject* poArgs)
{
int eMBT;
if (!PyTuple_GetInteger(poArgs, 0, &eMBT))
return Py_BuildException();
int eMBS;
if (!PyTuple_GetInteger(poArgs, 1, &eMBS))
return Py_BuildException();
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
rkPlayer.NEW_SetMouseState(eMBT, eMBS);
return Py_BuildNone();
}
PyObject* playerSetMouseFunc(PyObject* poSelf, PyObject* poArgs)
{
int eMBT;
if (!PyTuple_GetInteger(poArgs, 0, &eMBT))
return Py_BuildException();
int eMBS;
if (!PyTuple_GetInteger(poArgs, 1, &eMBS))
return Py_BuildException();
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
rkPlayer.NEW_SetMouseFunc(eMBT, eMBS);
return Py_BuildNone();
}
PyObject* playerGetMouseFunc(PyObject* poSelf, PyObject* poArgs)
{
int eMBT;
if (!PyTuple_GetInteger(poArgs, 0, &eMBT))
return Py_BuildException();
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
return Py_BuildValue("i", rkPlayer.NEW_GetMouseFunc(eMBT));
}
PyObject* playerSetMouseMiddleButtonState(PyObject* poSelf, PyObject* poArgs)
{
int eMBS;
if (!PyTuple_GetInteger(poArgs, 0, &eMBS))
return Py_BuildException();
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
rkPlayer.NEW_SetMouseMiddleButtonState(eMBS);
return Py_BuildNone();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
PyObject * playerGetName(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("s", CPythonPlayer::Instance().GetName());
}
PyObject* playerIsGameMaster(PyObject* poSelf, PyObject* poArgs)
{
const auto mainPlayer = CPythonPlayer::Instance().NEW_GetMainActorPtr();
return Py_BuildValue("i", mainPlayer != NULL? mainPlayer->IsGameMaster():0);
}
PyObject * playerGetRace(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("i", CPythonPlayer::Instance().GetRace());
}
PyObject * playerGetJob(PyObject* poSelf, PyObject* poArgs)
{
int race = CPythonPlayer::Instance().GetRace();
int job = RaceToJob(race);
return Py_BuildValue("i", job);
}
PyObject * playerGetPlayTime(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("i", CPythonPlayer::Instance().GetPlayTime());
}
PyObject * playerSetPlayTime(PyObject* poSelf, PyObject* poArgs)
{
int iTime;
if (!PyTuple_GetInteger(poArgs, 0, &iTime))
return Py_BuildException();
CPythonPlayer::Instance().SetPlayTime(iTime);
return Py_BuildNone();
}
PyObject * playerIsSkillCoolTime(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
return Py_BuildValue("i", CPythonPlayer::Instance().IsSkillCoolTime(iSlotIndex));
}
PyObject * playerGetSkillCoolTime(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
float fCoolTime = CPythonPlayer::Instance().GetSkillCoolTime(iSlotIndex);
float fElapsedCoolTime = CPythonPlayer::Instance().GetSkillElapsedCoolTime(iSlotIndex);
return Py_BuildValue("ff", fCoolTime, fElapsedCoolTime);
}
PyObject * playerIsSkillActive(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
return Py_BuildValue("i", CPythonPlayer::Instance().IsSkillActive(iSlotIndex));
}
PyObject * playerUseGuildSkill(PyObject* poSelf, PyObject* poArgs)
{
int iSkillSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSkillSlotIndex))
return Py_BuildException();
CPythonPlayer::Instance().UseGuildSkill(iSkillSlotIndex);
return Py_BuildNone();
}
PyObject * playerAffectIndexToSkillIndex(PyObject* poSelf, PyObject* poArgs)
{
int iAffectIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iAffectIndex))
return Py_BuildException();
DWORD dwSkillIndex;
if (!CPythonPlayer::Instance().AffectIndexToSkillIndex(iAffectIndex, &dwSkillIndex))
return Py_BuildValue("i", 0);
return Py_BuildValue("i", dwSkillIndex);
}
PyObject * playerGetEXP(PyObject* poSelf, PyObject* poArgs)
{
DWORD dwEXP = CPythonPlayer::Instance().GetStatus(POINT_EXP);
return Py_BuildValue("l", dwEXP);
}
#ifdef ENABLE_CONQUEROR_LEVEL
PyObject * playerGetConquerorEXP(PyObject* poSelf, PyObject* poArgs)
{
DWORD dwEXP = CPythonPlayer::Instance().GetStatus(POINT_CONQUEROR_EXP);
return Py_BuildValue("l", dwEXP);
}
#endif
PyObject * playerGetStatus(PyObject* poSelf, PyObject* poArgs)
{
int iType;
if (!PyTuple_GetInteger(poArgs, 0, &iType))
return Py_BuildException();
long iValue = CPythonPlayer::Instance().GetStatus(iType);
if (POINT_ATT_SPEED == iType)
{
CInstanceBase * pInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
if (pInstance && (CItemData::WEAPON_TWO_HANDED == pInstance->GetWeaponType()))
{
iValue -= TWOHANDED_WEWAPON_ATT_SPEED_DECREASE_VALUE;
}
}
//TraceError("SUNGMA POINT module : %d : %ld", iType, iValue);
return Py_BuildValue("i", iValue);
}
PyObject * playerSetStatus(PyObject* poSelf, PyObject* poArgs)
{
int iType;
if (!PyTuple_GetInteger(poArgs, 0, &iType))
return Py_BuildException();
int iValue;
if (!PyTuple_GetInteger(poArgs, 1, &iValue))
return Py_BuildException();
CPythonPlayer::Instance().SetStatus(iType, iValue);
return Py_BuildNone();
}
PyObject * playerGetElk(PyObject* poSelf, PyObject* poArgs)
{
return PyLong_FromLongLong(CPythonPlayer::Instance().GetStatus(POINT_GOLD));
}
PyObject * playerGetGuildID(PyObject* poSelf, PyObject* poArgs)
{
CInstanceBase * pInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
if (!pInstance)
return Py_BuildValue("i", 0);
return Py_BuildValue("i", pInstance->GetGuildID());
}
PyObject * playerGetGuildName(PyObject* poSelf, PyObject* poArgs)
{
CInstanceBase * pInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
if (pInstance)
{
DWORD dwID = pInstance->GetGuildID();
std::string strName;
if (CPythonGuild::Instance().GetGuildName(dwID, &strName))
return Py_BuildValue("s", strName.c_str());
}
return Py_BuildValue("s", "");
}
PyObject * playerGetAlignmentData(PyObject* poSelf, PyObject* poArgs)
{
CInstanceBase * pInstance = CPythonPlayer::Instance().NEW_GetMainActorPtr();
int iAlignmentPoint = 0;
int iAlignmentGrade = 4;
if (pInstance)
{
iAlignmentPoint = pInstance->GetAlignment();
iAlignmentGrade = pInstance->GetAlignmentGrade();
}
return Py_BuildValue("ii", iAlignmentPoint, iAlignmentGrade);
}
PyObject * playerSetSkill(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
int iSkillIndex;
if (!PyTuple_GetInteger(poArgs, 1, &iSkillIndex))
return Py_BuildException();
CPythonPlayer::Instance().SetSkill(iSlotIndex, iSkillIndex);
return Py_BuildNone();
}
PyObject * playerGetSkillIndex(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
return Py_BuildValue("i", CPythonPlayer::Instance().GetSkillIndex(iSlotIndex));
}
PyObject * playerGetSkillSlotIndex(PyObject* poSelf, PyObject* poArgs)
{
int iSkillIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSkillIndex))
return Py_BuildException();
DWORD dwSlotIndex;
if (!CPythonPlayer::Instance().GetSkillSlotIndex(iSkillIndex, &dwSlotIndex))
return Py_BuildException();
return Py_BuildValue("i", dwSlotIndex);
}
PyObject * playerGetSkillGrade(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
return Py_BuildValue("i", CPythonPlayer::Instance().GetSkillGrade(iSlotIndex));
}
PyObject * playerGetSkillLevel(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
return Py_BuildValue("i", CPythonPlayer::Instance().GetSkillLevel(iSlotIndex));
}
PyObject * playerGetSkillCurrentEfficientPercentage(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
return Py_BuildValue("f", CPythonPlayer::Instance().GetSkillCurrentEfficientPercentage(iSlotIndex));
}
PyObject * playerGetSkillNextEfficientPercentage(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
return Py_BuildValue("f", CPythonPlayer::Instance().GetSkillNextEfficientPercentage(iSlotIndex));
}
PyObject * playerClickSkillSlot(PyObject * poSelf, PyObject * poArgs)
{
int iSkillSlot;
if (!PyTuple_GetInteger(poArgs, 0, &iSkillSlot))
return Py_BadArgument();
CPythonPlayer::Instance().ClickSkillSlot(iSkillSlot);
return Py_BuildNone();
}
PyObject * playerChangeCurrentSkillNumberOnly(PyObject * poSelf, PyObject * poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BadArgument();
CPythonPlayer::Instance().ChangeCurrentSkillNumberOnly(iSlotIndex);
return Py_BuildNone();
}
PyObject * playerClearSkillDict(PyObject * poSelf, PyObject * poArgs)
{
CPythonPlayer::Instance().ClearSkillDict();
return Py_BuildNone();
}
PyObject * playerMoveItem(PyObject* poSelf, PyObject* poArgs)
{
TItemPos srcCell;
TItemPos dstCell;
switch (PyTuple_Size(poArgs))
{
case 2:
// int iSourceSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &srcCell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &dstCell.cell))
return Py_BuildException();
break;
case 4:
if (!PyTuple_GetByte(poArgs, 0, &srcCell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &srcCell.cell))
return Py_BuildException();
if (!PyTuple_GetByte(poArgs, 2, &dstCell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 3, &dstCell.cell))
return Py_BuildException();
default:
return Py_BuildException();
}
CPythonPlayer::Instance().MoveItemData(srcCell, dstCell);
return Py_BuildNone();
}
PyObject * playerSendClickItemPacket(PyObject* poSelf, PyObject* poArgs)
{
int ivid;
if (!PyTuple_GetInteger(poArgs, 0, &ivid))
return Py_BuildException();
CPythonPlayer::Instance().SendClickItemPacket(ivid);
return Py_BuildNone();
}
PyObject * playerGetItemIndex(PyObject* poSelf, PyObject* poArgs)
{
switch (PyTuple_Size(poArgs))
{
case 1:
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
int ItemIndex = CPythonPlayer::Instance().GetItemIndex(TItemPos (INVENTORY, iSlotIndex));
return Py_BuildValue("i", ItemIndex);
}
case 2:
{
TItemPos Cell;
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
int ItemIndex = CPythonPlayer::Instance().GetItemIndex(Cell);
return Py_BuildValue("i", ItemIndex);
}
default:
return Py_BuildException();
}
}
PyObject * playerGetItemFlags(PyObject* poSelf, PyObject* poArgs)
{
switch (PyTuple_Size(poArgs))
{
case 1:
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
DWORD flags = CPythonPlayer::Instance().GetItemFlags(TItemPos(INVENTORY, iSlotIndex));
return Py_BuildValue("i", flags);
}
case 2:
{
TItemPos Cell;
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
DWORD flags = CPythonPlayer::Instance().GetItemFlags(Cell);
return Py_BuildValue("i", flags);
}
default:
return Py_BuildException();
}
}
PyObject * playerGetItemCount(PyObject* poSelf, PyObject* poArgs)
{
switch (PyTuple_Size(poArgs))
{
case 1:
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
int ItemNum = CPythonPlayer::Instance().GetItemCount(TItemPos (INVENTORY, iSlotIndex));
return Py_BuildValue("i", ItemNum);
}
case 2:
{
TItemPos Cell;
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
int ItemNum = CPythonPlayer::Instance().GetItemCount(Cell);
return Py_BuildValue("i", ItemNum);
}
default:
return Py_BuildException();
}
}
PyObject * playerSetItemCount(PyObject* poSelf, PyObject* poArgs)
{
switch (PyTuple_Size(poArgs))
{
case 2:
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
int bCount;
if (!PyTuple_GetInteger(poArgs, 1, &bCount))
return Py_BuildException();
if (0 == bCount)
return Py_BuildException();
CPythonPlayer::Instance().SetItemCount(TItemPos (INVENTORY, iSlotIndex), bCount);
return Py_BuildNone();
}
case 3:
{
TItemPos Cell;
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
int bCount;
if (!PyTuple_GetInteger(poArgs, 2, &bCount))
return Py_BuildException();
CPythonPlayer::Instance().SetItemCount(Cell, bCount);
return Py_BuildNone();
}
default:
return Py_BuildException();
}
}
PyObject * playerGetItemCountByVnum(PyObject* poSelf, PyObject* poArgs)
{
int ivnum;
if (!PyTuple_GetInteger(poArgs, 0, &ivnum))
return Py_BuildException();
int ItemNum = CPythonPlayer::Instance().GetItemCountByVnum(ivnum);
return Py_BuildValue("i", ItemNum);
}
#ifdef ENABLE_SPECIAL_STORAGE
PyObject * playerGetItemCountByTT(PyObject* poSelf, PyObject* poArgs)
{
int ivnum;
if (!PyTuple_GetInteger(poArgs, 0, &ivnum))
return Py_BuildException();
int ItemNum = CPythonPlayer::Instance().GetItemCountByTT(ivnum);
return Py_BuildValue("i", ItemNum);
}
#endif
PyObject * playerGetItemMetinSocket(PyObject* poSelf, PyObject* poArgs)
{
TItemPos Cell;
int iMetinSocketIndex;
switch (PyTuple_Size(poArgs))
{
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &Cell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &iMetinSocketIndex))
return Py_BuildException();
break;
case 3:
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &iMetinSocketIndex))
return Py_BuildException();
break;
default:
return Py_BuildException();
}
int nMetinSocketValue = CPythonPlayer::Instance().GetItemMetinSocket(Cell, iMetinSocketIndex);
return Py_BuildValue("i", nMetinSocketValue);
}
PyObject * playerGetItemAttribute(PyObject* poSelf, PyObject* poArgs)
{
TItemPos Cell;
// int iSlotPos;
int iAttributeSlotIndex;
switch (PyTuple_Size(poArgs))
{
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &Cell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &iAttributeSlotIndex))
return Py_BuildException();
break;
case 3:
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &iAttributeSlotIndex))
return Py_BuildException();
break;
default:
return Py_BuildException();
}
BYTE byType;
short sValue;
CPythonPlayer::Instance().GetItemAttribute(Cell, iAttributeSlotIndex, &byType, &sValue);
return Py_BuildValue("ii", byType, sValue);
}
PyObject * playerGetItemLink(PyObject * poSelf, PyObject * poArgs)
{
TItemPos Cell;
switch (PyTuple_Size(poArgs))
{
case 1:
if (!PyTuple_GetInteger(poArgs, 0, &Cell.cell))
return Py_BuildException();
break;
case 2:
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
break;
default:
return Py_BuildException();
}
const TItemData * pPlayerItem = CPythonPlayer::Instance().GetItemData(Cell);
CItemData * pItemData = NULL;
char buf[1024];
if (pPlayerItem && CItemManager::Instance().GetItemDataPointer(pPlayerItem->vnum, &pItemData))
{
char itemlink[1024];
int len;
bool isAttr = true;
len = snprintf(itemlink, sizeof(itemlink), "item:%x:%x",pPlayerItem->vnum, pPlayerItem->flags);
for (int i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i)
len += snprintf(itemlink + len, sizeof(itemlink) - len, ":%x", pPlayerItem->alSockets[i]);
for (int i = 0; i < ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++i)
len += snprintf(itemlink + len, sizeof(itemlink) - len, ":%x:%d",pPlayerItem->aAttr[i].bType, pPlayerItem->aAttr[i].sValue);
#ifdef ENABLE_GLOVE_SYSTEM
for (int i = 0; i < GLOVE_ATTR_MAX_NUM; ++i)
len += snprintf(itemlink + len, sizeof(itemlink) - len, ":%x:%d",pPlayerItem->randomAttr[i].bType, pPlayerItem->randomAttr[i].sValue);
#endif
#ifdef ELEMENT_SPELL_WORLDARD
len += snprintf(itemlink + len, sizeof(itemlink) - len, ":%x:%x",pPlayerItem->grade_element, pPlayerItem->element_type_bonus);
if(pPlayerItem->grade_element > 0)
len += snprintf(itemlink + len, sizeof(itemlink) - len, ":%x:%x",pPlayerItem->attack_element[pPlayerItem->grade_element-1], pPlayerItem->elements_value_bonus[pPlayerItem->grade_element-1]);
else
len += snprintf(itemlink + len, sizeof(itemlink) - len, ":%x:%x",0,0);
#endif
if(GetDefaultCodePage() == CP_ARABIC)
snprintf(buf, sizeof(buf)," |h|r[%s]|%s|H%s|h", isAttr ? "cffffc700":"cfff1e6c0", pItemData->GetName(), itemlink);
else
snprintf(buf, sizeof(buf)," |%s|H%s|h[%s]|h|r", isAttr ? "cffffc700":"cfff1e6c0", itemlink, pItemData->GetName());
}
else
buf[0] = '\0';
return Py_BuildValue("s", buf);
}
PyObject * playerGetISellItemPrice(PyObject * poSelf, PyObject * poArgs)
{
TItemPos Cell;
switch (PyTuple_Size(poArgs))
{
case 1:
if (!PyTuple_GetInteger(poArgs, 0, &Cell.cell))
return Py_BuildException();
break;
case 2:
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
break;
default:
return Py_BuildException();
}
CItemData * pItemData;
if (!CItemManager::Instance().GetItemDataPointer(CPythonPlayer::Instance().GetItemIndex(Cell), &pItemData))
return Py_BuildValue("i", 0);
int iPrice;
if (pItemData->IsFlag(CItemData::ITEM_FLAG_COUNT_PER_1GOLD))
iPrice = CPythonPlayer::Instance().GetItemCount(Cell) / pItemData->GetISellItemPrice();
else
iPrice = pItemData->GetISellItemPrice() * CPythonPlayer::Instance().GetItemCount(Cell);
//iPrice /= 5;
return Py_BuildValue("i", iPrice);
}
PyObject * playerGetQuickPage(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("i", CPythonPlayer::Instance().GetQuickPage());
}
PyObject * playerSetQuickPage(PyObject* poSelf, PyObject* poArgs)
{
int iPageIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iPageIndex))
return Py_BuildException();
CPythonPlayer::Instance().SetQuickPage(iPageIndex);
return Py_BuildNone();
}
PyObject * playerLocalQuickSlotIndexToGlobalQuickSlotIndex(PyObject* poSelf, PyObject* poArgs)
{
int iLocalSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iLocalSlotIndex))
return Py_BuildException();
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
return Py_BuildValue("i", rkPlayer.LocalQuickSlotIndexToGlobalQuickSlotIndex(iLocalSlotIndex));
}
PyObject * playerGetLocalQuickSlot(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
DWORD dwWndType;
DWORD dwWndItemPos;
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
rkPlayer.GetLocalQuickSlotData(iSlotIndex, &dwWndType, &dwWndItemPos);
return Py_BuildValue("ii", dwWndType, dwWndItemPos);
}
PyObject * playerGetGlobalQuickSlot(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
DWORD dwWndType;
DWORD dwWndItemPos;
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
rkPlayer.GetGlobalQuickSlotData(iSlotIndex, &dwWndType, &dwWndItemPos);
return Py_BuildValue("ii", dwWndType, dwWndItemPos);
}
PyObject * playerRequestAddLocalQuickSlot(PyObject * poSelf, PyObject * poArgs)
{
int nSlotIndex;
int nWndType;
int nWndItemPos;
if (!PyTuple_GetInteger(poArgs, 0, &nSlotIndex))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &nWndType))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &nWndItemPos))
return Py_BuildException();
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
rkPlayer.RequestAddLocalQuickSlot(nSlotIndex, nWndType, nWndItemPos);
return Py_BuildNone();
}
PyObject * playerRequestAddToEmptyLocalQuickSlot(PyObject* poSelf, PyObject* poArgs)
{
int nWndType;
if (!PyTuple_GetInteger(poArgs, 0, &nWndType))
return Py_BuildException();
int nWndItemPos;
if (!PyTuple_GetInteger(poArgs, 1, &nWndItemPos))
return Py_BuildException();
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
rkPlayer.RequestAddToEmptyLocalQuickSlot(nWndType, nWndItemPos);
return Py_BuildNone();
}
PyObject * playerRequestDeleteGlobalQuickSlot(PyObject * poSelf, PyObject * poArgs)
{
int nGlobalSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &nGlobalSlotIndex))
return Py_BuildException();
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
rkPlayer.RequestDeleteGlobalQuickSlot(nGlobalSlotIndex);
return Py_BuildNone();
}
PyObject * playerRequestMoveGlobalQuickSlotToLocalQuickSlot(PyObject * poSelf, PyObject * poArgs)
{
int nGlobalSrcSlotIndex;
int nLocalDstSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &nGlobalSrcSlotIndex))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &nLocalDstSlotIndex))
return Py_BuildException();
CPythonPlayer& rkPlayer=CPythonPlayer::Instance();
rkPlayer.RequestMoveGlobalQuickSlotToLocalQuickSlot(nGlobalSrcSlotIndex, nLocalDstSlotIndex);
return Py_BuildNone();
}
PyObject * playerRequestUseLocalQuickSlot(PyObject* poSelf, PyObject* poArgs)
{
int iLocalPosition;
if (!PyTuple_GetInteger(poArgs, 0, &iLocalPosition))
return Py_BuildException();
CPythonPlayer::Instance().RequestUseLocalQuickSlot(iLocalPosition);
return Py_BuildNone();
}
PyObject * playerRemoveQuickSlotByValue(PyObject* poSelf, PyObject* poArgs)
{
int iType;
if (!PyTuple_GetInteger(poArgs, 0, &iType))
return Py_BuildException();
int iPosition;
if (!PyTuple_GetInteger(poArgs, 1, &iPosition))
return Py_BuildException();
CPythonPlayer::Instance().RemoveQuickSlotByValue(iType, iPosition);
return Py_BuildNone();
}
PyObject * playerisItem(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
char Flag = CPythonPlayer::Instance().IsItem(TItemPos(INVENTORY, iSlotIndex));
return Py_BuildValue("i", Flag);
}
#ifdef ENABLE_NEW_EQUIPMENT_SYSTEM
PyObject * playerIsBeltInventorySlot(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
char Flag = CPythonPlayer::Instance().IsBeltInventorySlot(TItemPos(INVENTORY, iSlotIndex));
return Py_BuildValue("i", Flag);
}
#endif
PyObject * playerIsEquipmentSlot(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
if (iSlotIndex >= c_Equipment_Start)
if (iSlotIndex <= c_DragonSoul_Equip_End)
return Py_BuildValue("i", 1);
return Py_BuildValue("i", 0);
}
PyObject * playerIsDSEquipmentSlot(PyObject* poSelf, PyObject* poArgs)
{
BYTE bWindowType;
if (!PyTuple_GetInteger(poArgs, 0, &bWindowType))
return Py_BuildException();
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 1, &iSlotIndex))
return Py_BuildException();
if (INVENTORY == bWindowType)
if (iSlotIndex >= c_DragonSoul_Equip_Start)
if (iSlotIndex <= c_DragonSoul_Equip_End)
return Py_BuildValue("i", 1);
return Py_BuildValue("i", 0);
}
#ifdef ENABLE_SHINING_SYSTEM
PyObject * playerIsShiningSlot(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
if (iSlotIndex >= c_Shining_Slot_Start)
if (iSlotIndex <= c_Shining_Slot_End)
return Py_BuildValue("i", 1);
return Py_BuildValue("i", 0);
}
#endif
PyObject * playerIsCostumeSlot(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
#ifdef ENABLE_COSTUME_SYSTEM
if (iSlotIndex >= c_Costume_Slot_Start)
if (iSlotIndex <= c_Costume_Slot_End)
return Py_BuildValue("i", 1);
#endif
return Py_BuildValue("i", 0);
}
PyObject * playerIsOpenPrivateShop(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("i", CPythonPlayer::Instance().IsOpenPrivateShop());
}
PyObject * playerIsValuableItem(PyObject* poSelf, PyObject* poArgs)
{
TItemPos SlotIndex;
switch (PyTuple_Size (poArgs))
{
case 1:
if (!PyTuple_GetInteger(poArgs, 0, &SlotIndex.cell))
return Py_BuildException();
break;
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &SlotIndex.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &SlotIndex.cell)) // @fixme013 arg idx from 0 to 1
return Py_BuildException();
break;
default:
return Py_BuildException();
}
DWORD dwItemIndex = CPythonPlayer::Instance().GetItemIndex(SlotIndex);
CItemManager::Instance().SelectItemData(dwItemIndex);
CItemData * pItemData = CItemManager::Instance().GetSelectedItemDataPointer();
if (!pItemData)
return Py_BuildException("Can't find item data");
BOOL hasMetinSocket = FALSE;
BOOL isHighPrice = FALSE;
for (int i = 0; i < METIN_SOCKET_COUNT; ++i)
if (CPythonPlayer::METIN_SOCKET_TYPE_NONE != CPythonPlayer::Instance().GetItemMetinSocket(SlotIndex, i))
hasMetinSocket = TRUE;
DWORD dwValue = pItemData->GetISellItemPrice();
if (dwValue > 5000)
isHighPrice = TRUE;
return Py_BuildValue("i", hasMetinSocket || isHighPrice);
}
int GetItemGrade(const char * c_szItemName)
{
std::string strName = c_szItemName;
if (strName.empty())
return 0;
char chGrade = strName[strName.length() - 1];
if (chGrade < '0' || chGrade > '9')
chGrade = '0';
int iGrade = chGrade - '0';
return iGrade;
}
PyObject * playerGetItemGrade(PyObject* poSelf, PyObject* poArgs)
{
TItemPos SlotIndex;
switch (PyTuple_Size(poArgs))
{
case 1:
if (!PyTuple_GetInteger(poArgs, 0, &SlotIndex.cell))
return Py_BuildException();
break;
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &SlotIndex.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &SlotIndex.cell))
return Py_BuildException();
break;
default:
return Py_BuildException();
}
int iItemIndex = CPythonPlayer::Instance().GetItemIndex(SlotIndex);
CItemManager::Instance().SelectItemData(iItemIndex);
CItemData * pItemData = CItemManager::Instance().GetSelectedItemDataPointer();
if (!pItemData)
return Py_BuildException("Can't find item data");
return Py_BuildValue("i", GetItemGrade(pItemData->GetName()));
}
#if defined(GAIDEN)
PyObject * playerGetItemUnbindTime(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
return Py_BuildValue("i", (int) CPythonPlayer::instance().GetItemUnbindTime(iSlotIndex));
}
#endif
enum
{
REFINE_SCROLL_TYPE_MAKE_SOCKET = 1,
REFINE_SCROLL_TYPE_UP_GRADE = 2,
};
enum
{
REFINE_CANT,
REFINE_OK,
REFINE_ALREADY_MAX_SOCKET_COUNT,
REFINE_NEED_MORE_GOOD_SCROLL,
REFINE_CANT_MAKE_SOCKET_ITEM,
REFINE_NOT_NEXT_GRADE_ITEM,
REFINE_CANT_REFINE_METIN_TO_EQUIPMENT,
REFINE_CANT_REFINE_ROD,
};
PyObject * playerCanRefine(PyObject * poSelf, PyObject * poArgs)
{
int iScrollItemIndex;
TItemPos TargetSlotIndex;
switch (PyTuple_Size(poArgs))
{
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &iScrollItemIndex))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 1, &TargetSlotIndex.cell))
return Py_BadArgument();
break;
case 3:
if (!PyTuple_GetInteger(poArgs, 0, &iScrollItemIndex))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 1, &TargetSlotIndex.window_type))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 2, &TargetSlotIndex.cell))
return Py_BadArgument();
break;
default:
return Py_BadArgument();
}
if (CPythonPlayer::Instance().IsEquipmentSlot(TargetSlotIndex))
{
return Py_BuildValue("i", REFINE_CANT_REFINE_METIN_TO_EQUIPMENT);
}
// Scroll
CItemManager::Instance().SelectItemData(iScrollItemIndex);
CItemData * pScrollItemData = CItemManager::Instance().GetSelectedItemDataPointer();
if (!pScrollItemData)
return Py_BuildValue("i", REFINE_CANT);
int iScrollType = pScrollItemData->GetType();
int iScrollSubType = pScrollItemData->GetSubType();
if (iScrollType != CItemData::ITEM_TYPE_USE)
return Py_BuildValue("i", REFINE_CANT);
if (iScrollSubType != CItemData::USE_TUNING)
return Py_BuildValue("i", REFINE_CANT);
// Target Item
int iTargetItemIndex = CPythonPlayer::Instance().GetItemIndex(TargetSlotIndex);
CItemManager::Instance().SelectItemData(iTargetItemIndex);
CItemData * pTargetItemData = CItemManager::Instance().GetSelectedItemDataPointer();
if (!pTargetItemData)
return Py_BuildValue("i", REFINE_CANT);
int iTargetType = pTargetItemData->GetType();
//int iTargetSubType = pTargetItemData->GetSubType();
if (CItemData::ITEM_TYPE_ROD == iTargetType)
return Py_BuildValue("i", REFINE_CANT_REFINE_ROD);
if (pTargetItemData->HasNextGrade())
{
return Py_BuildValue("i", REFINE_OK);
}
else
{
return Py_BuildValue("i", REFINE_NOT_NEXT_GRADE_ITEM);
}
return Py_BuildValue("i", REFINE_CANT);
}
enum
{
ATTACH_METIN_CANT,
ATTACH_METIN_OK,
ATTACH_METIN_NOT_MATCHABLE_ITEM,
ATTACH_METIN_NO_MATCHABLE_SOCKET,
ATTACH_METIN_NOT_EXIST_GOLD_SOCKET,
ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT,
};
PyObject * playerCanAttachMetin(PyObject* poSelf, PyObject* poArgs)
{
int iMetinItemID;
TItemPos TargetSlotIndex;
switch (PyTuple_Size(poArgs))
{
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &iMetinItemID))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &TargetSlotIndex.cell))
return Py_BuildException();
break;
case 3:
if (!PyTuple_GetInteger(poArgs, 0, &iMetinItemID))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &TargetSlotIndex.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &TargetSlotIndex.cell))
return Py_BuildException();
break;
default:
return Py_BuildException();
}
if (CPythonPlayer::Instance().IsEquipmentSlot(TargetSlotIndex))
{
return Py_BuildValue("i", ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT);
}
CItemData * pMetinItemData;
if (!CItemManager::Instance().GetItemDataPointer(iMetinItemID, &pMetinItemData))
return Py_BuildException("can't find item data");
DWORD dwTargetItemIndex = CPythonPlayer::Instance().GetItemIndex(TargetSlotIndex);
CItemData * pTargetItemData;
if (!CItemManager::Instance().GetItemDataPointer(dwTargetItemIndex, &pTargetItemData))
return Py_BuildException("can't find item data");
DWORD dwMetinWearFlags = pMetinItemData->GetWearFlags();
DWORD dwTargetWearFlags = pTargetItemData->GetWearFlags();
if (0 == (dwMetinWearFlags & dwTargetWearFlags))
return Py_BuildValue("i", ATTACH_METIN_NOT_MATCHABLE_ITEM);
if (CItemData::ITEM_TYPE_ROD == pTargetItemData->GetType())
return Py_BuildValue("i", ATTACH_METIN_CANT);
BOOL bNotExistGoldSocket = FALSE;
int iSubType = pMetinItemData->GetSubType();
for (int i = 0; i < ITEM_SOCKET_SLOT_MAX_NUM; ++i)
{
DWORD dwSocketType = CPythonPlayer::Instance().GetItemMetinSocket(TargetSlotIndex, i);
if (CItemData::METIN_NORMAL == iSubType)
{
if (CPythonPlayer::METIN_SOCKET_TYPE_SILVER == dwSocketType ||
CPythonPlayer::METIN_SOCKET_TYPE_GOLD == dwSocketType)
{
return Py_BuildValue("i", ATTACH_METIN_OK);
}
}
else if (CItemData::METIN_GOLD == iSubType)
{
if (CPythonPlayer::METIN_SOCKET_TYPE_GOLD == dwSocketType)
{
return Py_BuildValue("i", ATTACH_METIN_OK);
}
else if (CPythonPlayer::METIN_SOCKET_TYPE_SILVER == dwSocketType)
{
bNotExistGoldSocket = TRUE;
}
}
}
if (bNotExistGoldSocket)
{
return Py_BuildValue("i", ATTACH_METIN_NOT_EXIST_GOLD_SOCKET);
}
return Py_BuildValue("i", ATTACH_METIN_NO_MATCHABLE_SOCKET);
}
enum
{
DETACH_METIN_CANT,
DETACH_METIN_OK,
};
PyObject * playerCanDetach(PyObject * poSelf, PyObject * poArgs)
{
int iScrollItemIndex;
TItemPos TargetSlotIndex;
switch (PyTuple_Size(poArgs))
{
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &iScrollItemIndex))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 1, &TargetSlotIndex.cell))
return Py_BadArgument();
break;
case 3:
if (!PyTuple_GetInteger(poArgs, 0, &iScrollItemIndex))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 1, &TargetSlotIndex.window_type))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 2, &TargetSlotIndex.cell))
return Py_BadArgument();
break;
default:
return Py_BadArgument();
}
CItemManager::Instance().SelectItemData(iScrollItemIndex);
CItemData * pScrollItemData = CItemManager::Instance().GetSelectedItemDataPointer();
if (!pScrollItemData)
return Py_BuildException("Can't find item data");
int iScrollType = pScrollItemData->GetType();
int iScrollSubType = pScrollItemData->GetSubType();
if (iScrollType != CItemData::ITEM_TYPE_USE)
return Py_BuildValue("i", DETACH_METIN_CANT);
if (iScrollSubType != CItemData::USE_DETACHMENT)
return Py_BuildValue("i", DETACH_METIN_CANT);
int iTargetItemIndex = CPythonPlayer::Instance().GetItemIndex(TargetSlotIndex);
CItemManager::Instance().SelectItemData(iTargetItemIndex);
CItemData * pTargetItemData = CItemManager::Instance().GetSelectedItemDataPointer();
if (!pTargetItemData)
return Py_BuildException("Can't find item data");
#ifdef ENABLE_SASH_SYSTEM
if (pScrollItemData->GetValue(0) == SASH_CLEAN_ATTR_VALUE0)
{
if ((pTargetItemData->GetType() != CItemData::ITEM_TYPE_COSTUME) || (pTargetItemData->GetSubType() != CItemData::COSTUME_SASH))
return Py_BuildValue("i", DETACH_METIN_CANT);
const TItemData * pPlayerItem = CPythonPlayer::Instance().GetItemData(TargetSlotIndex);
if (pPlayerItem)
{
if (pPlayerItem->alSockets[SASH_ABSORBED_SOCKET] > 0)
return Py_BuildValue("i", DETACH_METIN_OK);
else
return Py_BuildValue("i", DETACH_METIN_CANT);
}
else
return Py_BuildValue("i", DETACH_METIN_CANT);
}
#endif
if (pTargetItemData->IsFlag(CItemData::ITEM_FLAG_REFINEABLE))
{
for (int iSlotCount = 0; iSlotCount < METIN_SOCKET_COUNT; ++iSlotCount)
if (CPythonPlayer::Instance().GetItemMetinSocket(TargetSlotIndex, iSlotCount) > 2)
{
return Py_BuildValue("i", DETACH_METIN_OK);
}
}
return Py_BuildValue("i", DETACH_METIN_CANT);
}
PyObject * playerCanUnlock(PyObject * poSelf, PyObject * poArgs)
{
int iKeyItemIndex;
TItemPos TargetSlotIndex;
switch (PyTuple_Size(poArgs))
{
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &iKeyItemIndex))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 1, &TargetSlotIndex.cell))
return Py_BadArgument();
break;
case 3:
if (!PyTuple_GetInteger(poArgs, 0, &iKeyItemIndex))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 1, &TargetSlotIndex.window_type))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 2, &TargetSlotIndex.cell))
return Py_BadArgument();
break;
default:
return Py_BadArgument();
}
// Key
CItemManager::Instance().SelectItemData(iKeyItemIndex);
CItemData * pKeyItemData = CItemManager::Instance().GetSelectedItemDataPointer();
if (!pKeyItemData)
return Py_BuildException("Can't find item data");
int iKeyType = pKeyItemData->GetType();
if (iKeyType != CItemData::ITEM_TYPE_TREASURE_KEY)
return Py_BuildValue("i", FALSE);
// Target Item
int iTargetItemIndex = CPythonPlayer::Instance().GetItemIndex(TargetSlotIndex);
CItemManager::Instance().SelectItemData(iTargetItemIndex);
CItemData * pTargetItemData = CItemManager::Instance().GetSelectedItemDataPointer();
if (!pTargetItemData)
return Py_BuildException("Can't find item data");
int iTargetType = pTargetItemData->GetType();
if (iTargetType != CItemData::ITEM_TYPE_TREASURE_BOX)
return Py_BuildValue("i", FALSE);
return Py_BuildValue("i", TRUE);
}
PyObject * playerIsRefineGradeScroll(PyObject* poSelf, PyObject* poArgs)
{
TItemPos ScrollSlotIndex;
switch (PyTuple_Size(poArgs))
{
case 1:
if (!PyTuple_GetInteger(poArgs, 0, &ScrollSlotIndex.cell))
return Py_BuildException();
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &ScrollSlotIndex.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &ScrollSlotIndex.cell))
return Py_BuildException();
default:
return Py_BuildException();
}
int iScrollItemIndex = CPythonPlayer::Instance().GetItemIndex(ScrollSlotIndex);
CItemManager::Instance().SelectItemData(iScrollItemIndex);
CItemData * pScrollItemData = CItemManager::Instance().GetSelectedItemDataPointer();
if (!pScrollItemData)
return Py_BuildException("Can't find item data");
return Py_BuildValue("i", REFINE_SCROLL_TYPE_UP_GRADE == pScrollItemData->GetValue(0));
}
PyObject * playerUpdate(PyObject* poSelf, PyObject* poArgs)
{
CPythonPlayer::Instance().Update();
return Py_BuildNone();
}
PyObject * playerRender(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildNone();
}
#ifdef ENABLE_MULTILANGUAGE_SYSTEM
PyObject * playerRequestFlag(PyObject* poSelf, PyObject* poArgs)
{
char* szName;
if (!PyTuple_GetString(poArgs, 0, &szName))
return Py_BadArgument();
CPythonNetworkStream& rns = CPythonNetworkStream::Instance();
rns.RequestFlag(szName);
return Py_BuildNone();
}
#endif
PyObject * playerClear(PyObject* poSelf, PyObject* poArgs)
{
CPythonPlayer::Instance().Clear();
return Py_BuildNone();
}
PyObject * playerClearTarget(PyObject* poSelf, PyObject* poArgs)
{
CPythonPlayer::Instance().SetTarget(0);
return Py_BuildNone();
}
PyObject * playerSetTarget(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();
CPythonPlayer::Instance().SetTarget(iVID);
return Py_BuildNone();
}
PyObject * playerOpenCharacterMenu(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();
CPythonPlayer::Instance().OpenCharacterMenu(iVID);
return Py_BuildNone();
}
PyObject * playerIsPartyMember(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();
return Py_BuildValue("i", CPythonPlayer::Instance().IsPartyMemberByVID(iVID));
}
PyObject * playerIsPartyLeader(PyObject* poSelf, PyObject* poArgs)
{
int iVID;
if (!PyTuple_GetInteger(poArgs, 0, &iVID))
return Py_BuildException();
DWORD dwPID;
if (!CPythonPlayer::Instance().PartyMemberVIDToPID(iVID, &dwPID))
return Py_BuildValue("i", FALSE);
CPythonPlayer::TPartyMemberInfo * pPartyMemberInfo;
if (!CPythonPlayer::Instance().GetPartyMemberPtr(dwPID, &pPartyMemberInfo))
return Py_BuildValue("i", FALSE);
return Py_BuildValue("i", CPythonPlayer::PARTY_ROLE_LEADER == pPartyMemberInfo->byState);
}
PyObject * playerIsPartyLeaderByPID(PyObject* poSelf, PyObject* poArgs)
{
int iPID;
if (!PyTuple_GetInteger(poArgs, 0, &iPID))
return Py_BuildException();
CPythonPlayer::TPartyMemberInfo * pPartyMemberInfo;
if (!CPythonPlayer::Instance().GetPartyMemberPtr(iPID, &pPartyMemberInfo))
return Py_BuildValue("i", FALSE);
return Py_BuildValue("i", CPythonPlayer::PARTY_ROLE_LEADER == pPartyMemberInfo->byState);
}
PyObject * playerGetPartyMemberHPPercentage(PyObject* poSelf, PyObject* poArgs)
{
int iPID;
if (!PyTuple_GetInteger(poArgs, 0, &iPID))
return Py_BuildException();
CPythonPlayer::TPartyMemberInfo * pPartyMemberInfo;
if (!CPythonPlayer::Instance().GetPartyMemberPtr(iPID, &pPartyMemberInfo))
return Py_BuildValue("i", FALSE);
return Py_BuildValue("i", pPartyMemberInfo->byHPPercentage);
}
PyObject * playerGetPartyMemberState(PyObject* poSelf, PyObject* poArgs)
{
int iPID;
if (!PyTuple_GetInteger(poArgs, 0, &iPID))
return Py_BuildException();
CPythonPlayer::TPartyMemberInfo * pPartyMemberInfo;
if (!CPythonPlayer::Instance().GetPartyMemberPtr(iPID, &pPartyMemberInfo))
return Py_BuildValue("i", FALSE);
return Py_BuildValue("i", pPartyMemberInfo->byState);
}
PyObject * playerGetPartyMemberAffects(PyObject* poSelf, PyObject* poArgs)
{
int iPID;
if (!PyTuple_GetInteger(poArgs, 0, &iPID))
return Py_BuildException();
CPythonPlayer::TPartyMemberInfo * pPartyMemberInfo;
if (!CPythonPlayer::Instance().GetPartyMemberPtr(iPID, &pPartyMemberInfo))
return Py_BuildValue("i", FALSE);
return Py_BuildValue("iiiiiii", pPartyMemberInfo->sAffects[0],
pPartyMemberInfo->sAffects[1],
pPartyMemberInfo->sAffects[2],
pPartyMemberInfo->sAffects[3],
pPartyMemberInfo->sAffects[4],
pPartyMemberInfo->sAffects[5],
pPartyMemberInfo->sAffects[6]);
}
PyObject * playerRemovePartyMember(PyObject* poSelf, PyObject* poArgs)
{
int iPID;
if (!PyTuple_GetInteger(poArgs, 0, &iPID))
return Py_BuildException();
CPythonPlayer::Instance().RemovePartyMember(iPID);
return Py_BuildNone();
}
PyObject * playerExitParty(PyObject* poSelf, PyObject* poArgs)
{
CPythonPlayer::Instance().ExitParty();
return Py_BuildNone();
}
PyObject * playerGetPKMode(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("i", CPythonPlayer::Instance().GetPKMode());
}
PyObject * playerHasMobilePhoneNumber(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("i", CPythonPlayer::Instance().HasMobilePhoneNumber());
}
PyObject * playerSetWeaponAttackBonusFlag(PyObject* poSelf, PyObject* poArgs)
{
int iFlag;
if (!PyTuple_GetInteger(poArgs, 0, &iFlag))
return Py_BuildException();
return Py_BuildNone();
}
PyObject * playerToggleCoolTime(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("i", CPythonPlayer::Instance().__ToggleCoolTime());
}
PyObject * playerToggleLevelLimit(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("i", CPythonPlayer::Instance().__ToggleLevelLimit());
}
PyObject * playerGetTargetVID(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("i", CPythonPlayer::Instance().GetTargetVID());
}
PyObject * playerRegisterEmotionIcon(PyObject* poSelf, PyObject* poArgs)
{
int iIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
return Py_BuildException();
char * szFileName;
if (!PyTuple_GetString(poArgs, 1, &szFileName))
return Py_BuildException();
CGraphicImage * pImage = (CGraphicImage *)CResourceManager::Instance().GetResourcePointer(szFileName);
m_kMap_iEmotionIndex_pkIconImage.insert(std::make_pair(iIndex, pImage));
return Py_BuildNone();
}
PyObject * playerGetEmotionIconImage(PyObject* poSelf, PyObject* poArgs)
{
int iIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
return Py_BuildException();
if (m_kMap_iEmotionIndex_pkIconImage.end() == m_kMap_iEmotionIndex_pkIconImage.find(iIndex))
return Py_BuildValue("i", 0);
return Py_BuildValue("i", m_kMap_iEmotionIndex_pkIconImage[iIndex]);
}
PyObject * playerSetItemData(PyObject* poSelf, PyObject* poArgs)
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
int iVirtualID;
if (!PyTuple_GetInteger(poArgs, 1, &iVirtualID))
return Py_BuildException();
int iNum;
if (!PyTuple_GetInteger(poArgs, 2, &iNum))
return Py_BuildException();
TItemData kItemInst;
ZeroMemory(&kItemInst, sizeof(kItemInst));
kItemInst.vnum=iVirtualID;
kItemInst.count=iNum;
CPythonPlayer::Instance().SetItemData(TItemPos(INVENTORY, iSlotIndex), kItemInst);
return Py_BuildNone();
}
PyObject * playerSetItemMetinSocket(PyObject* poSelf, PyObject* poArgs)
{
TItemPos ItemPos;
int iMetinSocketNumber;
int iNum;
switch (PyTuple_Size(poArgs))
{
case 3:
if (!PyTuple_GetInteger(poArgs, 0, &ItemPos.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &iMetinSocketNumber))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &iNum))
return Py_BuildException();
break;
case 4:
if (!PyTuple_GetInteger(poArgs, 0, &ItemPos.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &ItemPos.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &iMetinSocketNumber))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 3, &iNum))
return Py_BuildException();
break;
default:
return Py_BuildException();
}
CPythonPlayer::Instance().SetItemMetinSocket(ItemPos, iMetinSocketNumber, iNum);
return Py_BuildNone();
}
PyObject * playerSetItemAttribute(PyObject* poSelf, PyObject* poArgs)
{
TItemPos ItemPos;
int iAttributeSlotIndex;
int iAttributeType;
int iAttributeValue;
switch (PyTuple_Size(poArgs))
{
case 4:
if (!PyTuple_GetInteger(poArgs, 0, &ItemPos.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &iAttributeSlotIndex))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &iAttributeType))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 3, &iAttributeValue))
return Py_BuildException();
break;
case 5:
if (!PyTuple_GetInteger(poArgs, 0, &ItemPos.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &ItemPos.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &iAttributeSlotIndex))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 3, &iAttributeType))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 4, &iAttributeValue))
return Py_BuildException();
break;
}
CPythonPlayer::Instance().SetItemAttribute(ItemPos, iAttributeSlotIndex, iAttributeType, iAttributeValue);
return Py_BuildNone();
}
PyObject * playerSetAutoPotionInfo(PyObject* poSelf, PyObject* poArgs)
{
int potionType = 0;
if (!PyTuple_GetInteger(poArgs, 0, &potionType))
return Py_BadArgument();
CPythonPlayer* player = CPythonPlayer::InstancePtr();
CPythonPlayer::SAutoPotionInfo& potionInfo = player->GetAutoPotionInfo(potionType);
if (!PyTuple_GetBoolean(poArgs, 1, &potionInfo.bActivated))
return Py_BadArgument();
if (!PyTuple_GetLong(poArgs, 2, &potionInfo.currentAmount))
return Py_BadArgument();
if (!PyTuple_GetLong(poArgs, 3, &potionInfo.totalAmount))
return Py_BadArgument();
if (!PyTuple_GetLong(poArgs, 4, &potionInfo.inventorySlotIndex))
return Py_BadArgument();
return Py_BuildNone();
}
PyObject * playerGetAutoPotionInfo(PyObject* poSelf, PyObject* poArgs)
{
CPythonPlayer* player = CPythonPlayer::InstancePtr();
int potionType = 0;
if (!PyTuple_GetInteger(poArgs, 0, &potionType))
return Py_BadArgument();
CPythonPlayer::SAutoPotionInfo& potionInfo = player->GetAutoPotionInfo(potionType);
return Py_BuildValue("biii", potionInfo.bActivated, int(potionInfo.currentAmount), int(potionInfo.totalAmount), int(potionInfo.inventorySlotIndex));
}
PyObject * playerSlotTypeToInvenType(PyObject* poSelf, PyObject* poArgs)
{
int slotType = 0;
if (!PyTuple_GetInteger(poArgs, 0, &slotType))
return Py_BadArgument();
return Py_BuildValue("i", SlotTypeToInvenType((BYTE)slotType));
}
#ifdef ENABLE_NEW_EQUIPMENT_SYSTEM
// 플레이어가 벨트를 착용 중인지?
PyObject * playerIsEquippingBelt(PyObject* poSelf, PyObject* poArgs)
{
const CPythonPlayer* player = CPythonPlayer::InstancePtr();
bool bEquipping = false;
const TItemData* data = player->GetItemData(TItemPos(EQUIPMENT, c_Equipment_Belt));
if (NULL != data)
bEquipping = 0 < data->count;
return Py_BuildValue("b", bEquipping);
}
// 검사하려는 벨트 인벤토리 Cell이 사용 가능한 칸인지? (사용가능 여부는 착용 중인 벨트의 강화 정도에 따라 달라짐)
PyObject * playerIsAvailableBeltInventoryCell(PyObject* poSelf, PyObject* poArgs)
{
const CPythonPlayer* player = CPythonPlayer::InstancePtr();
const TItemData* pData = player->GetItemData(TItemPos(EQUIPMENT, c_Equipment_Belt));
if (NULL == pData || 0 == pData->count)
return Py_BuildValue("b", false);
CItemManager::Instance().SelectItemData(pData->vnum);
CItemData * pItem = CItemManager::Instance().GetSelectedItemDataPointer();
long beltGrade = pItem->GetValue(0);
int pos = 0;
if (!PyTuple_GetInteger(poArgs, 0, &pos))
return Py_BadArgument();
//return Py_BuildValue("b", CBeltInventoryHelper::IsAvailableCell(pos - c_Belt_Inventory_Slot_Start, GetItemGrade(pItem->GetName())));
return Py_BuildValue("b", CBeltInventoryHelper::IsAvailableCell(pos - c_Belt_Inventory_Slot_Start, beltGrade));
}
#endif
// 용혼석 강화
PyObject* playerSendDragonSoulRefine(PyObject* poSelf, PyObject* poArgs)
{
BYTE bSubHeader;
PyObject* pDic;
TItemPos RefineItemPoses[DS_REFINE_WINDOW_MAX_NUM];
if (!PyTuple_GetByte(poArgs, 0, &bSubHeader))
return Py_BuildException();
switch (bSubHeader)
{
case DS_SUB_HEADER_CLOSE:
break;
case DS_SUB_HEADER_DO_UPGRADE:
case DS_SUB_HEADER_DO_IMPROVEMENT:
case DS_SUB_HEADER_DO_REFINE:
{
if (!PyTuple_GetObject(poArgs, 1, &pDic))
return Py_BuildException();
int pos = 0;
PyObject* key, *value;
int size = PyDict_Size(pDic);
while (PyDict_Next(pDic, &pos, &key, &value))
{
int i = PyInt_AsLong(key);
if (i > DS_REFINE_WINDOW_MAX_NUM)
return Py_BuildException();
if (!PyTuple_GetByte(value, 0, &RefineItemPoses[i].window_type)
|| !PyTuple_GetInteger(value, 1, &RefineItemPoses[i].cell))
{
return Py_BuildException();
}
}
}
break;
}
CPythonNetworkStream& rns=CPythonNetworkStream::Instance();
rns.SendDragonSoulRefinePacket(bSubHeader, RefineItemPoses);
return Py_BuildNone();
}
#ifdef ENABLE_GLOVE_SYSTEM
PyObject * playerGetItemRandomAttribute(PyObject* poSelf, PyObject* poArgs)
{
TItemPos Cell;
// int iSlotPos;
int iAttributeSlotIndex;
switch (PyTuple_Size(poArgs))
{
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &Cell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &iAttributeSlotIndex))
return Py_BuildException();
break;
case 3:
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &iAttributeSlotIndex))
return Py_BuildException();
break;
default:
return Py_BuildException();
}
BYTE byType;
short sValue;
CPythonPlayer::Instance().GetItemRandomAttribute(Cell, iAttributeSlotIndex, &byType, &sValue);
return Py_BuildValue("ii", byType, sValue);
}
#endif
#ifdef ENABLE_SOULBIND_SYSTEM
PyObject * playerGetItemBind(PyObject* poSelf, PyObject* poArgs)
{
switch (PyTuple_Size(poArgs))
{
case 1:
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
long ItemBind = CPythonPlayer::Instance().GetItemBind(TItemPos(INVENTORY, iSlotIndex));
return Py_BuildValue("i", ItemBind);
}
case 2:
{
TItemPos Cell;
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
long ItemBind = CPythonPlayer::Instance().GetItemBind(Cell);
return Py_BuildValue("i", ItemBind);
}
default:
return Py_BuildException();
}
}
#endif
PyObject * playerIsAntiFlagBySlot(PyObject * poSelf, PyObject * poArgs)
{
TItemPos Cell;
int antiflag;
switch (PyTuple_Size(poArgs))
{
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &Cell.cell))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 1, &antiflag))
return Py_BadArgument();
break;
case 3:
if (!PyTuple_GetInteger(poArgs, 0, &Cell.window_type))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 2, &antiflag))
return Py_BadArgument();
break;
default:
return Py_BuildException();
}
DWORD itemAntiFlags = CPythonPlayer::Instance().GetItemAntiFlags(Cell);
return Py_BuildValue("i", IS_SET(itemAntiFlags, antiflag) != 0 ? TRUE : FALSE);
}
PyObject * playerGetItemTypeBySlot(PyObject * poSelf, PyObject * poArgs)
{
TItemPos Cell;
switch (PyTuple_Size(poArgs))
{
case 1:
if (!PyTuple_GetInteger(poArgs, 0, &Cell.cell))
return Py_BadArgument();
break;
case 2:
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BadArgument();
break;
default:
return Py_BuildException();
}
return Py_BuildValue("i", CPythonPlayer::Instance().GetItemTypeBySlot(Cell));
}
PyObject * playerGetItemSubTypeBySlot(PyObject * poSelf, PyObject * poArgs)
{
TItemPos Cell;
switch (PyTuple_Size(poArgs))
{
case 1:
if (!PyTuple_GetInteger(poArgs, 0, &Cell.cell))
return Py_BadArgument();
break;
case 2:
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BadArgument();
break;
default:
return Py_BuildException();
}
return Py_BuildValue("i", CPythonPlayer::Instance().GetItemSubTypeBySlot(Cell));
}
PyObject * playerIsSameItemVnum(PyObject * poSelf, PyObject * poArgs)
{
TItemPos Cell;
int iItemVNum;
switch (PyTuple_Size(poArgs))
{
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &iItemVNum))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BadArgument();
break;
case 3:
if (!PyTuple_GetInteger(poArgs, 0, &iItemVNum))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.window_type))
return Py_BadArgument();
if (!PyTuple_GetInteger(poArgs, 2, &Cell.cell))
return Py_BadArgument();
break;
default:
return Py_BuildException();
}
return Py_BuildValue("i", (iItemVNum == CPythonPlayer::Instance().GetItemIndex(Cell)) ? TRUE : FALSE);
}
#ifdef ENABLE_NEW_NAME_ITEM
PyObject* playerGetItemNewName(PyObject* poSelf, PyObject* poArgs)
{
switch (PyTuple_Size(poArgs))
{
case 1:
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
return Py_BuildValue("s", CPythonPlayer::Instance().GetItemNewName(TItemPos(INVENTORY, iSlotIndex)));
}
case 2:
{
TItemPos Cell;
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
return Py_BuildValue("s", CPythonPlayer::Instance().GetItemNewName(Cell));
}
}
return Py_BuildValue("s", "^");
}
#endif
#ifdef ELEMENT_SPELL_WORLDARD
enum
{
ELEMENT_UPGRADE_CANT_ADD,
ELEMENT_UPGRADE_ADD,
ELEMENT_DOWNGRADE_CANT_ADD,
ELEMENT_DOWNGRADE_ADD,
ELEMENT_CHANGE_CANT_ADD,
ELEMENT_CHANGE_ADD,
ELEMENT_CANT_WORLDARD,
};
PyObject * playerElements(PyObject * poSelf, PyObject * poArgs)
{
int VnumItemElement;
TItemPos SlotIndexItemWeapon;
TItemPos SlotIndexItemElements;
//short sValue_Item_Weapon;
switch (PyTuple_Size(poArgs))
{
case 2:
if (!PyTuple_GetInteger(poArgs, 0, &VnumItemElement))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &SlotIndexItemWeapon.cell))
return Py_BuildException();
break;
default:
return Py_BuildException();
}
if (CPythonPlayer::Instance().IsEquipmentSlot(SlotIndexItemWeapon))
{
return Py_BuildValue("i", ELEMENT_CANT_WORLDARD);
}
CItemData * pItemElementData;
if (!CItemManager::Instance().GetItemDataPointer(VnumItemElement, &pItemElementData))
return Py_BuildException("can't find item data");
DWORD dwSlotIndexItemWeapon = CPythonPlayer::Instance().GetItemIndex(SlotIndexItemWeapon);
CItemData * pSlotIndexItemWeapon;
if (!CItemManager::Instance().GetItemDataPointer(dwSlotIndexItemWeapon, &pSlotIndexItemWeapon))
return Py_BuildException("can't find item data");
int iSubTypeItemElement = pItemElementData->GetSubType();
int iTypeWeapon = pSlotIndexItemWeapon->GetType();
if (CItemData::USE_ELEMENT_UPGRADE == iSubTypeItemElement && CItemData::ITEM_TYPE_WEAPON == iTypeWeapon)
{
BYTE dwGradeItem = CPythonPlayer::Instance().GetElementGrade(SlotIndexItemWeapon);
BYTE byType_Item_Weapon = CPythonPlayer::Instance().GetElementType(SlotIndexItemWeapon);
CItemManager::Instance().SelectItemData(dwSlotIndexItemWeapon);
CItemData * pItemWeaponData = CItemManager::Instance().GetSelectedItemDataPointer();
if (!pItemWeaponData){
return Py_BuildException("Can't find item data");
}
if(dwGradeItem >= 0 && dwGradeItem < 3 && GetItemGrade(pItemWeaponData->GetName()) >= 7){
if(dwGradeItem > 0)
{
if(byType_Item_Weapon != pItemElementData->GetValue(0)){
return Py_BuildValue("i", ELEMENT_UPGRADE_CANT_ADD);
}
return Py_BuildValue("i", ELEMENT_UPGRADE_ADD);
}
return Py_BuildValue("i", ELEMENT_UPGRADE_ADD);
}
return Py_BuildValue("i", ELEMENT_UPGRADE_CANT_ADD);
}
else if (CItemData::USE_ELEMENT_DOWNGRADE == iSubTypeItemElement && CItemData::ITEM_TYPE_WEAPON == iTypeWeapon)
{
BYTE dwGradeItem = CPythonPlayer::Instance().GetElementGrade(SlotIndexItemWeapon);
BYTE byType_Item_Weapon = CPythonPlayer::Instance().GetElementType(SlotIndexItemWeapon);
CItemManager::Instance().SelectItemData(dwSlotIndexItemWeapon);
CItemData * pItemWeaponData = CItemManager::Instance().GetSelectedItemDataPointer();
if (!pItemWeaponData){
return Py_BuildException("Can't find item data");
}
if(dwGradeItem > 0 && dwGradeItem <= 3 && GetItemGrade(pItemWeaponData->GetName()) >= 7){
return Py_BuildValue("i", ELEMENT_DOWNGRADE_ADD);
}
return Py_BuildValue("i", ELEMENT_DOWNGRADE_CANT_ADD);
}
else if (CItemData::USE_ELEMENT_CHANGE == iSubTypeItemElement && CItemData::ITEM_TYPE_WEAPON == iTypeWeapon)
{
BYTE dwGradeItem = CPythonPlayer::Instance().GetElementGrade(SlotIndexItemWeapon);
BYTE byType_Item_Weapon = CPythonPlayer::Instance().GetElementType(SlotIndexItemWeapon);
CItemManager::Instance().SelectItemData(dwSlotIndexItemWeapon);
CItemData * pItemWeaponData = CItemManager::Instance().GetSelectedItemDataPointer();
if (!pItemWeaponData){
return Py_BuildException("Can't find item data");
}
if(dwGradeItem > 0 && dwGradeItem <= 3 && GetItemGrade(pItemWeaponData->GetName()) >= 7){
return Py_BuildValue("i", ELEMENT_CHANGE_ADD);
}
return Py_BuildValue("i", ELEMENT_CHANGE_CANT_ADD);
}
return Py_BuildValue("i", ELEMENT_CANT_WORLDARD);
}
PyObject * playerGetItemElementGrade(PyObject* poSelf, PyObject* poArgs)
{
switch (PyTuple_Size(poArgs))
{
case 1:
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
DWORD dwElementGrade = CPythonPlayer::Instance().GetElementGrade(TItemPos(INVENTORY, iSlotIndex));
return Py_BuildValue("i", dwElementGrade);
}
case 2:
{
TItemPos Cell;
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
DWORD dwElementGrade = CPythonPlayer::Instance().GetElementGrade(Cell);
return Py_BuildValue("i", dwElementGrade);
}
default:
return Py_BuildException();
}
}
PyObject * playerGetItemElementAttack(PyObject* poSelf, PyObject* poArgs)
{
int iAttackIndex;
switch (PyTuple_Size(poArgs))
{
case 2:
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &iAttackIndex))
return Py_BuildException();
DWORD dwElementAttack = CPythonPlayer::Instance().GetElementAttack(TItemPos(INVENTORY, iSlotIndex),iAttackIndex);
return Py_BuildValue("i", dwElementAttack);
}
case 3:
{
TItemPos Cell;
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &iAttackIndex))
return Py_BuildException();
DWORD dwElementAttack = CPythonPlayer::Instance().GetElementAttack(Cell,iAttackIndex);
return Py_BuildValue("i", dwElementAttack);
}
default:
return Py_BuildException();
}
}
PyObject * playerGetItemElementType(PyObject* poSelf, PyObject* poArgs)
{
switch (PyTuple_Size(poArgs))
{
case 1:
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
BYTE dwElementType = CPythonPlayer::Instance().GetElementType(TItemPos(INVENTORY, iSlotIndex));
return Py_BuildValue("i", dwElementType);
}
case 2:
{
TItemPos Cell;
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
BYTE dwElementType = CPythonPlayer::Instance().GetElementType(Cell);
return Py_BuildValue("i", dwElementType);
}
default:
return Py_BuildException();
}
}
PyObject * playerGetItemElementValue(PyObject* poSelf, PyObject* poArgs)
{
int iValueIndex;
switch (PyTuple_Size(poArgs))
{
case 2:
{
int iSlotIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iSlotIndex))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &iValueIndex))
return Py_BuildException();
short dwElementValue = CPythonPlayer::Instance().GetElementValue(TItemPos(INVENTORY, iSlotIndex),iValueIndex);
return Py_BuildValue("i", dwElementValue);
}
case 3:
{
TItemPos Cell;
if (!PyTuple_GetByte(poArgs, 0, &Cell.window_type))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 1, &Cell.cell))
return Py_BuildException();
if (!PyTuple_GetInteger(poArgs, 2, &iValueIndex))
return Py_BuildException();
short dwElementValue = CPythonPlayer::Instance().GetElementValue(Cell,iValueIndex);
return Py_BuildValue("i", dwElementValue);
}
default:
return Py_BuildException();
}
}
#endif
#ifdef ENABLE_NEW_DETAILS_GUI
PyObject * playerGetKillLOG(PyObject* poSelf, PyObject* poArgs)
{
int log;
if (!PyTuple_GetInteger(poArgs, 0, &log))
return Py_BadArgument();
CPythonPlayer & rkPlayer = CPythonPlayer::Instance();
return Py_BuildValue("l", rkPlayer.GetKillLOG(log));
}
#endif
PyObject* playerGetMainCharacterPart(PyObject* poSelf, PyObject* poArgs)
{
int iPartIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iPartIndex))
return Py_BadArgument();
CInstanceBase* pMainInstance = CPythonCharacterManager::Instance().GetMainInstancePtr();
return Py_BuildValue("i", pMainInstance ? pMainInstance->GetPartData(iPartIndex) : 0);
}
PyObject* playerGetMainCharacterShiningPart(PyObject* poSelf, PyObject* poArgs)
{
int iPartIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iPartIndex))
return Py_BadArgument();
CInstanceBase* pMainInstance = CPythonCharacterManager::Instance().GetMainInstancePtr();
return Py_BuildValue("i", pMainInstance ? pMainInstance->GetShiningData(iPartIndex) : 0);
}
#ifdef ENABLE_ULTIMATE_REGEN
PyObject* playerLoadNewRegen(PyObject* poSelf, PyObject* poArgs)
{
CPythonPlayer::Instance().LoadNewRegen();
return Py_BuildNone();
}
#endif
#ifdef ENABLE_GEM_SYSTEM
PyObject* playerGetGem(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("i", CPythonPlayer::Instance().GetStatus(POINT_GEM));
}
#endif
#ifdef ENABLE_MINI_GAME_CATCH_KING
PyObject* playerSetEventGame(PyObject* poSelf, PyObject* poArgs)
{
int iEnable;
if (!PyTuple_GetInteger(poArgs, 0, &iEnable))
return Py_BuildException();
CPythonPlayer::Instance().SetEventGame(iEnable);
return Py_BuildNone();
}
PyObject* playerGetEventGame(PyObject* poSelf, PyObject* poArgs)
{
return Py_BuildValue("i", CPythonPlayer::Instance().GetEventGame());
}
#endif
void initPlayer()
{
static PyMethodDef s_methods[] =
{
{ "GetAutoPotionInfo", playerGetAutoPotionInfo, METH_VARARGS },
{ "SetAutoPotionInfo", playerSetAutoPotionInfo, METH_VARARGS },
#ifdef ENABLE_SOULBIND_SYSTEM
{"GetItemBind", playerGetItemBind, METH_VARARGS},
#endif
#ifdef TOURNAMENT_PVP_SYSTEM
{ "IsTournamentMap", playerIsTournamentMap, METH_VARARGS},
#endif
{ "IsAntiFlagBySlot", playerIsAntiFlagBySlot, METH_VARARGS },
{ "GetItemTypeBySlot", playerGetItemTypeBySlot, METH_VARARGS },
{ "GetItemSubTypeBySlot", playerGetItemSubTypeBySlot, METH_VARARGS },
{ "IsSameItemVnum", playerIsSameItemVnum, METH_VARARGS },
#ifdef ENABLE_AUTOMATIC_PICK_UP_SYSTEM
{"PickCloseItemVector", playerPickCloseItemVector, METH_VARARGS},
#endif
{ "PickCloseItem", playerPickCloseItem, METH_VARARGS },
{ "SetGameWindow", playerSetGameWindow, METH_VARARGS },
{ "RegisterEffect", playerRegisterEffect, METH_VARARGS },
{ "RegisterCacheEffect", playerRegisterCacheEffect, METH_VARARGS },
{ "SetMouseState", playerSetMouseState, METH_VARARGS },
{ "SetMouseFunc", playerSetMouseFunc, METH_VARARGS },
{ "GetMouseFunc", playerGetMouseFunc, METH_VARARGS },
{ "SetMouseMiddleButtonState", playerSetMouseMiddleButtonState, METH_VARARGS },
{ "SetMainCharacterIndex", playerSetMainCharacterIndex, METH_VARARGS },
{ "GetMainCharacterIndex", playerGetMainCharacterIndex, METH_VARARGS },
{ "GetMainCharacterName", playerGetMainCharacterName, METH_VARARGS },
{ "GetMainCharacterPosition", playerGetMainCharacterPosition, METH_VARARGS },
{ "IsMainCharacterIndex", playerIsMainCharacterIndex, METH_VARARGS },
{ "CanAttackInstance", playerCanAttackInstance, METH_VARARGS },
{ "IsActingEmotion", playerIsActingEmotion, METH_VARARGS },
{ "IsPVPInstance", playerIsPVPInstance, METH_VARARGS },
{ "IsSameEmpire", playerIsSameEmpire, METH_VARARGS },
{ "IsChallengeInstance", playerIsChallengeInstance, METH_VARARGS },
{ "IsRevengeInstance", playerIsRevengeInstance, METH_VARARGS },
{ "IsCantFightInstance", playerIsCantFightInstance, METH_VARARGS },
{ "GetCharacterDistance", playerGetCharacterDistance, METH_VARARGS },
{ "IsInSafeArea", playerIsInSafeArea, METH_VARARGS },
{ "IsMountingHorse", playerIsMountingHorse, METH_VARARGS },
{ "IsObserverMode", playerIsObserverMode, METH_VARARGS },
{ "ActEmotion", playerActEmotion, METH_VARARGS },
{ "ShowPlayer", playerShowPlayer, METH_VARARGS },
{ "HidePlayer", playerHidePlayer, METH_VARARGS },
{ "ComboAttack", playerComboAttack, METH_VARARGS },
#ifdef ENABLE_MULTILANGUAGE_SYSTEM
{ "RequestFlag", playerRequestFlag, METH_VARARGS },
#endif
{ "SetAutoCameraRotationSpeed", playerSetAutoCameraRotationSpeed, METH_VARARGS },
{ "SetAttackKeyState", playerSetAttackKeyState, METH_VARARGS },
{ "SetSingleDIKKeyState", playerSetSingleDIKKeyState, METH_VARARGS },
{ "EndKeyWalkingImmediately", playerEndKeyWalkingImmediately, METH_VARARGS },
{ "StartMouseWalking", playerStartMouseWalking, METH_VARARGS },
{ "EndMouseWalking", playerEndMouseWalking, METH_VARARGS },
{ "ResetCameraRotation", playerResetCameraRotation, METH_VARARGS },
{ "SetQuickCameraMode", playerSetQuickCameraMode, METH_VARARGS },
///////////////////////////////////////////////////////////////////////////////////////////
{ "SetSkill", playerSetSkill, METH_VARARGS },
{ "GetSkillIndex", playerGetSkillIndex, METH_VARARGS },
{ "GetSkillSlotIndex", playerGetSkillSlotIndex, METH_VARARGS },
{ "GetSkillGrade", playerGetSkillGrade, METH_VARARGS },
{ "GetSkillLevel", playerGetSkillLevel, METH_VARARGS },
{ "GetSkillCurrentEfficientPercentage", playerGetSkillCurrentEfficientPercentage, METH_VARARGS },
{ "GetSkillNextEfficientPercentage", playerGetSkillNextEfficientPercentage, METH_VARARGS },
{ "ClickSkillSlot", playerClickSkillSlot, METH_VARARGS },
{ "ChangeCurrentSkillNumberOnly", playerChangeCurrentSkillNumberOnly, METH_VARARGS },
{ "ClearSkillDict", playerClearSkillDict, METH_VARARGS },
{ "GetItemIndex", playerGetItemIndex, METH_VARARGS },
{ "GetItemFlags", playerGetItemFlags, METH_VARARGS },
{ "GetItemCount", playerGetItemCount, METH_VARARGS },
{ "GetItemCountByVnum", playerGetItemCountByVnum, METH_VARARGS },
{ "GetItemMetinSocket", playerGetItemMetinSocket, METH_VARARGS },
{ "GetItemAttribute", playerGetItemAttribute, METH_VARARGS },
#ifdef ENABLE_SPECIAL_STORAGE
{ "GetItemCountByTT", playerGetItemCountByTT, METH_VARARGS },
#endif
#if defined(GAIDEN)
{ "GetItemUnbindTime", playerGetItemUnbindTime, METH_VARARGS },
#endif
{ "GetISellItemPrice", playerGetISellItemPrice, METH_VARARGS },
{ "MoveItem", playerMoveItem, METH_VARARGS },
{ "SendClickItemPacket", playerSendClickItemPacket, METH_VARARGS },
///////////////////////////////////////////////////////////////////////////////////////////
{ "GetName", playerGetName, METH_VARARGS },
{ "IsGameMaster", playerIsGameMaster, METH_VARARGS },
{ "GetJob", playerGetJob, METH_VARARGS },
{ "GetRace", playerGetRace, METH_VARARGS },
{ "GetPlayTime", playerGetPlayTime, METH_VARARGS },
{ "SetPlayTime", playerSetPlayTime, METH_VARARGS },
{ "IsSkillCoolTime", playerIsSkillCoolTime, METH_VARARGS },
{ "GetSkillCoolTime", playerGetSkillCoolTime, METH_VARARGS },
{ "IsSkillActive", playerIsSkillActive, METH_VARARGS },
{ "UseGuildSkill", playerUseGuildSkill, METH_VARARGS },
{ "AffectIndexToSkillIndex", playerAffectIndexToSkillIndex, METH_VARARGS },
{ "GetEXP", playerGetEXP, METH_VARARGS },
#ifdef ENABLE_CONQUEROR_LEVEL
{ "GetConquerorEXP", playerGetConquerorEXP, METH_VARARGS },
#endif
{ "GetStatus", playerGetStatus, METH_VARARGS },
{ "SetStatus", playerSetStatus, METH_VARARGS },
{ "GetElk", playerGetElk, METH_VARARGS },
{ "GetMoney", playerGetElk, METH_VARARGS },
{ "GetGuildID", playerGetGuildID, METH_VARARGS },
{ "GetGuildName", playerGetGuildName, METH_VARARGS },
{ "GetAlignmentData", playerGetAlignmentData, METH_VARARGS },
{ "RequestAddLocalQuickSlot", playerRequestAddLocalQuickSlot, METH_VARARGS },
{ "RequestAddToEmptyLocalQuickSlot", playerRequestAddToEmptyLocalQuickSlot, METH_VARARGS },
{ "RequestDeleteGlobalQuickSlot", playerRequestDeleteGlobalQuickSlot, METH_VARARGS },
{ "RequestMoveGlobalQuickSlotToLocalQuickSlot", playerRequestMoveGlobalQuickSlotToLocalQuickSlot, METH_VARARGS },
{ "RequestUseLocalQuickSlot", playerRequestUseLocalQuickSlot, METH_VARARGS },
{ "LocalQuickSlotIndexToGlobalQuickSlotIndex", playerLocalQuickSlotIndexToGlobalQuickSlotIndex, METH_VARARGS },
{ "GetQuickPage", playerGetQuickPage, METH_VARARGS },
{ "SetQuickPage", playerSetQuickPage, METH_VARARGS },
{ "GetLocalQuickSlot", playerGetLocalQuickSlot, METH_VARARGS },
{ "GetGlobalQuickSlot", playerGetGlobalQuickSlot, METH_VARARGS },
{ "RemoveQuickSlotByValue", playerRemoveQuickSlotByValue, METH_VARARGS },
{ "isItem", playerisItem, METH_VARARGS },
{ "IsEquipmentSlot", playerIsEquipmentSlot, METH_VARARGS },
{ "IsDSEquipmentSlot", playerIsDSEquipmentSlot, METH_VARARGS },
{ "IsCostumeSlot", playerIsCostumeSlot, METH_VARARGS },
{ "IsValuableItem", playerIsValuableItem, METH_VARARGS },
{ "IsOpenPrivateShop", playerIsOpenPrivateShop, METH_VARARGS },
#ifdef ENABLE_SHINING_SYSTEM
{ "IsShiningSlot", playerIsShiningSlot, METH_VARARGS },
#endif
#ifdef ENABLE_NEW_EQUIPMENT_SYSTEM
{ "IsBeltInventorySlot", playerIsBeltInventorySlot, METH_VARARGS },
{ "IsEquippingBelt", playerIsEquippingBelt, METH_VARARGS },
{ "IsAvailableBeltInventoryCell", playerIsAvailableBeltInventoryCell, METH_VARARGS },
#endif
#ifdef ELEMENT_SPELL_WORLDARD
{ "GetItemElementGrade", playerGetItemElementGrade, METH_VARARGS },
{ "GetItemElementAttack", playerGetItemElementAttack, METH_VARARGS },
{ "GetItemElementType", playerGetItemElementType, METH_VARARGS },
{ "GetItemElementValue", playerGetItemElementValue, METH_VARARGS },
{ "GetElements", playerElements, METH_VARARGS },
#endif
// Refine
{ "GetItemGrade", playerGetItemGrade, METH_VARARGS },
{ "CanRefine", playerCanRefine, METH_VARARGS },
{ "CanDetach", playerCanDetach, METH_VARARGS },
{ "CanUnlock", playerCanUnlock, METH_VARARGS },
{ "CanAttachMetin", playerCanAttachMetin, METH_VARARGS },
{ "IsRefineGradeScroll", playerIsRefineGradeScroll, METH_VARARGS },
{ "ClearTarget", playerClearTarget, METH_VARARGS },
{ "SetTarget", playerSetTarget, METH_VARARGS },
{ "OpenCharacterMenu", playerOpenCharacterMenu, METH_VARARGS },
{ "Update", playerUpdate, METH_VARARGS },
{ "Render", playerRender, METH_VARARGS },
{ "Clear", playerClear, METH_VARARGS },
#if defined(WJ_COMBAT_ZONE)
{ "IsCombatZoneMap", playerIsCombatZoneMap, METH_VARARGS },
{ "GetCombatZonePoints", playerGetCombatZonePoints, METH_VARARGS },
#endif
// Party
{ "IsPartyMember", playerIsPartyMember, METH_VARARGS },
{ "IsPartyLeader", playerIsPartyLeader, METH_VARARGS },
{ "IsPartyLeaderByPID", playerIsPartyLeaderByPID, METH_VARARGS },
{ "GetPartyMemberHPPercentage", playerGetPartyMemberHPPercentage, METH_VARARGS },
{ "GetPartyMemberState", playerGetPartyMemberState, METH_VARARGS },
{ "GetPartyMemberAffects", playerGetPartyMemberAffects, METH_VARARGS },
{ "RemovePartyMember", playerRemovePartyMember, METH_VARARGS },
{ "ExitParty", playerExitParty, METH_VARARGS },
// PK Mode
{ "GetPKMode", playerGetPKMode, METH_VARARGS },
// Mobile
{ "HasMobilePhoneNumber", playerHasMobilePhoneNumber, METH_VARARGS },
// Emotion
{ "RegisterEmotionIcon", playerRegisterEmotionIcon, METH_VARARGS },
{ "GetEmotionIconImage", playerGetEmotionIconImage, METH_VARARGS },
// For System
{ "SetWeaponAttackBonusFlag", playerSetWeaponAttackBonusFlag, METH_VARARGS },
{ "ToggleCoolTime", playerToggleCoolTime, METH_VARARGS },
{ "ToggleLevelLimit", playerToggleLevelLimit, METH_VARARGS },
{ "GetTargetVID", playerGetTargetVID, METH_VARARGS },
{ "SetItemData", playerSetItemData, METH_VARARGS },
{ "SetItemMetinSocket", playerSetItemMetinSocket, METH_VARARGS },
{ "SetItemAttribute", playerSetItemAttribute, METH_VARARGS },
{ "SetItemCount", playerSetItemCount, METH_VARARGS },
{ "GetItemLink", playerGetItemLink, METH_VARARGS },
{ "SlotTypeToInvenType", playerSlotTypeToInvenType, METH_VARARGS },
{ "SendDragonSoulRefine", playerSendDragonSoulRefine, METH_VARARGS },
#ifdef ENABLE_GLOVE_SYSTEM
{ "GetItemRandomAttribute", playerGetItemRandomAttribute, METH_VARARGS },
#endif
#ifdef ENABLE_SEALBIND_SYSTEM
{ "CanSealItem", playerCanSealItem, METH_VARARGS },
{ "GetItemSealDate", playerGetItemSealDate, METH_VARARGS },
{ "GetItemUnSealLeftTime", GetItemUnSealLeftTime, METH_VARARGS },
#endif
#ifdef ENABLE_NEW_NAME_ITEM
{ "GetItemNewName", playerGetItemNewName, METH_VARARGS },
#endif
#ifdef ENABLE_NEW_DETAILS_GUI
{ "GetKillLOG", playerGetKillLOG, METH_VARARGS },
#endif
{ "GetMainCharacterPart", playerGetMainCharacterPart, METH_VARARGS },
{ "GetMainCharacterShiningPart", playerGetMainCharacterShiningPart, METH_VARARGS },
#ifdef ENABLE_ULTIMATE_REGEN
{ "LoadNewRegen", playerLoadNewRegen, METH_VARARGS },
#endif
#ifdef ENABLE_GEM_SYSTEM
{ "GetGem", playerGetGem, METH_VARARGS },
#endif
#ifdef ENABLE_MINI_GAME_CATCH_KING
{ "SetEventGame", playerSetEventGame, METH_VARARGS },
{ "GetEventGame", playerGetEventGame, METH_VARARGS },
#endif
{ NULL, NULL, NULL },
};
PyObject* poModule = Py_InitModule ("player", s_methods);
PyModule_AddIntConstant(poModule, "LEVEL", POINT_LEVEL);
#ifdef ENABLE_CONQUEROR_LEVEL
PyModule_AddIntConstant(poModule, "CONQUEROR_LEVEL", POINT_CONQUEROR_LEVEL);
PyModule_AddIntConstant(poModule, "CONQUEROR_LEVEL_STEP", POINT_CONQUEROR_LEVEL_STEP);
PyModule_AddIntConstant(poModule, "SUNGMA_STR", POINT_SUNGMA_STR);
PyModule_AddIntConstant(poModule, "SUNGMA_HP", POINT_SUNGMA_HP);
PyModule_AddIntConstant(poModule, "SUNGMA_MOVE", POINT_SUNGMA_MOVE);
PyModule_AddIntConstant(poModule, "SUNGMA_INMUNE", POINT_SUNGMA_INMUNE);
PyModule_AddIntConstant(poModule, "CONQUEROR_POINT", POINT_CONQUEROR_POINT);
PyModule_AddIntConstant(poModule, "CONQUEROR_EXP", POINT_CONQUEROR_EXP);
PyModule_AddIntConstant(poModule, "CONQUEROR_NEXT_EXP", POINT_CONQUEROR_NEXT_EXP);
#endif
PyModule_AddIntConstant(poModule, "VOICE", POINT_VOICE);
PyModule_AddIntConstant(poModule, "EXP", POINT_EXP);
PyModule_AddIntConstant(poModule, "NEXT_EXP", POINT_NEXT_EXP);
PyModule_AddIntConstant(poModule, "HP", POINT_HP);
PyModule_AddIntConstant(poModule, "MAX_HP", POINT_MAX_HP);
PyModule_AddIntConstant(poModule, "SP", POINT_SP);
PyModule_AddIntConstant(poModule, "MAX_SP", POINT_MAX_SP);
PyModule_AddIntConstant(poModule, "STAMINA", POINT_STAMINA);
PyModule_AddIntConstant(poModule, "MAX_STAMINA", POINT_MAX_STAMINA);
PyModule_AddIntConstant(poModule, "ELK", POINT_GOLD);
PyModule_AddIntConstant(poModule, "ST", POINT_ST);
PyModule_AddIntConstant(poModule, "HT", POINT_HT);
PyModule_AddIntConstant(poModule, "DX", POINT_DX);
PyModule_AddIntConstant(poModule, "IQ", POINT_IQ);
PyModule_AddIntConstant(poModule, "ATT_POWER", POINT_ATT_POWER);
PyModule_AddIntConstant(poModule, "ATT_MIN", POINT_MIN_ATK);
PyModule_AddIntConstant(poModule, "ATT_MAX", POINT_MAX_ATK);
PyModule_AddIntConstant(poModule, "MIN_MAGIC_WEP", POINT_MIN_MAGIC_WEP);
PyModule_AddIntConstant(poModule, "MAX_MAGIC_WEP", POINT_MAX_MAGIC_WEP);
PyModule_AddIntConstant(poModule, "ATT_SPEED", POINT_ATT_SPEED);
PyModule_AddIntConstant(poModule, "ATT_BONUS", POINT_ATT_GRADE_BONUS);
PyModule_AddIntConstant(poModule, "EVADE_RATE", POINT_EVADE_RATE);
PyModule_AddIntConstant(poModule, "MOVING_SPEED", POINT_MOV_SPEED);
PyModule_AddIntConstant(poModule, "DEF_GRADE", POINT_DEF_GRADE);
PyModule_AddIntConstant(poModule, "DEF_BONUS", POINT_DEF_GRADE_BONUS);
PyModule_AddIntConstant(poModule, "CASTING_SPEED", POINT_CASTING_SPEED);
PyModule_AddIntConstant(poModule, "MAG_ATT", POINT_MAGIC_ATT_GRADE);
PyModule_AddIntConstant(poModule, "MAG_DEF", POINT_MAGIC_DEF_GRADE);
PyModule_AddIntConstant(poModule, "EMPIRE_POINT", POINT_EMPIRE_POINT);
PyModule_AddIntConstant(poModule, "STAT", POINT_STAT);
PyModule_AddIntConstant(poModule, "SKILL_PASSIVE", POINT_SUB_SKILL);
PyModule_AddIntConstant(poModule, "SKILL_SUPPORT", POINT_SUB_SKILL);
PyModule_AddIntConstant(poModule, "SKILL_ACTIVE", POINT_SKILL);
PyModule_AddIntConstant(poModule, "SKILL_HORSE", POINT_HORSE_SKILL);
PyModule_AddIntConstant(poModule, "PLAYTIME", POINT_PLAYTIME);
PyModule_AddIntConstant(poModule, "BOW_DISTANCE", POINT_BOW_DISTANCE);
PyModule_AddIntConstant(poModule, "HP_RECOVERY", POINT_HP_RECOVERY);
PyModule_AddIntConstant(poModule, "SP_RECOVERY", POINT_SP_RECOVERY);
PyModule_AddIntConstant(poModule, "ATTACKER_BONUS", POINT_PARTY_ATT_GRADE);
PyModule_AddIntConstant(poModule, "MAX_NUM", POINT_MAX_NUM);
////
PyModule_AddIntConstant(poModule, "POINT_CRITICAL_PCT", POINT_CRITICAL_PCT);
PyModule_AddIntConstant(poModule, "POINT_PENETRATE_PCT", POINT_PENETRATE_PCT);
PyModule_AddIntConstant(poModule, "POINT_MALL_ATTBONUS", POINT_MALL_ATTBONUS);
PyModule_AddIntConstant(poModule, "POINT_MALL_DEFBONUS", POINT_MALL_DEFBONUS);
PyModule_AddIntConstant(poModule, "POINT_MALL_EXPBONUS", POINT_MALL_EXPBONUS);
PyModule_AddIntConstant(poModule, "POINT_MALL_ITEMBONUS", POINT_MALL_ITEMBONUS);
PyModule_AddIntConstant(poModule, "POINT_MALL_GOLDBONUS", POINT_MALL_GOLDBONUS);
PyModule_AddIntConstant(poModule, "POINT_MAX_HP_PCT", POINT_MAX_HP_PCT);
PyModule_AddIntConstant(poModule, "POINT_MAX_SP_PCT", POINT_MAX_SP_PCT);
PyModule_AddIntConstant(poModule, "POINT_SKILL_DAMAGE_BONUS", POINT_SKILL_DAMAGE_BONUS);
PyModule_AddIntConstant(poModule, "POINT_NORMAL_HIT_DAMAGE_BONUS", POINT_NORMAL_HIT_DAMAGE_BONUS);
PyModule_AddIntConstant(poModule, "POINT_SKILL_DEFEND_BONUS", POINT_SKILL_DEFEND_BONUS);
PyModule_AddIntConstant(poModule, "POINT_NORMAL_HIT_DEFEND_BONUS", POINT_NORMAL_HIT_DEFEND_BONUS);
PyModule_AddIntConstant(poModule, "POINT_PC_BANG_EXP_BONUS", POINT_PC_BANG_EXP_BONUS);
PyModule_AddIntConstant(poModule, "POINT_PC_BANG_DROP_BONUS", POINT_PC_BANG_DROP_BONUS);
PyModule_AddIntConstant(poModule, "ENERGY", POINT_ENERGY);
PyModule_AddIntConstant(poModule, "ENERGY_END_TIME", POINT_ENERGY_END_TIME);
PyModule_AddIntConstant(poModule, "SKILL_GRADE_NORMAL", CPythonPlayer::SKILL_NORMAL);
PyModule_AddIntConstant(poModule, "SKILL_GRADE_MASTER", CPythonPlayer::SKILL_MASTER);
PyModule_AddIntConstant(poModule, "SKILL_GRADE_GRAND_MASTER", CPythonPlayer::SKILL_GRAND_MASTER);
PyModule_AddIntConstant(poModule, "SKILL_GRADE_PERFECT_MASTER", CPythonPlayer::SKILL_PERFECT_MASTER);
PyModule_AddIntConstant(poModule, "CATEGORY_ACTIVE", CPythonPlayer::CATEGORY_ACTIVE);
PyModule_AddIntConstant(poModule, "CATEGORY_PASSIVE", CPythonPlayer::CATEGORY_PASSIVE);
PyModule_AddIntConstant(poModule, "INVENTORY_PAGE_COLUMN", c_Inventory_Page_Column);
PyModule_AddIntConstant(poModule, "INVENTORY_PAGE_ROW", c_Inventory_Page_Row);
PyModule_AddIntConstant(poModule, "INVENTORY_PAGE_SIZE", c_Inventory_Page_Size);
PyModule_AddIntConstant(poModule, "INVENTORY_PAGE_COUNT", c_Inventory_Page_Count);
PyModule_AddIntConstant(poModule, "INVENTORY_SLOT_COUNT", c_Inventory_Count);
PyModule_AddIntConstant(poModule, "EQUIPMENT_SLOT_START", c_Equipment_Start);
PyModule_AddIntConstant(poModule, "EQUIPMENT_PAGE_COUNT", c_Equipment_Count);
#ifdef ENABLE_NEW_EQUIPMENT_SYSTEM
PyModule_AddIntConstant(poModule, "NEW_EQUIPMENT_SLOT_START", c_New_Equipment_Start);
PyModule_AddIntConstant(poModule, "NEW_EQUIPMENT_SLOT_COUNT", c_New_Equipment_Count);
#endif
PyModule_AddIntConstant(poModule, "MBF_SKILL", CPythonPlayer::MBF_SKILL);
PyModule_AddIntConstant(poModule, "MBF_ATTACK", CPythonPlayer::MBF_ATTACK);
PyModule_AddIntConstant(poModule, "MBF_CAMERA", CPythonPlayer::MBF_CAMERA);
PyModule_AddIntConstant(poModule, "MBF_SMART", CPythonPlayer::MBF_SMART);
PyModule_AddIntConstant(poModule, "MBF_MOVE", CPythonPlayer::MBF_MOVE);
PyModule_AddIntConstant(poModule, "MBF_AUTO", CPythonPlayer::MBF_AUTO);
PyModule_AddIntConstant(poModule, "MBS_PRESS", CPythonPlayer::MBS_PRESS);
PyModule_AddIntConstant(poModule, "MBS_CLICK", CPythonPlayer::MBS_CLICK);
PyModule_AddIntConstant(poModule, "MBT_RIGHT", CPythonPlayer::MBT_RIGHT);
PyModule_AddIntConstant(poModule, "MBT_LEFT", CPythonPlayer::MBT_LEFT);
#ifdef WJ_ENABLE_TRADABLE_ICON
PyModule_AddIntConstant(poModule, "ON_TOP_WND_NONE", ON_TOP_WND_NONE);
PyModule_AddIntConstant(poModule, "ON_TOP_WND_SHOP", ON_TOP_WND_SHOP);
PyModule_AddIntConstant(poModule, "ON_TOP_WND_EXCHANGE", ON_TOP_WND_EXCHANGE);
PyModule_AddIntConstant(poModule, "ON_TOP_WND_SAFEBOX", ON_TOP_WND_SAFEBOX);
PyModule_AddIntConstant(poModule, "ON_TOP_WND_PRIVATE_SHOP", ON_TOP_WND_PRIVATE_SHOP);
PyModule_AddIntConstant(poModule, "ON_TOP_WND_ITEM_COMB", ON_TOP_WND_ITEM_COMB);
PyModule_AddIntConstant(poModule, "ON_TOP_WND_PET_FEED", ON_TOP_WND_PET_FEED);
#if defined(__BL_67_ATTR__)
PyModule_AddIntConstant(poModule, "ON_TOP_WND_ATTR_67", ON_TOP_WND_ATTR_67);
#endif
#endif
// Public code with server
PyModule_AddIntConstant(poModule, "SLOT_TYPE_NONE", SLOT_TYPE_NONE);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_INVENTORY", SLOT_TYPE_INVENTORY);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_SKILL", SLOT_TYPE_SKILL);
// Special indecies for client
PyModule_AddIntConstant(poModule, "SLOT_TYPE_SHOP", SLOT_TYPE_SHOP);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_EXCHANGE_OWNER", SLOT_TYPE_EXCHANGE_OWNER);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_EXCHANGE_TARGET", SLOT_TYPE_EXCHANGE_TARGET);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_QUICK_SLOT", SLOT_TYPE_QUICK_SLOT);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_SAFEBOX", SLOT_TYPE_SAFEBOX);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_PRIVATE_SHOP", SLOT_TYPE_PRIVATE_SHOP);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_MALL", SLOT_TYPE_MALL);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_EMOTION", SLOT_TYPE_EMOTION);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_DRAGON_SOUL_INVENTORY", SLOT_TYPE_DRAGON_SOUL_INVENTORY);
PyModule_AddIntConstant(poModule, "RESERVED_WINDOW", RESERVED_WINDOW);
PyModule_AddIntConstant(poModule, "INVENTORY", INVENTORY);
PyModule_AddIntConstant(poModule, "EQUIPMENT", EQUIPMENT);
PyModule_AddIntConstant(poModule, "SAFEBOX", SAFEBOX);
PyModule_AddIntConstant(poModule, "MALL", MALL);
PyModule_AddIntConstant(poModule, "DRAGON_SOUL_INVENTORY", DRAGON_SOUL_INVENTORY);
PyModule_AddIntConstant(poModule, "GROUND", GROUND);
#ifdef ENABLE_SWITCHBOT
PyModule_AddIntConstant(poModule, "SWITCHBOT", SWITCHBOT);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_SWITCHBOT", SLOT_TYPE_SWITCHBOT);
#endif
#ifdef CHANGE_EQUIP_WORLDARD
PyModule_AddIntConstant(poModule, "CHANGE_EQUIP", CHANGE_EQUIP);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_CHANGE_EQUIP", SLOT_TYPE_CHANGE_EQUIP);
PyModule_AddIntConstant(poModule, "CHANGE_EQUIP_SLOT_START", c_change_equip_Slot_Start);
PyModule_AddIntConstant(poModule, "CHANGE_EQUIP_SLOT_COUNT", CHANGE_EQUIP_SLOT_COUNT);
PyModule_AddIntConstant(poModule, "CHANGE_EQUIP_PAGE_EXTRA", CHANGE_EQUIP_PAGE_EXTRA);
#endif
PyModule_AddIntConstant(poModule, "ITEM_MONEY", -1);
PyModule_AddIntConstant(poModule, "SKILL_SLOT_COUNT", SKILL_MAX_NUM);
PyModule_AddIntConstant(poModule, "EFFECT_PICK", CPythonPlayer::EFFECT_PICK);
PyModule_AddIntConstant(poModule, "METIN_SOCKET_TYPE_NONE", CPythonPlayer::METIN_SOCKET_TYPE_NONE);
PyModule_AddIntConstant(poModule, "METIN_SOCKET_TYPE_SILVER", CPythonPlayer::METIN_SOCKET_TYPE_SILVER);
PyModule_AddIntConstant(poModule, "METIN_SOCKET_TYPE_GOLD", CPythonPlayer::METIN_SOCKET_TYPE_GOLD);
PyModule_AddIntConstant(poModule, "METIN_SOCKET_MAX_NUM", ITEM_SOCKET_SLOT_MAX_NUM);
// refactored attribute slot begin
PyModule_AddIntConstant(poModule, "ATTRIBUTE_SLOT_NORM_NUM", ITEM_ATTRIBUTE_SLOT_NORM_NUM);
PyModule_AddIntConstant(poModule, "ATTRIBUTE_SLOT_RARE_NUM", ITEM_ATTRIBUTE_SLOT_RARE_NUM);
PyModule_AddIntConstant(poModule, "ATTRIBUTE_SLOT_NORM_START", ITEM_ATTRIBUTE_SLOT_NORM_START);
PyModule_AddIntConstant(poModule, "ATTRIBUTE_SLOT_NORM_END", ITEM_ATTRIBUTE_SLOT_NORM_END);
PyModule_AddIntConstant(poModule, "ATTRIBUTE_SLOT_RARE_START", ITEM_ATTRIBUTE_SLOT_RARE_START);
PyModule_AddIntConstant(poModule, "ATTRIBUTE_SLOT_RARE_END", ITEM_ATTRIBUTE_SLOT_RARE_END);
PyModule_AddIntConstant(poModule, "ATTRIBUTE_SLOT_MAX_NUM", ITEM_ATTRIBUTE_SLOT_MAX_NUM);
// refactored attribute slot end
PyModule_AddIntConstant(poModule, "REFINE_CANT", REFINE_CANT);
PyModule_AddIntConstant(poModule, "REFINE_OK", REFINE_OK);
PyModule_AddIntConstant(poModule, "REFINE_ALREADY_MAX_SOCKET_COUNT", REFINE_ALREADY_MAX_SOCKET_COUNT);
PyModule_AddIntConstant(poModule, "REFINE_NEED_MORE_GOOD_SCROLL", REFINE_NEED_MORE_GOOD_SCROLL);
PyModule_AddIntConstant(poModule, "REFINE_CANT_MAKE_SOCKET_ITEM", REFINE_CANT_MAKE_SOCKET_ITEM);
PyModule_AddIntConstant(poModule, "REFINE_NOT_NEXT_GRADE_ITEM", REFINE_NOT_NEXT_GRADE_ITEM);
PyModule_AddIntConstant(poModule, "REFINE_CANT_REFINE_METIN_TO_EQUIPMENT", REFINE_CANT_REFINE_METIN_TO_EQUIPMENT);
PyModule_AddIntConstant(poModule, "REFINE_CANT_REFINE_ROD", REFINE_CANT_REFINE_ROD);
PyModule_AddIntConstant(poModule, "ATTACH_METIN_CANT", ATTACH_METIN_CANT);
PyModule_AddIntConstant(poModule, "ATTACH_METIN_OK", ATTACH_METIN_OK);
PyModule_AddIntConstant(poModule, "ATTACH_METIN_NOT_MATCHABLE_ITEM", ATTACH_METIN_NOT_MATCHABLE_ITEM);
PyModule_AddIntConstant(poModule, "ATTACH_METIN_NO_MATCHABLE_SOCKET", ATTACH_METIN_NO_MATCHABLE_SOCKET);
PyModule_AddIntConstant(poModule, "ATTACH_METIN_NOT_EXIST_GOLD_SOCKET", ATTACH_METIN_NOT_EXIST_GOLD_SOCKET);
PyModule_AddIntConstant(poModule, "ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT", ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT);
PyModule_AddIntConstant(poModule, "DETACH_METIN_CANT", DETACH_METIN_CANT);
PyModule_AddIntConstant(poModule, "DETACH_METIN_OK", DETACH_METIN_OK);
#ifdef ELEMENT_SPELL_WORLDARD
PyModule_AddIntConstant(poModule, "ATT_ELEMENTS", POINT_ATT_ELEMENTS);
PyModule_AddIntConstant(poModule, "ELEMENT_UPGRADE_CANT_ADD", ELEMENT_UPGRADE_CANT_ADD);
PyModule_AddIntConstant(poModule, "ELEMENT_UPGRADE_ADD", ELEMENT_UPGRADE_ADD);
PyModule_AddIntConstant(poModule, "ELEMENT_DOWNGRADE_CANT_ADD", ELEMENT_DOWNGRADE_CANT_ADD);
PyModule_AddIntConstant(poModule, "ELEMENT_DOWNGRADE_ADD", ELEMENT_DOWNGRADE_ADD);
PyModule_AddIntConstant(poModule, "ELEMENT_CANT_WORLDARD", ELEMENT_CANT_WORLDARD);
PyModule_AddIntConstant(poModule, "ELEMENT_CHANGE_ADD", ELEMENT_CHANGE_ADD);
PyModule_AddIntConstant(poModule, "ELEMENT_CHANGE_CANT_ADD", ELEMENT_CHANGE_CANT_ADD);
PyModule_AddIntConstant(poModule, "MAX_ELEMENTS_SPELL", MAX_ELEMENTS_SPELL);
#endif
// Party
PyModule_AddIntConstant(poModule, "PARTY_STATE_NORMAL", CPythonPlayer::PARTY_ROLE_NORMAL);
PyModule_AddIntConstant(poModule, "PARTY_STATE_LEADER", CPythonPlayer::PARTY_ROLE_LEADER);
PyModule_AddIntConstant(poModule, "PARTY_STATE_ATTACKER", CPythonPlayer::PARTY_ROLE_ATTACKER);
PyModule_AddIntConstant(poModule, "PARTY_STATE_TANKER", CPythonPlayer::PARTY_ROLE_TANKER);
PyModule_AddIntConstant(poModule, "PARTY_STATE_BUFFER", CPythonPlayer::PARTY_ROLE_BUFFER);
PyModule_AddIntConstant(poModule, "PARTY_STATE_SKILL_MASTER", CPythonPlayer::PARTY_ROLE_SKILL_MASTER);
PyModule_AddIntConstant(poModule, "PARTY_STATE_BERSERKER", CPythonPlayer::PARTY_ROLE_BERSERKER);
PyModule_AddIntConstant(poModule, "PARTY_STATE_DEFENDER", CPythonPlayer::PARTY_ROLE_DEFENDER);
PyModule_AddIntConstant(poModule, "PARTY_STATE_MAX_NUM", CPythonPlayer::PARTY_ROLE_MAX_NUM);
// Skill Index
PyModule_AddIntConstant(poModule, "SKILL_INDEX_TONGSOL", c_iSkillIndex_Tongsol);
PyModule_AddIntConstant(poModule, "SKILL_INDEX_FISHING", c_iSkillIndex_Fishing);
PyModule_AddIntConstant(poModule, "SKILL_INDEX_MINING", c_iSkillIndex_Mining);
PyModule_AddIntConstant(poModule, "SKILL_INDEX_MAKING", c_iSkillIndex_Making);
PyModule_AddIntConstant(poModule, "SKILL_INDEX_COMBO", c_iSkillIndex_Combo);
PyModule_AddIntConstant(poModule, "SKILL_INDEX_LANGUAGE1", c_iSkillIndex_Language1);
PyModule_AddIntConstant(poModule, "SKILL_INDEX_LANGUAGE2", c_iSkillIndex_Language2);
PyModule_AddIntConstant(poModule, "SKILL_INDEX_LANGUAGE3", c_iSkillIndex_Language3);
PyModule_AddIntConstant(poModule, "SKILL_INDEX_POLYMORPH", c_iSkillIndex_Polymorph);
PyModule_AddIntConstant(poModule, "SKILL_INDEX_RIDING", c_iSkillIndex_Riding);
PyModule_AddIntConstant(poModule, "SKILL_INDEX_SUMMON", c_iSkillIndex_Summon);
// PK Mode
PyModule_AddIntConstant(poModule, "PK_MODE_PEACE", PK_MODE_PEACE);
PyModule_AddIntConstant(poModule, "PK_MODE_REVENGE", PK_MODE_REVENGE);
PyModule_AddIntConstant(poModule, "PK_MODE_FREE", PK_MODE_FREE);
PyModule_AddIntConstant(poModule, "PK_MODE_PROTECT", PK_MODE_PROTECT);
PyModule_AddIntConstant(poModule, "PK_MODE_GUILD", PK_MODE_GUILD);
PyModule_AddIntConstant(poModule, "PK_MODE_MAX_NUM", PK_MODE_MAX_NUM);
#ifdef ENABLE_FEATURES_REFINE_SYSTEM
PyModule_AddIntConstant(poModule, "REFINE_PERCENTAGE_LOW", REFINE_PERCENTAGE_LOW);
PyModule_AddIntConstant(poModule, "REFINE_PERCENTAGE_MEDIUM", REFINE_PERCENTAGE_MEDIUM);
PyModule_AddIntConstant(poModule, "REFINE_PERCENTAGE_EXTRA", REFINE_PERCENTAGE_EXTRA);
PyModule_AddIntConstant(poModule, "REFINE_VNUM_POTION_LOW", REFINE_VNUM_POTION_LOW);
PyModule_AddIntConstant(poModule, "REFINE_VNUM_POTION_MEDIUM", REFINE_VNUM_POTION_MEDIUM);
PyModule_AddIntConstant(poModule, "REFINE_VNUM_POTION_EXTRA", REFINE_VNUM_POTION_EXTRA);
#endif
// Block Mode
PyModule_AddIntConstant(poModule, "BLOCK_EXCHANGE", BLOCK_EXCHANGE);
PyModule_AddIntConstant(poModule, "BLOCK_PARTY", BLOCK_PARTY_INVITE);
PyModule_AddIntConstant(poModule, "BLOCK_GUILD", BLOCK_GUILD_INVITE);
PyModule_AddIntConstant(poModule, "BLOCK_WHISPER", BLOCK_WHISPER);
PyModule_AddIntConstant(poModule, "BLOCK_FRIEND", BLOCK_MESSENGER_INVITE);
PyModule_AddIntConstant(poModule, "BLOCK_PARTY_REQUEST", BLOCK_PARTY_REQUEST);
// Party
PyModule_AddIntConstant(poModule, "PARTY_EXP_NON_DISTRIBUTION", PARTY_EXP_DISTRIBUTION_NON_PARITY);
PyModule_AddIntConstant(poModule, "PARTY_EXP_DISTRIBUTION_PARITY", PARTY_EXP_DISTRIBUTION_PARITY);
// Emotion
PyModule_AddIntConstant(poModule, "EMOTION_CLAP", EMOTION_CLAP);
PyModule_AddIntConstant(poModule, "EMOTION_CHEERS_1", EMOTION_CHEERS_1);
PyModule_AddIntConstant(poModule, "EMOTION_CHEERS_2", EMOTION_CHEERS_2);
PyModule_AddIntConstant(poModule, "EMOTION_DANCE_1", EMOTION_DANCE_1);
PyModule_AddIntConstant(poModule, "EMOTION_DANCE_2", EMOTION_DANCE_2);
PyModule_AddIntConstant(poModule, "EMOTION_DANCE_3", EMOTION_DANCE_3);
PyModule_AddIntConstant(poModule, "EMOTION_DANCE_4", EMOTION_DANCE_4);
PyModule_AddIntConstant(poModule, "EMOTION_DANCE_5", EMOTION_DANCE_5);
PyModule_AddIntConstant(poModule, "EMOTION_DANCE_6", EMOTION_DANCE_6); // PSY 강남스타일
PyModule_AddIntConstant(poModule, "EMOTION_CONGRATULATION", EMOTION_CONGRATULATION);
PyModule_AddIntConstant(poModule, "EMOTION_FORGIVE", EMOTION_FORGIVE);
PyModule_AddIntConstant(poModule, "EMOTION_ANGRY", EMOTION_ANGRY);
PyModule_AddIntConstant(poModule, "EMOTION_ATTRACTIVE", EMOTION_ATTRACTIVE);
PyModule_AddIntConstant(poModule, "EMOTION_SAD", EMOTION_SAD);
PyModule_AddIntConstant(poModule, "EMOTION_SHY", EMOTION_SHY);
PyModule_AddIntConstant(poModule, "EMOTION_CHEERUP", EMOTION_CHEERUP);
PyModule_AddIntConstant(poModule, "EMOTION_BANTER", EMOTION_BANTER);
PyModule_AddIntConstant(poModule, "EMOTION_JOY", EMOTION_JOY);
PyModule_AddIntConstant(poModule, "EMOTION_KISS", EMOTION_KISS);
PyModule_AddIntConstant(poModule, "EMOTION_FRENCH_KISS", EMOTION_FRENCH_KISS);
PyModule_AddIntConstant(poModule, "EMOTION_SLAP", EMOTION_SLAP);
//// 자동물약 타입
PyModule_AddIntConstant(poModule, "AUTO_POTION_TYPE_HP", CPythonPlayer::AUTO_POTION_TYPE_HP);
PyModule_AddIntConstant(poModule, "AUTO_POTION_TYPE_SP", CPythonPlayer::AUTO_POTION_TYPE_SP);
// 용혼석
PyModule_AddIntConstant(poModule, "DRAGON_SOUL_PAGE_SIZE", c_DragonSoul_Inventory_Box_Size);
PyModule_AddIntConstant(poModule, "DRAGON_SOUL_PAGE_COUNT", DRAGON_SOUL_GRADE_MAX);
PyModule_AddIntConstant(poModule, "DRAGON_SOUL_SLOT_COUNT", c_DragonSoul_Inventory_Count);
PyModule_AddIntConstant(poModule, "DRAGON_SOUL_EQUIPMENT_SLOT_START", c_DragonSoul_Equip_Start);
PyModule_AddIntConstant(poModule, "DRAGON_SOUL_EQUIPMENT_PAGE_COUNT", DS_DECK_MAX_NUM);
PyModule_AddIntConstant(poModule, "DRAGON_SOUL_EQUIPMENT_FIRST_SIZE", c_DragonSoul_Equip_Slot_Max);
// 용혼석 개량창
PyModule_AddIntConstant(poModule, "DRAGON_SOUL_REFINE_CLOSE", DS_SUB_HEADER_CLOSE);
PyModule_AddIntConstant(poModule, "DS_SUB_HEADER_DO_UPGRADE", DS_SUB_HEADER_DO_UPGRADE);
PyModule_AddIntConstant(poModule, "DS_SUB_HEADER_DO_IMPROVEMENT", DS_SUB_HEADER_DO_IMPROVEMENT);
PyModule_AddIntConstant(poModule, "DS_SUB_HEADER_DO_REFINE", DS_SUB_HEADER_DO_REFINE);
#ifdef RENEWAL_DEAD_PACKET
PyModule_AddIntConstant(poModule, "REVIVE_TYPE_HERE", REVIVE_TYPE_HERE);
PyModule_AddIntConstant(poModule, "REVIVE_TYPE_TOWN", REVIVE_TYPE_TOWN);
PyModule_AddIntConstant(poModule, "REVIVE_TYPE_AUTO_TOWN", REVIVE_TYPE_AUTO_TOWN);
PyModule_AddIntConstant(poModule, "REVIVE_TYPE_MAX", REVIVE_TYPE_MAX);
#endif
#ifdef ENABLE_AUTOMATIC_PICK_UP_SYSTEM
PyModule_AddIntConstant(poModule, "AUTOMATIC_PICK_UP_ACTIVATE", AUTOMATIC_PICK_UP_ACTIVATE);
#endif
#ifdef ENABLE_SPECIAL_STORAGE
PyModule_AddIntConstant(poModule, "SLOT_TYPE_UPGRADE_INVENTORY", SLOT_TYPE_UPGRADE_INVENTORY);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_BOOK_INVENTORY", SLOT_TYPE_BOOK_INVENTORY);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_STONE_INVENTORY", SLOT_TYPE_STONE_INVENTORY);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_CHANGE_INVENTORY", SLOT_TYPE_CHANGE_INVENTORY);
PyModule_AddIntConstant(poModule, "SLOT_TYPE_COSTUME_INVENTORY", SLOT_TYPE_COSTUME_INVENTORY);
PyModule_AddIntConstant(poModule, "UPGRADE_INVENTORY", UPGRADE_INVENTORY);
PyModule_AddIntConstant(poModule, "BOOK_INVENTORY", BOOK_INVENTORY);
PyModule_AddIntConstant(poModule, "STONE_INVENTORY", STONE_INVENTORY);
PyModule_AddIntConstant(poModule, "CHANGE_INVENTORY", CHANGE_INVENTORY);
PyModule_AddIntConstant(poModule, "COSTUME_INVENTORY", COSTUME_INVENTORY);
PyModule_AddIntConstant(poModule, "SPECIAL_PAGE_SIZE", c_Special_Inventory_Page_Size);
PyModule_AddIntConstant(poModule, "SPECIAL_PAGE_COUNT", c_Special_Inventory_Page_Count);
PyModule_AddIntConstant(poModule, "SPECIAL_SLOT_COUNT", c_Special_ItemSlot_Count);
#endif
#ifdef ENABLE_BATTLE_PASS
PyModule_AddIntConstant(poModule, "MISSION_NONE", MISSION_NONE);
PyModule_AddIntConstant(poModule, "MISSION_BOSS", MISSION_BOSS);
PyModule_AddIntConstant(poModule, "MISSION_CATCH_FISH", MISSION_CATCH_FISH);
PyModule_AddIntConstant(poModule, "MISSION_CRAFT_ITEM", MISSION_CRAFT_ITEM);
PyModule_AddIntConstant(poModule, "MISSION_CRAFT_GAYA", MISSION_CRAFT_GAYA);
PyModule_AddIntConstant(poModule, "MISSION_DESTROY_ITEM", MISSION_DESTROY_ITEM);
PyModule_AddIntConstant(poModule, "MISSION_DUNGEON", MISSION_DUNGEON);
PyModule_AddIntConstant(poModule, "MISSION_EARN_MONEY", MISSION_EARN_MONEY);
PyModule_AddIntConstant(poModule, "MISSION_FEED_PET", MISSION_FEED_PET);
PyModule_AddIntConstant(poModule, "MISSION_LEVEL_UP", MISSION_LEVEL_UP);
PyModule_AddIntConstant(poModule, "MISSION_MOUNT_TIME", MISSION_MOUNT_TIME);
PyModule_AddIntConstant(poModule, "MISSION_OPEN_OFFLINESHOP", MISSION_OPEN_OFFLINESHOP);
PyModule_AddIntConstant(poModule, "MISSION_PLAYTIME", MISSION_PLAYTIME);
PyModule_AddIntConstant(poModule, "MISSION_REFINE_ITEM", MISSION_REFINE_ITEM);
PyModule_AddIntConstant(poModule, "MISSION_REFINE_ALCHEMY", MISSION_REFINE_ALCHEMY);
PyModule_AddIntConstant(poModule, "MISSION_SASH", MISSION_SASH);
PyModule_AddIntConstant(poModule, "MISSION_SELL_ITEM", MISSION_SELL_ITEM);
PyModule_AddIntConstant(poModule, "MISSION_SPEND_MONEY", MISSION_SPEND_MONEY);
PyModule_AddIntConstant(poModule, "MISSION_SPRITE_STONE", MISSION_SPRITE_STONE);
PyModule_AddIntConstant(poModule, "MISSION_STONE", MISSION_STONE);
PyModule_AddIntConstant(poModule, "MISSION_USE_EMOTICON", MISSION_USE_EMOTICON);
PyModule_AddIntConstant(poModule, "MISSION_WHISPER", MISSION_WHISPER);
PyModule_AddIntConstant(poModule, "MISSION_SHOUT_CHAT", MISSION_SHOUT_CHAT);
PyModule_AddIntConstant(poModule, "MISSION_KILLPLAYER", MISSION_KILLPLAYER);
PyModule_AddIntConstant(poModule, "MISSION_MONSTER", MISSION_MONSTER);
#endif
#ifdef ENABLE_EVENT_MANAGER
PyModule_AddIntConstant(poModule, "BONUS_EVENT", BONUS_EVENT);
PyModule_AddIntConstant(poModule, "DOUBLE_BOSS_LOOT_EVENT", DOUBLE_BOSS_LOOT_EVENT);
PyModule_AddIntConstant(poModule, "DOUBLE_METIN_LOOT_EVENT", DOUBLE_METIN_LOOT_EVENT);
PyModule_AddIntConstant(poModule, "DOUBLE_MISSION_BOOK_EVENT", DOUBLE_MISSION_BOOK_EVENT);
PyModule_AddIntConstant(poModule, "DUNGEON_COOLDOWN_EVENT", DUNGEON_COOLDOWN_EVENT);
PyModule_AddIntConstant(poModule, "DUNGEON_TICKET_LOOT_EVENT", DUNGEON_TICKET_LOOT_EVENT);
PyModule_AddIntConstant(poModule, "EMPIRE_WAR_EVENT", EMPIRE_WAR_EVENT);
PyModule_AddIntConstant(poModule, "MOONLIGHT_EVENT", MOONLIGHT_EVENT);
PyModule_AddIntConstant(poModule, "TOURNAMENT_EVENT", TOURNAMENT_EVENT);
PyModule_AddIntConstant(poModule, "WHELL_OF_FORTUNE_EVENT", WHELL_OF_FORTUNE_EVENT);
PyModule_AddIntConstant(poModule, "HALLOWEEN_EVENT", HALLOWEEN_EVENT);
PyModule_AddIntConstant(poModule, "NPC_SEARCH_EVENT", NPC_SEARCH_EVENT);
PyModule_AddIntConstant(poModule, "EXP_EVENT", EXP_EVENT);
PyModule_AddIntConstant(poModule, "ITEM_DROP_EVENT", ITEM_DROP_EVENT);
PyModule_AddIntConstant(poModule, "YANG_DROP_EVENT", YANG_DROP_EVENT);
PyModule_AddIntConstant(poModule, "CARD_EVENT", CARD_EVENT);
PyModule_AddIntConstant(poModule, "CATCH_KING_EVENT", CATCH_KING_EVENT);
PyModule_AddIntConstant(poModule, "TREASURE_KEY", TREASURE_KEY);
PyModule_AddIntConstant(poModule, "BEGGINER_EVENT", BEGGINER_EVENT);
#endif
#ifdef ENABLE_RARITY
PyModule_AddIntConstant(poModule, "METIN_SOCKET_MAX_NUM_EX", ITEM_SOCKET_SLOT_MAX_NUM_EX);
#endif
#ifdef ENABLE_NEW_DETAILS_GUI
PyModule_AddIntConstant(poModule, "KILL_SHINSO", KILL_SHINSO);
PyModule_AddIntConstant(poModule, "KILL_JINNO", KILL_JINNO);
PyModule_AddIntConstant(poModule, "KILL_CHUNJO", KILL_CHUNJO);
PyModule_AddIntConstant(poModule, "KILL_ALLPLAYER", KILL_ALLPLAYER);
PyModule_AddIntConstant(poModule, "KILL_DUELWON", KILL_DUELWON);
PyModule_AddIntConstant(poModule, "KILL_DUELLOST", KILL_DUELLOST);
PyModule_AddIntConstant(poModule, "KILL_MONSTER", KILL_MONSTER);
PyModule_AddIntConstant(poModule, "KILL_METINSTONE", KILL_METINSTONE);
PyModule_AddIntConstant(poModule, "KILL_BOSSES", KILL_BOSSES);
#endif
#ifdef ENABLE_GEM_SYSTEM
PyModule_AddIntConstant(poModule, "GEM", POINT_GEM);
#endif
}