port 2V2-c: chrmgr/chr modules + race registration chain

PythonCharacterManagerModule/PythonCharacterModule ported verbatim; the
2V0 chr/chrmgr stubs are gone and initchr/initchrmgr run in 40250 order.
The registration chain they need (RaceData/RaceDataFile/RaceManager/
RaceMotionData, GameType, AttributeData/AttributeInstance, TextFileLoader,
Util, Camera/CameraProcedure) is ported; CRaceManager is created in
PythonBoot. port.login_flow asserts race 0 has its wait motions and no
unhandled packet header; port.login_live 8/8 against 192.168.21.203.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
shenlei
2026-09-23 18:40:47 +09:00
co-authored by Claude Opus 5.5
parent 62b6e23bfc
commit 996d793f0c
39 changed files with 8270 additions and 625 deletions
@@ -0,0 +1,354 @@
#include "StdAfx.h"
#include "PythonBackground.h"
#include "../EterLib/Camera.h"
//////////////////////////////////////////////////////////////////////////
// 메세지
extern void SetHeightLog(bool isLog);
float CCamera::CAMERA_MIN_DISTANCE = 200.0f;
float CCamera::CAMERA_MAX_DISTANCE = 2500.0f;
void CCamera::ProcessTerrainCollision()
{
CPythonBackground & rPythonBackground = CPythonBackground::Instance();
D3DXVECTOR3 v3CollisionPoint;
if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kTargetToCameraBottomRay, &v3CollisionPoint))
{
SetCameraState(CAMERA_STATE_CANTGODOWN);
D3DXVECTOR3 v3CheckVector = m_v3Eye - 2.0f * m_fTerrainCollisionRadius * m_v3Up;
v3CheckVector.z = rPythonBackground.GetHeight(floorf(v3CheckVector.x), floorf(v3CheckVector.y));
D3DXVECTOR3 v3NewEye = v3CheckVector + 2.0f * m_fTerrainCollisionRadius * m_v3Up;
if (v3NewEye.z > m_v3Eye.z)
{
//printf("ToCameraBottom(%f, %f, %f) TCR %f, UP(%f, %f, %f), new %f > old %f",
// v3CheckVector.x, v3CheckVector.y, v3CheckVector.z,
// m_fTerrainCollisionRadius,
// m_v3Up.x, m_v3Up.y, m_v3Up.z,
// v3NewEye.z, m_v3Eye.z);
SetEye(v3NewEye);
}
/*
SetCameraState(CAMERA_STATE_NORMAL);
D3DXVECTOR3 v3NewEye = v3CollisionPoint;
SetEye(v3NewEye);
*/
}
else
SetCameraState(CAMERA_STATE_NORMAL);
if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kCameraBottomToTerrainRay, &v3CollisionPoint))
{
SetCameraState(CAMERA_STATE_CANTGODOWN);
auto d3dd = (m_v3Eye - v3CollisionPoint);
if (D3DXVec3Length(&d3dd) < 2.0f * m_fTerrainCollisionRadius)
{
D3DXVECTOR3 v3NewEye = v3CollisionPoint + 2.0f * m_fTerrainCollisionRadius * m_v3Up;
//printf("CameraBottomToTerrain new %f > old %f", v3NewEye.z, m_v3Eye.z);
SetEye(v3NewEye);
}
}
else
SetCameraState(CAMERA_STATE_NORMAL);
/*
if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kCameraFrontToTerrainRay, &v3CollisionPoint))
{
if (D3DXVec3Length(&(m_v3Eye - v3CollisionPoint)) < 4.0f * m_fTerrainCollisionRadius)
{
D3DXVECTOR3 v3NewEye = v3CollisionPoint - 4.0f * m_fTerrainCollisionRadius * m_v3View;
//printf("CameraFrontToTerrain new %f > old %f", v3NewEye.z, m_v3Eye.z);
SetEye(v3NewEye);
}
}
if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kCameraBackToTerrainRay, &v3CollisionPoint))
{
if (D3DXVec3Length(&(m_v3Eye - v3CollisionPoint)) < m_fTerrainCollisionRadius)
{
D3DXVECTOR3 v3NewEye = v3CollisionPoint + m_fTerrainCollisionRadius * m_v3View;
//printf("CameraBackToTerrain new %f > old %f", v3NewEye.z, m_v3Eye.z);
SetEye(v3NewEye);
}
}
// Left
if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kCameraLeftToTerrainRay, &v3CollisionPoint))
{
SetCameraState(CAMERA_STATE_CANTGOLEFT);
if (D3DXVec3Length(&(m_v3Eye - v3CollisionPoint)) < 3.0f * m_fTerrainCollisionRadius)
{
D3DXVECTOR3 v3NewEye = v3CollisionPoint + 3.0f * m_fTerrainCollisionRadius * m_v3Cross;
//printf("CameraLeftToTerrain new %f > old %f", v3NewEye.z, m_v3Eye.z);
SetEye(v3NewEye);
}
}
else
SetCameraState(CAMERA_STATE_NORMAL);
// Right
if (rPythonBackground.GetPickingPointWithRayOnlyTerrain(m_kCameraRightToTerrainRay, &v3CollisionPoint))
{
SetCameraState(CAMERA_STATE_CANTGORIGHT);
if (D3DXVec3Length(&(m_v3Eye - v3CollisionPoint)) < 3.0f * m_fTerrainCollisionRadius)
{
D3DXVECTOR3 v3NewEye = v3CollisionPoint - 3.0f * m_fTerrainCollisionRadius * m_v3Cross;
//printf("CameraRightToTerrain new %f > old %f", v3NewEye.z, m_v3Eye.z);
SetEye(v3NewEye);
}
}
else
SetCameraState(CAMERA_STATE_NORMAL);
*/
}
struct CameraCollisionChecker
{
bool m_isBlocked;
std::vector<D3DXVECTOR3>* m_pkVct_v3Position;
CDynamicSphereInstance * m_pdsi;
CameraCollisionChecker(CDynamicSphereInstance * pdsi, std::vector<D3DXVECTOR3>* pkVct_v3Position) : m_pdsi(pdsi), m_pkVct_v3Position(pkVct_v3Position), m_isBlocked(false)
{
}
void operator () (CGraphicObjectInstance* pOpponent)
{
if (pOpponent->CollisionDynamicSphere(*m_pdsi))
{
m_pkVct_v3Position->push_back(pOpponent->GetPosition());
m_isBlocked = true;
}
}
};
void CCamera::ProcessBuildingCollision()
{
float fMoveAmountSmall = 2.0f;
float fMoveAmountLarge = 4.0f;
D3DXVECTOR3 v3CheckVector;
CDynamicSphereInstance s;
s.fRadius = m_fObjectCollisionRadius;
s.v3LastPosition = m_v3Eye;
Vector3d aVector3d;
aVector3d.Set(m_v3Eye.x, m_v3Eye.y, m_v3Eye.z);
// 뒤
CCullingManager & rkCullingMgr = CCullingManager::Instance();
{
v3CheckVector = m_v3Eye - m_fObjectCollisionRadius * m_v3View;
s.v3Position = v3CheckVector;
std::vector<D3DXVECTOR3> kVct_kPosition;
CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
bool bCollide = kCameraCollisionChecker.m_isBlocked;
if (bCollide)
{
if (m_v3AngularVelocity.y > 0.0f)
{
m_v3AngularVelocity.y = 0.0f;
m_v3AngularVelocity.z += fMoveAmountLarge;
}
// m_v3AngularVelocity.y = fMAX(fMoveAmountSmall, m_v3AngularVelocity.y);
//// m_v3AngularVelocity.y += fMoveAmountSmall;
if (kVct_kPosition.size() > 1)
{
// m_v3AngularVelocity.z = fMAX(fMoveAmountSmall, m_v3AngularVelocity.z);
m_v3AngularVelocity.z += fMoveAmountSmall;
}
else
{
auto d3dd = (kVct_kPosition[0] - m_v3Eye);
D3DXVec3Cross(&v3CheckVector, &d3dd, &m_v3View);
float fDot = D3DXVec3Dot(&v3CheckVector, &m_v3Up);
if (fDot < 0)
{
// m_v3AngularVelocity.x = fMIN(-fMoveAmountSmall, m_v3AngularVelocity.x);
m_v3AngularVelocity.x -= fMoveAmountSmall;
}
else if(fDot > 0)
{
// m_v3AngularVelocity.x = fMAX(fMoveAmountSmall, m_v3AngularVelocity.x);
m_v3AngularVelocity.x += fMoveAmountSmall;
}
else
{
// m_v3AngularVelocity.z = fMAX(fMoveAmountSmall, m_v3AngularVelocity.z);
m_v3AngularVelocity.z += fMoveAmountSmall;
}
}
}
}
// 위
{
v3CheckVector = m_v3Eye + 2.0f * m_fObjectCollisionRadius * m_v3Up;
s.v3Position = v3CheckVector;
std::vector<D3DXVECTOR3> kVct_kPosition;
CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
bool bCollide = kCameraCollisionChecker.m_isBlocked;
if (bCollide)
{
m_v3AngularVelocity.z = fMIN(-fMoveAmountSmall, m_v3AngularVelocity.y);
// m_v3AngularVelocity.z -= 1.0f;
}
}
// 좌
{
v3CheckVector = m_v3Eye + 3.0f * m_fObjectCollisionRadius * m_v3Cross;
s.v3Position = v3CheckVector;
std::vector<D3DXVECTOR3> kVct_kPosition;
CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
bool bCollide = kCameraCollisionChecker.m_isBlocked;
if (bCollide)
{
if (m_v3AngularVelocity.x > 0.0f)
{
m_v3AngularVelocity.x = 0.0f;
m_v3AngularVelocity.y += fMoveAmountLarge;
}
}
}
// 우
{
v3CheckVector = m_v3Eye - 3.0f * m_fObjectCollisionRadius * m_v3Cross;
s.v3Position = v3CheckVector;
std::vector<D3DXVECTOR3> kVct_kPosition;
CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
bool bCollide = kCameraCollisionChecker.m_isBlocked;
if (bCollide)
{
if (m_v3AngularVelocity.x < 0.0f)
{
m_v3AngularVelocity.x = 0.0f;
m_v3AngularVelocity.y += fMoveAmountLarge;
}
}
}
// 아래
{
v3CheckVector = m_v3Eye - 2.0f * m_fTerrainCollisionRadius * m_v3Up;
s.v3Position = v3CheckVector;
std::vector<D3DXVECTOR3> kVct_kPosition;
CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
bool bCollide = kCameraCollisionChecker.m_isBlocked;
if (bCollide)
{
if (m_v3AngularVelocity.z < 0.0f)
{
m_v3AngularVelocity.z = 0.0f;
m_v3AngularVelocity.y += fMoveAmountLarge;
}
}
}
// 앞
{
v3CheckVector = m_v3Eye + 4.0f * m_fObjectCollisionRadius * m_v3View;
s.v3Position = v3CheckVector;
std::vector<D3DXVECTOR3> kVct_kPosition;
CameraCollisionChecker kCameraCollisionChecker(&s, &kVct_kPosition);
rkCullingMgr.ForInRange(aVector3d, m_fObjectCollisionRadius, &kCameraCollisionChecker);
bool bCollide = kCameraCollisionChecker.m_isBlocked;
if (bCollide)
{
if (m_v3AngularVelocity.y < 0.0f)
{
m_v3AngularVelocity.y = 0.0f;
m_v3AngularVelocity.z += fMoveAmountLarge;
}
if (kVct_kPosition.size() > 1)
{
// m_v3AngularVelocity.z = fMAX(fMoveAmountLarge, m_v3AngularVelocity.z);
m_v3AngularVelocity.z += fMoveAmountLarge;
}
else
{
auto d3dd = (kVct_kPosition[0] - m_v3Eye);
D3DXVec3Cross(&v3CheckVector, &d3dd, &m_v3View);
float fDot = D3DXVec3Dot(&v3CheckVector, &m_v3Up);
if (fDot < 0)
{
// m_v3AngularVelocity.x = fMIN(-fMoveAmountSmall, m_v3AngularVelocity.x);
m_v3AngularVelocity.x -= fMoveAmountSmall;
}
else if(fDot > 0)
{
// m_v3AngularVelocity.x = fMAX(fMoveAmountSmall, m_v3AngularVelocity.x);
m_v3AngularVelocity.x += fMoveAmountSmall;
}
else
{
// m_v3AngularVelocity.z = fMAX(fMoveAmountSmall, m_v3AngularVelocity.z);
m_v3AngularVelocity.z += fMoveAmountSmall;
}
}
}
}
}
void CCamera::Update()
{
// ProcessBuildingCollision();
RotateEyeAroundTarget(m_v3AngularVelocity.z, m_v3AngularVelocity.x);
float fNewDistance=fMAX(CAMERA_MIN_DISTANCE, fMIN( CAMERA_MAX_DISTANCE, GetDistance() - m_v3AngularVelocity.y ) );
SetDistance(fNewDistance);
if (m_bProcessTerrainCollision)
ProcessTerrainCollision();
m_v3AngularVelocity *= 0.5f;
if (fabs(m_v3AngularVelocity.x) < 1.0f)
m_v3AngularVelocity.x = 0.0f;
if (fabs(m_v3AngularVelocity.y) < 1.0f)
m_v3AngularVelocity.y = 0.0f;
if (fabs(m_v3AngularVelocity.z) < 1.0f)
m_v3AngularVelocity.z = 0.0f;
const float CAMERA_MOVABLE_DISTANCE = CAMERA_MAX_DISTANCE - CAMERA_MIN_DISTANCE;
const float CAMERA_TARGET_DELTA = CAMERA_TARGET_FACE - CAMERA_TARGET_STANDARD;
float fCameraCurMovableDistance=CAMERA_MAX_DISTANCE - GetDistance();
float fNewTargetHeight = CAMERA_TARGET_STANDARD + CAMERA_TARGET_DELTA * fCameraCurMovableDistance / CAMERA_MOVABLE_DISTANCE;
SetTargetHeight(fNewTargetHeight);
// Cinematic
#ifdef __20040725_CAMERA_WORK__
m_MovementPosition += m_MovementSpeed;
if (0.0f != m_MovementPosition.m_fViewDir)
MoveFront(m_MovementPosition.m_fViewDir);
if (0.0f != m_MovementPosition.m_fCrossDir)
MoveAlongCross(m_MovementPosition.m_fCrossDir);
if (0.0f != m_MovementPosition.m_fUpDir)
MoveVertical(m_MovementPosition.m_fUpDir);
#endif
}
@@ -0,0 +1,844 @@
#include "StdAfx.h"
#include "PythonCharacterManager.h"
#include "PythonBackground.h"
#include "InstanceBase.h"
#include "../GameLib/RaceManager.h"
//////////////////////////////////////////////////////////////////////////
// RaceData 관련 시작
//////////////////////////////////////////////////////////////////////////
PyObject * chrmgrSetEmpireNameMode(PyObject* poSelf, PyObject* poArgs)
{
int iEnable;
if (!PyTuple_GetInteger(poArgs, 0, &iEnable))
return Py_BadArgument();
CInstanceBase::SetEmpireNameMode(iEnable ? true : false);
CPythonCharacterManager::Instance().RefreshAllPCTextTail();
return Py_BuildNone();
}
PyObject * chrmgrRegisterTitleName(PyObject* poSelf, PyObject* poArgs)
{
int iIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
return Py_BadArgument();
char * szTitleName;
if (!PyTuple_GetString(poArgs, 1, &szTitleName))
return Py_BadArgument();
CInstanceBase::RegisterTitleName(iIndex, szTitleName);
return Py_BuildNone();
}
PyObject * chrmgrRegisterNameColor(PyObject* poSelf, PyObject* poArgs)
{
int index;
if (!PyTuple_GetInteger(poArgs, 0, &index))
return Py_BadArgument();
int ir;
if (!PyTuple_GetInteger(poArgs, 1, &ir))
return Py_BadArgument();
int ig;
if (!PyTuple_GetInteger(poArgs, 2, &ig))
return Py_BadArgument();
int ib;
if (!PyTuple_GetInteger(poArgs, 3, &ib))
return Py_BadArgument();
CInstanceBase::RegisterNameColor(index, ir, ig, ib);
return Py_BuildNone();
}
PyObject * chrmgrRegisterTitleColor(PyObject* poSelf, PyObject* poArgs)
{
int iIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iIndex))
return Py_BadArgument();
int ir;
if (!PyTuple_GetInteger(poArgs, 1, &ir))
return Py_BadArgument();
int ig;
if (!PyTuple_GetInteger(poArgs, 2, &ig))
return Py_BadArgument();
int ib;
if (!PyTuple_GetInteger(poArgs, 3, &ib))
return Py_BadArgument();
CInstanceBase::RegisterTitleColor(iIndex, ir, ig, ib);
return Py_BuildNone();
}
PyObject * chrmgrGetPickedVID(PyObject* poSelf, PyObject* poArgs)
{
CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
DWORD dwPickedActorID;
if (rkChrMgr.OLD_GetPickedInstanceVID(&dwPickedActorID))
return Py_BuildValue("i", dwPickedActorID);
else
return Py_BuildValue("i", -1);
}
PyObject * chrmgrGetVIDInfo(PyObject* poSelf, PyObject* poArgs)
{
int nVID;
if (!PyTuple_GetInteger(poArgs, 0, &nVID))
return Py_BadArgument();
CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
char szDetail[256]="";
CInstanceBase* pkInstBase=rkChrMgr.GetInstancePtr(nVID);
if (pkInstBase)
{
TPixelPosition kPPosInst;
pkInstBase->NEW_GetPixelPosition(&kPPosInst);
LONG xInst=kPPosInst.x;
LONG yInst=kPPosInst.y;
CPythonBackground& rkBG=CPythonBackground::Instance();
rkBG.LocalPositionToGlobalPosition(xInst, yInst);
sprintf(szDetail, "pos=(%d, %d)", xInst, yInst);
}
char szInfo[1024];
sprintf(szInfo, "VID %d (isRegistered=%d, isAlive=%d, isDead=%d) %s",
nVID,
rkChrMgr.IsRegisteredVID(nVID),
rkChrMgr.IsAliveVID(nVID),
rkChrMgr.IsDeadVID(nVID),
szDetail
);
return Py_BuildValue("s", szInfo);
}
PyObject * chrmgrSetPathName(PyObject* poSelf, PyObject* poArgs)
{
char * szPathName;
if (!PyTuple_GetString(poArgs, 0, &szPathName))
return Py_BadArgument();
CRaceManager::Instance().SetPathName(szPathName);
return Py_BuildNone();
}
PyObject * chrmgrCreateRace(PyObject * poSelf, PyObject * poArgs)
{
int iRace;
if (!PyTuple_GetInteger(poArgs, 0, &iRace))
return Py_BadArgument();
CRaceManager::Instance().CreateRace(iRace);
return Py_BuildNone();
}
PyObject * chrmgrSelectRace(PyObject * poSelf, PyObject * poArgs)
{
int iRace;
if (!PyTuple_GetInteger(poArgs, 0, &iRace))
return Py_BadArgument();
CRaceManager::Instance().SelectRace(iRace);
return Py_BuildNone();
}
PyObject * chrmgrRegisterAttachingBoneName(PyObject * poSelf, PyObject * poArgs)
{
int iPartIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iPartIndex))
return Py_BadArgument();
char * szBoneName;
if (!PyTuple_GetString(poArgs, 1, &szBoneName))
return Py_BadArgument();
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
if (!pRaceData)
return Py_BuildException("RaceData has not selected!");
pRaceData->RegisterAttachingBoneName(iPartIndex, szBoneName);
return Py_BuildNone();
}
PyObject * chrmgrRegisterMotionMode(PyObject* poSelf, PyObject* poArgs)
{
int iMotionIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iMotionIndex))
return Py_BadArgument();
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
if (!pRaceData)
return Py_BuildException("RaceData has not selected!");
pRaceData->RegisterMotionMode(iMotionIndex);
return Py_BuildNone();
}
PyObject * chrmgrSetMotionRandomWeight(PyObject* poSelf, PyObject* poArgs)
{
int iMode;
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
return Py_BadArgument();
int iMotion;
if (!PyTuple_GetInteger(poArgs, 1, &iMotion))
return Py_BadArgument();
int iSubMotion;
if (!PyTuple_GetInteger(poArgs, 2, &iSubMotion))
return Py_BadArgument();
int iPercentage;
if (!PyTuple_GetInteger(poArgs, 3, &iPercentage))
return Py_BadArgument();
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
if (!pRaceData)
return Py_BuildException("RaceData has not selected!");
if (!pRaceData->SetMotionRandomWeight(iMode, iMotion, iSubMotion, iPercentage))
Py_BuildException("Failed to SetMotionRandomWeight");
return Py_BuildNone();
}
PyObject * chrmgrRegisterNormalAttack(PyObject* poSelf, PyObject* poArgs)
{
int iMode;
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
return Py_BadArgument();
int iMotion;
if (!PyTuple_GetInteger(poArgs, 1, &iMotion))
return Py_BadArgument();
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
if (!pRaceData)
return Py_BuildException("RaceData has not selected!");
pRaceData->RegisterNormalAttack(iMode, iMotion);
return Py_BuildNone();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// 없어질 함수들
PyObject * chrmgrReserveComboAttack(PyObject* poSelf, PyObject* poArgs)
{
int iMode;
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
return Py_BadArgument();
int iCount;
if (!PyTuple_GetInteger(poArgs, 1, &iCount))
return Py_BadArgument();
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
if (!pRaceData)
return Py_BuildException("RaceData has not selected!");
pRaceData->ReserveComboAttack(iMode, 0, iCount);
return Py_BuildNone();
}
PyObject * chrmgrRegisterComboAttack(PyObject* poSelf, PyObject* poArgs)
{
int iMode;
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
return Py_BadArgument();
int iComboIndex;
if (!PyTuple_GetInteger(poArgs, 1, &iComboIndex))
return Py_BadArgument();
int iMotionIndex;
if (!PyTuple_GetInteger(poArgs, 2, &iMotionIndex))
return Py_BadArgument();
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
if (!pRaceData)
return Py_BuildException("RaceData has not selected!");
pRaceData->RegisterComboAttack(iMode, 0, iComboIndex, iMotionIndex);
return Py_BuildNone();
}
// 없어질 함수들
///////////////////////////////////////////////////////////////////////////////////////////////////
PyObject * chrmgrReserveComboAttackNew(PyObject* poSelf, PyObject* poArgs)
{
int iMotionMode;
if (!PyTuple_GetInteger(poArgs, 0, &iMotionMode))
return Py_BadArgument();
int iComboType;
if (!PyTuple_GetInteger(poArgs, 1, &iComboType))
return Py_BadArgument();
int iCount;
if (!PyTuple_GetInteger(poArgs, 2, &iCount))
return Py_BadArgument();
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
if (!pRaceData)
return Py_BuildException("RaceData has not selected!");
pRaceData->ReserveComboAttack(iMotionMode, iComboType, iCount);
return Py_BuildNone();
}
PyObject * chrmgrRegisterComboAttackNew(PyObject* poSelf, PyObject* poArgs)
{
int iMotionMode;
if (!PyTuple_GetInteger(poArgs, 0, &iMotionMode))
return Py_BadArgument();
int iComboType;
if (!PyTuple_GetInteger(poArgs, 1, &iComboType))
return Py_BadArgument();
int iComboIndex;
if (!PyTuple_GetInteger(poArgs, 2, &iComboIndex))
return Py_BadArgument();
int iMotionIndex;
if (!PyTuple_GetInteger(poArgs, 3, &iMotionIndex))
return Py_BadArgument();
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
if (!pRaceData)
return Py_BuildException("RaceData has not selected!");
pRaceData->RegisterComboAttack(iMotionMode, iComboType, iComboIndex, iMotionIndex);
return Py_BuildNone();
}
PyObject * chrmgrLoadRaceData(PyObject* poSelf, PyObject* poArgs)
{
char* szFileName;
if (!PyTuple_GetString(poArgs, 0, &szFileName))
return Py_BadArgument();
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
if (!pRaceData)
return Py_BuildException("RaceData has not selected!");
const char * c_szFullFileName = CRaceManager::Instance().GetFullPathFileName(szFileName);
if (!pRaceData->LoadRaceData(c_szFullFileName))
{
TraceError("Failed to load race data : %s\n", c_szFullFileName);
}
return Py_BuildNone();
}
PyObject * chrmgrLoadLocalRaceData(PyObject* poSelf, PyObject* poArgs)
{
char* szFileName;
if (!PyTuple_GetString(poArgs, 0, &szFileName))
return Py_BadArgument();
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
if (!pRaceData)
return Py_BuildException("RaceData has not selected!");
if (!pRaceData->LoadRaceData(szFileName))
{
TraceError("Failed to load race data : %s\n", szFileName);
}
return Py_BuildNone();
}
/*
PyObject * chrmgrRegisterMotion(PyObject* poSelf, PyObject* poArgs)
{
int iMode;
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
return Py_BadArgument();
int iMotion;
if (!PyTuple_GetInteger(poArgs, 1, &iMotion))
return Py_BadArgument();
char* szFileName;
if (!PyTuple_GetString(poArgs, 2, &szFileName))
return Py_BadArgument();
int iWeight = 0;
PyTuple_GetInteger(poArgs, 3, &iWeight);
iWeight = MIN(100, iWeight);
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
if (!pRaceData)
return Py_BuildException("RaceData has not selected!");
pRaceData->NEW_RegisterMotion(iMode, iMotion, CRaceManager::Instance().GetFullPathFileName(szFileName), iWeight);
return Py_BuildNone();
}
*/
PyObject * chrmgrRegisterCacheMotionData(PyObject* poSelf, PyObject* poArgs)
{
int iMode;
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
return Py_BadArgument();
int iMotion;
if (!PyTuple_GetInteger(poArgs, 1, &iMotion))
return Py_BadArgument();
char * szFileName;
if (!PyTuple_GetString(poArgs, 2, &szFileName))
return Py_BadArgument();
int iWeight = 0;
PyTuple_GetInteger(poArgs, 3, &iWeight);
iWeight = MIN(100, iWeight);
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
if (!pRaceData)
return Py_BuildException("RaceData has not selected!");
const char * c_szFullFileName = CRaceManager::Instance().GetFullPathFileName(szFileName);
CGraphicThing* pkMotionThing=pRaceData->RegisterMotionData(iMode, iMotion, c_szFullFileName, iWeight);
if (pkMotionThing)
CResourceManager::Instance().LoadStaticCache(pkMotionThing->GetFileName());
return Py_BuildNone();
}
PyObject * chrmgrRegisterMotionData(PyObject* poSelf, PyObject* poArgs)
{
int iMode;
if (!PyTuple_GetInteger(poArgs, 0, &iMode))
return Py_BadArgument();
int iMotion;
if (!PyTuple_GetInteger(poArgs, 1, &iMotion))
return Py_BadArgument();
char * szFileName;
if (!PyTuple_GetString(poArgs, 2, &szFileName))
return Py_BadArgument();
int iWeight = 0;
PyTuple_GetInteger(poArgs, 3, &iWeight);
iWeight = MIN(100, iWeight);
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
if (!pRaceData)
return Py_BuildException("RaceData has not selected!");
const char * c_szFullFileName = CRaceManager::Instance().GetFullPathFileName(szFileName);
pRaceData->RegisterMotionData(iMode, iMotion, c_szFullFileName, iWeight);
return Py_BuildNone();
}
PyObject * chrmgrRegisterRaceSrcName(PyObject* poSelf, PyObject* poArgs)
{
char * szName;
if (!PyTuple_GetString(poArgs, 0, &szName))
return Py_BadArgument();
char * szSrcName;
if (!PyTuple_GetString(poArgs, 1, &szSrcName))
return Py_BadArgument();
CRaceManager::Instance().RegisterRaceSrcName(szName, szSrcName);
return Py_BuildNone();
}
PyObject * chrmgrRegisterRaceName(PyObject* poSelf, PyObject* poArgs)
{
int iRaceIndex;
if (!PyTuple_GetInteger(poArgs, 0, &iRaceIndex))
return Py_BadArgument();
char * szName;
if (!PyTuple_GetString(poArgs, 1, &szName))
return Py_BadArgument();
CRaceManager::Instance().RegisterRaceName(iRaceIndex, szName);
return Py_BuildNone();
}
PyObject * chrmgrSetShapeModel(PyObject* poSelf, PyObject* poArgs)
{
int eShape;
if (!PyTuple_GetInteger(poArgs, 0, &eShape))
return Py_BadArgument();
char * szFileName;
if (!PyTuple_GetString(poArgs, 1, &szFileName))
return Py_BadArgument();
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
if (!pRaceData)
return Py_BuildException("RaceData has not selected!");
pRaceData->SetShapeModel(eShape, szFileName);
return Py_BuildNone();
}
PyObject * chrmgrAppendShapeSkin(PyObject* poSelf, PyObject* poArgs)
{
int eShape;
if (!PyTuple_GetInteger(poArgs, 0, &eShape))
return Py_BadArgument();
int ePart;
if (!PyTuple_GetInteger(poArgs, 1, &ePart))
return Py_BadArgument();
char * szSrcFileName;
if (!PyTuple_GetString(poArgs, 2, &szSrcFileName))
return Py_BadArgument();
char * szDstFileName;
if (!PyTuple_GetString(poArgs, 3, &szDstFileName))
return Py_BadArgument();
CRaceData * pRaceData = CRaceManager::Instance().GetSelectedRaceDataPointer();
if (!pRaceData)
return Py_BuildException("RaceData has not selected!");
pRaceData->AppendShapeSkin(eShape, ePart, szSrcFileName, szDstFileName);
return Py_BuildNone();
}
//////////////////////////////////////////////////////////////////////////
// RaceData 관련 끝
//////////////////////////////////////////////////////////////////////////
PyObject * chrmgrSetMovingSpeed(PyObject* poSelf, PyObject* poArgs)
{
#ifndef _DISTRIBUTE
int nMovSpd;
if (!PyTuple_GetInteger(poArgs, 0, &nMovSpd))
return Py_BadArgument();
if (nMovSpd<0)
return Py_BuildException("MovingSpeed < 0");
CInstanceBase * pkInst = CPythonCharacterManager::Instance().GetSelectedInstancePtr();
if (!pkInst)
return Py_BuildException("MainCharacter has not selected!");
pkInst->SetMoveSpeed(nMovSpd);
#endif
return Py_BuildNone();
}
PyObject * chrmgrRegisterEffect(PyObject* poSelf, PyObject* poArgs)
{
int eEftType;
if (!PyTuple_GetInteger(poArgs, 0, &eEftType))
return Py_BadArgument();
char * szBoneName;
if (!PyTuple_GetString(poArgs, 1, &szBoneName))
return Py_BadArgument();
char * szPathName;
if (!PyTuple_GetString(poArgs, 2, &szPathName))
return Py_BadArgument();
CInstanceBase::RegisterEffect(eEftType, szBoneName, szPathName, false);
return Py_BuildNone();
}
PyObject * chrmgrRegisterCacheEffect(PyObject* poSelf, PyObject* poArgs)
{
int eEftType;
if (!PyTuple_GetInteger(poArgs, 0, &eEftType))
return Py_BadArgument();
char * szBoneName;
if (!PyTuple_GetString(poArgs, 1, &szBoneName))
return Py_BadArgument();
char * szPathName;
if (!PyTuple_GetString(poArgs, 2, &szPathName))
return Py_BadArgument();
CInstanceBase::RegisterEffect(eEftType, szBoneName, szPathName, true);
return Py_BuildNone();
}
PyObject * chrmgrSetDustGap(PyObject* poSelf, PyObject* poArgs)
{
int nGap;
if (!PyTuple_GetInteger(poArgs, 0, &nGap))
return Py_BadArgument();
CInstanceBase::SetDustGap(nGap);
return Py_BuildNone();
}
PyObject * chrmgrSetHorseDustGap(PyObject* poSelf, PyObject* poArgs)
{
int nGap;
if (!PyTuple_GetInteger(poArgs, 0, &nGap))
return Py_BadArgument();
CInstanceBase::SetHorseDustGap(nGap);
return Py_BuildNone();
}
PyObject * chrmgrToggleDirectionLine(PyObject* poSelf, PyObject* poArgs)
{
static bool s_isVisible=true;
CActorInstance::ShowDirectionLine(s_isVisible);
s_isVisible=!s_isVisible;
return Py_BuildNone();
}
PyObject * chrmgrRegisterPointEffect(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();
CPythonCharacterManager& rkChrMgr=CPythonCharacterManager::Instance();
rkChrMgr.RegisterPointEffect(iEft, szFileName);
return Py_BuildNone();
}
PyObject * chrmgrShowPointEffect(PyObject* poSelf, PyObject* poArgs)
{
int nVID;
if (!PyTuple_GetInteger(poArgs, 0, &nVID))
return Py_BadArgument();
int nEft;
if (!PyTuple_GetInteger(poArgs, 1, &nEft))
return Py_BadArgument();
CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
rkChrMgr.ShowPointEffect(nEft, nVID >= 0 ? nVID : 0xffffffff);
return Py_BuildNone();
}
void CPythonCharacterManager::SCRIPT_SetAffect(DWORD dwVID, DWORD eState, BOOL isVisible)
{
CInstanceBase * pkInstSel = (dwVID == 0xffffffff) ? GetSelectedInstancePtr() : GetInstancePtr(dwVID);
if (!pkInstSel)
return;
pkInstSel->SCRIPT_SetAffect(eState, isVisible ? true : false);
}
PyObject * chrmgrSetAffect(PyObject* poSelf, PyObject* poArgs)
{
int nVID;
if (!PyTuple_GetInteger(poArgs, 0, &nVID))
return Py_BadArgument();
int nEft;
if (!PyTuple_GetInteger(poArgs, 1, &nEft))
return Py_BadArgument();
int nVisible;
if (!PyTuple_GetInteger(poArgs, 2, &nVisible))
return Py_BadArgument();
CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
rkChrMgr.SCRIPT_SetAffect(nVID >= 0 ? nVID : 0xffffffff, nEft, nVisible);
return Py_BuildNone();
}
void CPythonCharacterManager::SetEmoticon(DWORD dwVID, DWORD eState)
{
CInstanceBase * pkInstSel = (dwVID == 0xffffffff) ? GetSelectedInstancePtr() : GetInstancePtr(dwVID);
if (!pkInstSel)
return;
pkInstSel->SetEmoticon(eState);
}
bool CPythonCharacterManager::IsPossibleEmoticon(DWORD dwVID)
{
CInstanceBase * pkInstSel = (dwVID == 0xffffffff) ? GetSelectedInstancePtr() : GetInstancePtr(dwVID);
if (!pkInstSel)
return false;
return pkInstSel->IsPossibleEmoticon();
}
PyObject * chrmgrSetEmoticon(PyObject* poSelf, PyObject* poArgs)
{
int nVID;
if (!PyTuple_GetInteger(poArgs, 0, &nVID))
return Py_BadArgument();
int nEft;
if (!PyTuple_GetInteger(poArgs, 1, &nEft))
return Py_BadArgument();
CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
rkChrMgr.SetEmoticon(nVID >= 0 ? nVID : 0xffffffff, nEft);
return Py_BuildNone();
}
PyObject * chrmgrIsPossibleEmoticon(PyObject* poSelf, PyObject* poArgs)
{
int nVID;
if (!PyTuple_GetInteger(poArgs, 0, &nVID))
return Py_BadArgument();
CPythonCharacterManager & rkChrMgr = CPythonCharacterManager::Instance();
int result = rkChrMgr.IsPossibleEmoticon(nVID >= 0 ? nVID : 0xffffffff);
return Py_BuildValue("i", result);
}
void initchrmgr()
{
static PyMethodDef s_methods[] =
{
// RaceData 관련
{ "SetEmpireNameMode", chrmgrSetEmpireNameMode, METH_VARARGS },
{ "GetVIDInfo", chrmgrGetVIDInfo, METH_VARARGS },
{ "GetPickedVID", chrmgrGetPickedVID, METH_VARARGS },
{ "SetShapeModel", chrmgrSetShapeModel, METH_VARARGS },
{ "AppendShapeSkin", chrmgrAppendShapeSkin, METH_VARARGS },
{ "SetPathName", chrmgrSetPathName, METH_VARARGS },
{ "LoadRaceData", chrmgrLoadRaceData, METH_VARARGS },
{ "LoadLocalRaceData", chrmgrLoadLocalRaceData, METH_VARARGS },
{ "CreateRace", chrmgrCreateRace, METH_VARARGS },
{ "SelectRace", chrmgrSelectRace, METH_VARARGS },
{ "RegisterAttachingBoneName", chrmgrRegisterAttachingBoneName, METH_VARARGS },
{ "RegisterMotionMode", chrmgrRegisterMotionMode, METH_VARARGS },
//{ "RegisterMotion", chrmgrRegisterMotion, METH_VARARGS },
{ "SetMotionRandomWeight", chrmgrSetMotionRandomWeight, METH_VARARGS },
{ "RegisterNormalAttack", chrmgrRegisterNormalAttack, METH_VARARGS },
{ "ReserveComboAttack", chrmgrReserveComboAttack, METH_VARARGS },
{ "RegisterComboAttack", chrmgrRegisterComboAttack, METH_VARARGS },
{ "ReserveComboAttackNew", chrmgrReserveComboAttackNew, METH_VARARGS },
{ "RegisterComboAttackNew", chrmgrRegisterComboAttackNew, METH_VARARGS },
{ "RegisterMotionData", chrmgrRegisterMotionData, METH_VARARGS },
{ "RegisterRaceName", chrmgrRegisterRaceName, METH_VARARGS },
{ "RegisterRaceSrcName", chrmgrRegisterRaceSrcName, METH_VARARGS },
{ "RegisterCacheMotionData", chrmgrRegisterCacheMotionData, METH_VARARGS },
// ETC
{ "SetAffect", chrmgrSetAffect, METH_VARARGS },
{ "SetEmoticon", chrmgrSetEmoticon, METH_VARARGS },
{ "IsPossibleEmoticon", chrmgrIsPossibleEmoticon, METH_VARARGS },
{ "RegisterEffect", chrmgrRegisterEffect, METH_VARARGS },
{ "RegisterCacheEffect", chrmgrRegisterCacheEffect, METH_VARARGS },
{ "RegisterPointEffect", chrmgrRegisterPointEffect, METH_VARARGS },
{ "ShowPointEffect", chrmgrShowPointEffect, METH_VARARGS },
{ "ToggleDirectionLine", chrmgrToggleDirectionLine, METH_VARARGS },
{ "SetMovingSpeed", chrmgrSetMovingSpeed, METH_VARARGS },
{ "SetDustGap", chrmgrSetDustGap, METH_VARARGS },
{ "SetHorseDustGap", chrmgrSetHorseDustGap, METH_VARARGS },
{ "RegisterTitleName", chrmgrRegisterTitleName, METH_VARARGS },
{ "RegisterNameColor", chrmgrRegisterNameColor, METH_VARARGS },
{ "RegisterTitleColor", chrmgrRegisterTitleColor, METH_VARARGS },
{ NULL, NULL, NULL },
};
PyObject * poModule = Py_InitModule("chrmgr", s_methods);
PyModule_AddIntConstant(poModule, "NAMECOLOR_MOB", CInstanceBase::NAMECOLOR_NORMAL_MOB);
PyModule_AddIntConstant(poModule, "NAMECOLOR_NPC", CInstanceBase::NAMECOLOR_NORMAL_NPC);
PyModule_AddIntConstant(poModule, "NAMECOLOR_PC", CInstanceBase::NAMECOLOR_NORMAL_PC);
PyModule_AddIntConstant(poModule, "NAMECOLOR_EMPIRE_MOB", CInstanceBase::NAMECOLOR_EMPIRE_MOB);
PyModule_AddIntConstant(poModule, "NAMECOLOR_EMPIRE_NPC", CInstanceBase::NAMECOLOR_EMPIRE_NPC);
PyModule_AddIntConstant(poModule, "NAMECOLOR_EMPIRE_PC", CInstanceBase::NAMECOLOR_EMPIRE_PC);
PyModule_AddIntConstant(poModule, "NAMECOLOR_FUNC", CInstanceBase::NAMECOLOR_FUNC);
PyModule_AddIntConstant(poModule, "NAMECOLOR_PK", CInstanceBase::NAMECOLOR_PK);
PyModule_AddIntConstant(poModule, "NAMECOLOR_PVP", CInstanceBase::NAMECOLOR_PVP);
PyModule_AddIntConstant(poModule, "NAMECOLOR_PARTY", CInstanceBase::NAMECOLOR_PARTY);
PyModule_AddIntConstant(poModule, "NAMECOLOR_WARP", CInstanceBase::NAMECOLOR_WARP);
PyModule_AddIntConstant(poModule, "NAMECOLOR_WAYPOINT", CInstanceBase::NAMECOLOR_WAYPOINT);
PyModule_AddIntConstant(poModule, "NAMECOLOR_EXTRA", CInstanceBase::NAMECOLOR_EXTRA);
PyModule_AddIntConstant(poModule, "EFFECT_SPAWN_DISAPPEAR", CInstanceBase::EFFECT_SPAWN_DISAPPEAR);
PyModule_AddIntConstant(poModule, "EFFECT_SPAWN_APPEAR", CInstanceBase::EFFECT_SPAWN_APPEAR);
PyModule_AddIntConstant(poModule, "EFFECT_DUST", CInstanceBase::EFFECT_DUST);
PyModule_AddIntConstant(poModule, "EFFECT_HORSE_DUST", CInstanceBase::EFFECT_HORSE_DUST);
PyModule_AddIntConstant(poModule, "EFFECT_STUN", CInstanceBase::EFFECT_STUN);
PyModule_AddIntConstant(poModule, "EFFECT_HIT", CInstanceBase::EFFECT_HIT);
PyModule_AddIntConstant(poModule, "EFFECT_FLAME_ATTACK", CInstanceBase::EFFECT_FLAME_ATTACK);
PyModule_AddIntConstant(poModule, "EFFECT_FLAME_HIT", CInstanceBase::EFFECT_FLAME_HIT);
PyModule_AddIntConstant(poModule, "EFFECT_FLAME_ATTACH", CInstanceBase::EFFECT_FLAME_ATTACH);
PyModule_AddIntConstant(poModule, "EFFECT_ELECTRIC_ATTACK", CInstanceBase::EFFECT_ELECTRIC_ATTACK);
PyModule_AddIntConstant(poModule, "EFFECT_ELECTRIC_HIT", CInstanceBase::EFFECT_ELECTRIC_HIT);
PyModule_AddIntConstant(poModule, "EFFECT_ELECTRIC_ATTACH", CInstanceBase::EFFECT_ELECTRIC_ATTACH);
PyModule_AddIntConstant(poModule, "EFFECT_SELECT", CInstanceBase::EFFECT_SELECT);
PyModule_AddIntConstant(poModule, "EFFECT_TARGET", CInstanceBase::EFFECT_TARGET);
PyModule_AddIntConstant(poModule, "EFFECT_CRITICAL", CInstanceBase::EFFECT_CRITICAL);
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_TARGET", CInstanceBase::EFFECT_DAMAGE_TARGET);
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_NOT_TARGET", CInstanceBase::EFFECT_DAMAGE_NOT_TARGET);
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_SELFDAMAGE", CInstanceBase::EFFECT_DAMAGE_SELFDAMAGE);
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_SELFDAMAGE2", CInstanceBase::EFFECT_DAMAGE_SELFDAMAGE2);
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_POISON", CInstanceBase::EFFECT_DAMAGE_POISON);
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_MISS", CInstanceBase::EFFECT_DAMAGE_MISS);
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_TARGETMISS", CInstanceBase::EFFECT_DAMAGE_TARGETMISS);
PyModule_AddIntConstant(poModule, "EFFECT_DAMAGE_CRITICAL", CInstanceBase::EFFECT_DAMAGE_CRITICAL);
PyModule_AddIntConstant(poModule, "EFFECT_LEVELUP", CInstanceBase::EFFECT_LEVELUP);
PyModule_AddIntConstant(poModule, "EFFECT_SKILLUP", CInstanceBase::EFFECT_SKILLUP);
PyModule_AddIntConstant(poModule, "EFFECT_HPUP_RED", CInstanceBase::EFFECT_HPUP_RED);
PyModule_AddIntConstant(poModule, "EFFECT_SPUP_BLUE", CInstanceBase::EFFECT_SPUP_BLUE);
PyModule_AddIntConstant(poModule, "EFFECT_SPEEDUP_GREEN", CInstanceBase::EFFECT_SPEEDUP_GREEN);
PyModule_AddIntConstant(poModule, "EFFECT_DXUP_PURPLE", CInstanceBase::EFFECT_DXUP_PURPLE);
PyModule_AddIntConstant(poModule, "EFFECT_PENETRATE", CInstanceBase::EFFECT_PENETRATE);
PyModule_AddIntConstant(poModule, "EFFECT_BLOCK", CInstanceBase::EFFECT_BLOCK);
PyModule_AddIntConstant(poModule, "EFFECT_DODGE", CInstanceBase::EFFECT_DODGE);
PyModule_AddIntConstant(poModule, "EFFECT_FIRECRACKER", CInstanceBase::EFFECT_FIRECRACKER);
PyModule_AddIntConstant(poModule, "EFFECT_SPIN_TOP", CInstanceBase::EFFECT_SPIN_TOP);
PyModule_AddIntConstant(poModule, "EFFECT_WEAPON", CInstanceBase::EFFECT_WEAPON);
PyModule_AddIntConstant(poModule, "EFFECT_AFFECT", CInstanceBase::EFFECT_AFFECT);
PyModule_AddIntConstant(poModule, "EFFECT_EMOTICON", CInstanceBase::EFFECT_EMOTICON);
PyModule_AddIntConstant(poModule, "EFFECT_EMPIRE", CInstanceBase::EFFECT_EMPIRE);
PyModule_AddIntConstant(poModule, "EFFECT_REFINED", CInstanceBase::EFFECT_REFINED);
PyModule_AddIntConstant(poModule, "EFFECT_SUCCESS", CInstanceBase::EFFECT_SUCCESS) ;
PyModule_AddIntConstant(poModule, "EFFECT_FAIL", CInstanceBase::EFFECT_FAIL) ;
PyModule_AddIntConstant(poModule, "EFFECT_FR_SUCCESS", CInstanceBase::EFFECT_FR_SUCCESS) ;
PyModule_AddIntConstant(poModule, "EFFECT_LEVELUP_ON_14_FOR_GERMANY", CInstanceBase::EFFECT_LEVELUP_ON_14_FOR_GERMANY ); //레벨업 14일때 ( 독일전용 )
PyModule_AddIntConstant(poModule, "EFFECT_LEVELUP_UNDER_15_FOR_GERMANY", CInstanceBase::EFFECT_LEVELUP_UNDER_15_FOR_GERMANY );//레벨업 15일때 ( 독일전용 )
PyModule_AddIntConstant(poModule, "EFFECT_PERCENT_DAMAGE1", CInstanceBase::EFFECT_PERCENT_DAMAGE1);
PyModule_AddIntConstant(poModule, "EFFECT_PERCENT_DAMAGE2", CInstanceBase::EFFECT_PERCENT_DAMAGE2);
PyModule_AddIntConstant(poModule, "EFFECT_PERCENT_DAMAGE3", CInstanceBase::EFFECT_PERCENT_DAMAGE3);
// 자동물약 HP, SP
PyModule_AddIntConstant(poModule, "EFFECT_AUTO_HPUP", CInstanceBase::EFFECT_AUTO_HPUP);
PyModule_AddIntConstant(poModule, "EFFECT_AUTO_SPUP", CInstanceBase::EFFECT_AUTO_SPUP);
PyModule_AddIntConstant(poModule, "EFFECT_RAMADAN_RING_EQUIP", CInstanceBase::EFFECT_RAMADAN_RING_EQUIP);
PyModule_AddIntConstant(poModule, "EFFECT_HALLOWEEN_CANDY_EQUIP", CInstanceBase::EFFECT_HALLOWEEN_CANDY_EQUIP);
PyModule_AddIntConstant(poModule, "EFFECT_HAPPINESS_RING_EQUIP", CInstanceBase::EFFECT_HAPPINESS_RING_EQUIP);
PyModule_AddIntConstant(poModule, "EFFECT_LOVE_PENDANT_EQUIP", CInstanceBase::EFFECT_LOVE_PENDANT_EQUIP);
}
File diff suppressed because it is too large Load Diff
@@ -44,5 +44,7 @@ enum
// Listed here as 40250 lists them; only the ported ones are defined.
void initpack();
void initapp();
void initchr();
void initchrmgr();
void initChat();
void initnet();